If you’ve made it this far – we will save our discussion of Redundancy & RAID arrays for part 2 and Incremental vs. Differential backups for part 3 of our series on I/O & backups.

With Android 4.2 installed, go to ‘Settings’ and select ‘Users’ from the Interface column.  Click on the ‘ADD USER’ button to create a new account.  To switch between accounts, turn the screen off with a press of the power button, then wake the device with another press of the power button.

The lock screen now shows both of your user accounts at the bottom, simply click the user account you want to use and login.  Each user account can have its own password, so multiple people can share the same tablet.  Each user account is able to install all of its own separate applications.

Just install instagram once on each user account, and you can switch android users to switch between the two logged in instagram accounts.

User Account 1:

User Account 2:

First Impressions

The 7” form factor for tablets is the sweet spot for touch/tablet computing. It is small enough to fit in a backpack or messenger bag with ease and not displace other important objects you need to carry around (notebooks – of the paper variety and “dead trees” aka books). The lightweight and durable materials used in its construction make it feel sturdy – but not cheap. I am a fan of rubberized coatings as they allow for a comfortable feel in the hands and provide a solid grip that cannot be found on glossy plastic or metal. ASUS managed to blend these features together well in their execution of the Nexus 7, allowing for long term one handed use. The front facing camera provides a quality (enough) picture for videoconferencing. The lack of physical buttons on the face is strange (like a home button), however this is quickly forgotten as one becomes accustomed to the device. [Editor's Note: I've yet to suffer a total system hardlock. I'm keeping my fingers crossed.]

Props

I received this the day Android 4.2 was released, so as soon as I fired it up I was already downloading the updates for the OS. It felt fast and responsive – setting up all of your accounts was very easy, especially if you already have an existing Google account. The Android marketplace is diverse with its offerings, and you can get some great open source software for your tablet if you choose to get it. As a Nexus device, it runs the vanilla version of the Android OS. As the Google flagship device, you can count on hardware and device driver support from developers. While I have not tested any custom ROMs for it yet, the fact that I can excites me greatly. The freedom to do what you want with your device and run the software you want is something I wish Apple would consider (Yes – I understand the walled garden approach but I believe they would see increased revenue from hardware sales if more software was compatible with their hardware.) I would hope to see a privacy and security focused ROM distro ala SELinux released for the tablet by the open source community. Once I get time – I will probably try out a few custom ROMs and end up writing a review about them.

Reading on this tablet is very nice, as the screen adjusts its brightness based on ambient light to conserve battery. Adobe offers its full suite of “free” products for the device (Flash and Acrobat Reader) so you can use this in a manner that is nearly identical to a browser on a laptop or a PC. My eBooks all work well on the device and it is nice to be able to carry around a large library of information (all of my computer books and research white papers).

Gripes

The 8GB is a bit cramped once all of your OS updates are installed and you download all of your applications from either the Google Play Store or your synced Google account. I am wondering why a discrete SD card slot was forgone, but based on my limited research this seems to be a recurring theme from new android devices going forward as apparently support for the reader is difficult in the fragmented Android device market.

“App Bleed”

Here I would like to draw attention to a term for a phenomenon I am calling “app bleed”. App bleed occurs when what should be a compartmentalized application ends up sharing data with other applications installed on your system. [Editor's Note: I realize this is just a file/access permissions problem - however I find app developers advertising this type of behavior as a "feature" to be a dumb idea.] This problem worsens when you store your credentials in the application and it does things automatically without your knowledge. For example, if you are logged into FaceBook and go to some website and read an article and it automatically shares that article with your FaceBook friends or some purchase you made on amazon.com gets tweeted to your Twitter followers. Many of these apps check for each other and want to share data between themselves. I STRONGLY dislike applications that share data with each other – unless I explicitly tell them this is OK. I like all of my apps separate from each other because I want to know where my data is being stored at all times. The future seems to be trending toward greater integration of social media/email/scheduling programs all sharing data with each other – so it looks like people like me are left out in the cold.

Conclusions

The Nexus 7 has just the right blend of features and price making it too compelling to pass up if you are in the market for a multimedia widget. It does everything it aims to do extremely well. If you see yourself needing a cheap device to consume web or social media content – this is the best one for the task. I will look forward to using my Nexus 7 for months to come. Stay tuned for my reviews on custom ROMS – coming in a few months! [Editor's Note: Probably a bit longer.]

I have been building a Social Networking style website in Django and recently received multiple 500 error reports due to users not having proper variables set.  I found the default 500 error email to be rather lacking with clues as to which users were actually causing the 500 errors, so I used the snippet above to add the request.user.username and request.user.email variables to 500 tracebacks for authenticated users.

Thanks to the Author Sid for a very useful piece of code.

To get this working, I created a new app called errorreporting, and pasted the following code into a file called middleware.py inside the errorreporting folder:

class ExceptionUserInfoMiddleware(object):
    """
Adds user details to request context on receiving an exception, so that they show up in the error emails.
Add to settings.MIDDLEWARE_CLASSES and keep it outermost(i.e. on top if possible). This allows
it to catch exceptions in other middlewares as well.
"""

    def process_exception(self, request, exception):
        """
Process the exception.

  arameters:
- `request`: request that caused the exception
- `exception`: actual exception being raised
"""

        try:
            if request.user.is_authenticated():
                request.META['USERNAME'] = str(request.user.username)
                request.META['USER_EMAIL'] = str(request.user.email)
        except:
            pass

Then, in settings.py, I added the following line to the top of the MIDDLEWARE_CLASSES block:

'errorreporting.middleware.ExceptionUserInfoMiddleware',

This issue is caused by Jquery Mobile and can be solved by adding the following meta tags inside your head:

<meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
<meta name="apple-mobile-web-app-capable" content="yes" />
<meta name="apple-mobile-web-app-status-bar-style" content="black" />

In this post, we’ll look at how to install the latest stable version of Apache Hadoop on a laptop running Linux Mint 13, although this install setup should be very similar for most other distributions.

Before we begin, you should check out the hadoop website here: http://hadoop.apache.org/ and familiarize yourself with the Getting Started documentation.

// GET HADOOP

The first thing you need to do is acquire the hadoop package. At the time of writing, Hadoop was available for download from the following link: http://www.apache.org/dyn/closer.cgi/hadoop/common/.  The latest stable version at this point is 1.0.4, so I opted to download the file hadoop-1.0.4.tar.gz as I want to use the source tarball instead of the rpm to build hadoop.  I have chosen this route because the laptop I am installing hadoop on will not be solely used for hadoop, so using a source based distribution allows me to keep everything in a single working directory and allows for easy upgrading in the future.

Once you have downloaded the tarball, extract it with the following command:

$ tar zxvf hadoop-1.0.4.tar.gz

Optionally, you can move it somewhere on the filesystem where hadoop will reside (maybe in your home directory).

Inside the newly created hadoop-1.0.4 directory, there is a docs directory that has an outline of all the steps we will be working through.  This post will walk through the ‘Single Node Setup’ instructions inside the docs directory.

First, we will look at Standalone Operation which does not provide HDFS support, it simply gets a hadoop node up and running to process simple jobs.  SSH access is not required for Standalone Operation.

To get the Standalone Operation functional, we only need to add 1 line of code that tells hadoop where the Java Installation resides on our machine.  Apache recommends using the Sun flavor of the Java JDK, but since this is not a production setup, I am going to use the OpenJDK installation that is already installed on my Linux Mint distribution.  Further information about supported flavors of the JDK can be found here: http://wiki.apache.org/hadoop/HadoopJavaVersions.

Since I am running the 64 bit version of Mint, my JDK is installed at  /usr/lib/jvm/java-6-openjdk-amd64.  Add this configuration to the hadoop environment variables like this:

$ cd hadoop-1.0.4/conf
$ vim hadoop-env.sh

Somewhere around the top of this file you will see the following lines:

# The java implementation to use.  Required.
# export JAVA_HOME=/usr/lib/j2sdk1.5-sun

We are going to change this to:

# The java implementation to use.  Required.
export JAVA_HOME=/usr/lib/jvm/java-6-openjdk-amd64

Congratulations! You should now be able to fire up hadoop in Standalone Operation mode. You can start by taking a look at the usage for the script that starts hadoop by going back up to the main hadoop folder and typing the following:

$ bin/hadoop

Now lets run the example hadoop script to actually push a full job through our Standalone server. Again in the hadoop folder:

$ mkdir input
$ cp conf/*.xml input
$ bin/hadoop jar hadoop-examples-*.jar grep input output 'dfs[a-z.]+'
$ cat output/*

This should run the example script and put the output from the job in the output folder.

// PSUDO-DISTRIBUTED OPERATION

Although Psudo-Distributed Operation is not required, it will provide you with an environment that much more resembles what you will encounter in production.  I recommend performing the extra configuration to provide the web-based job tracker, web-based node tracker, and HDFS that you will find in hadoop production servers.

On Linux Mint, we must start by installing the SSH server and starting up the ssh daemon.  Install the server with the following command:

$ sudo apt-get install openssh-server

After the server is installed, check its status with:

$ /etc/init.d/ssh status

If the server is not started, start it with:

$ /etc/init.d/ssh start

Now that the SSH server is running, we must enable passphraseless ssh

// WARNING
THIS IS DANGEROUS. YOU SHOULD NOT ENABLE PASSPHRASELESS SSH WHEN YOU ARE NOT USING HADOOP. EITHER DISABLE SSH ALLTOGETHER OR REMOVE THE AUTHORIZED_KEYS WHEN NOT USING HADOOP.

$ ssh-keygen -t dsa -P '' -f ~/.ssh/id_dsa
$ cat ~/.ssh/id_dsa.pub >> ~/.ssh/authorized_keys

You should now be able to ssh into the localhost without entering a password. Try it with the following command (you might have to type yes to accept the RSA key fingerprint, this is OK):

$ ssh localhost
$ exit

Inside the conf directory, we need to modify 3 files to add configuration for Psudo-Distributed Operation. This should be added between the <configuration> and </configuration>tags.

In conf/core-site.xml add the following:

    <property>
        <name>fs.default.name</name>
        <value>hdfs://localhost:9000</value>
    </property>

In conf/hdfs-site.xml add the following:

    <property>
        <name>dfs.replication</name>
        <value>1</value>
    </property>

In conf/mapred-site.xml add the following:

    <property>
        <name>mapred.job.tracker</name>
        <value>localhost:9001</value>
    </property>

Now we need to format the distributed filesystem with the following command, from the hadoop folder:

$ bin/hadoop namenode -format

And now were ready to go! Start up the hadoop daemon with the following command:

$ bin/start-all.sh

You should now be able to browse the nameNode and JobTracker in your browser (after a short delay for startup) by browsing to the following URLs:

nameNode: http://localhost:50070/

JobTracker: http://localhost:50030/

At this point your Psudo-Distributed Mode should be fully operational.

// RUN THE EXAMPLE ON THE PSUDO-DISTRIBUTED CLUSTER

Now were going to run the exact same example we ran above but this time inside of the Psudo-Distributed Cluster.  We start by copying our input data set into HDFS:

$ bin/hadoop fs -put conf input

Run the example:

$ bin/hadoop jar hadoop-examples-*.jar grep input output 'dfs['a-z.]+'

You should now see the job executing in the web based Job Tracker, and when the job completes you will be able to get the report from the job tracker. To copy the output from HDFS back to the local file system for examination, we can use the following command:

$ bin/hadoop fs -get output output

The output from the job that just completed will now be in a folder called ‘output’ in the current working directory.

// STOP THE HADOOP DAEMON

Once you are finished, you should stop the hadoop daemons from running with the following command:

$ bin/stop-all.sh

Recently, I gave the kindle a try, to see if I could really get back into reading books. Even though I’m a huge supporter and overzealous user of technology, I was wary of the kindle at first. I didn’t like the thought of not being able to flip pages, not being able to dog-ear pages and write notes in the book. It really bothered me that when I finished dedicating all that time to a novel, I wouldn’t have a paper back trophy to add to the collection. Then I actually gave it a try …

Kevin Mitnick’s autobiography, “Ghost in the Wires: My Adventures as the World’s Most Wanted Hacker“, instantly interested me as I had read “Takedown: The Pursuit and Capture of Kevin Mitnick, America’s Most Wanted Computer Outlaw-By the Man Who Did It” by Tsutomu Shimomura and John Markoff in highschool.

In this spare-no-details first hand account, Mitnick takes us through his rise to become the FBI’s most wanted target, detailing his steps in creating new identities to allude the law enforcement manhunt while (quite successfully) staging a counter snooping operation that kept him one step ahead of his pursuers for years.

Many of Mitnick’s exploits are based on an attack vector known as Social Engineering. He outlines the three steps to successful social engineering as:
1) Assume a position of authority
2) Convince the victim that you are supposed to be doing what you are asking them to do
3) Convince the victim that you are unable to do it yourself, and you need their help
These three steps, if performed properly, almost always result in the victim doing something for you that you shouldn’t be able to do yourself. Mitnick, by simply talking to people on the phone, was incredibly skilled in getting people to grant him access to restricted information and change systems that he didn’t have the permission to change himself.

Overall, this book assumes you have some background understanding of how a Telco operates, and is not for the technically challenged, although it rarely goes into great technical detail.

What I found most interesting was Mitnick’s thoughts on solitary confinement, a topic he became quite familiar with through first hand experience.  Spending 8 months in solitary confinement for non-violent crimes seems a little harsh, and Mitnick constantly describes the damaging psychological impact that it can have on a human being.

At one point, Mitnick describes being diagnosed as having an “addiction to hacking” in the same sense as an addiction to smoking or drinking.  This is easily justified given his lack of “for profit” exploits in lieu of a constantly exploiting Telcos on the quest for knowledge.

The truly shocking thing about this book is not Mitnick’s exploits, but the vulnerabilities in the Telco’s themselves, something I have been conscious of for years. Most of his code based exploits were piggybacked on Social Engineering attacks against the Telcos. The biggest vulnerability in the phone companies are the Operators, Service Technicians and general staff who are willing to break security protocol (or even completely disregard it) for someone who speaks their rare and unique, highly technical language. This is a terrifying reality considering the power one can wield by simply convincing people over the phone to do something.

I highly recommend this book to other tech junkies looking for a good read, and am looking forward to reading some of his other books.

You can check out the tab here.

I’ve been playing with the Facebook API for a while, and I’ve never really been satisfied with the final product.  Something about it always seemed incomplete.  There were all kinds of restrictions and all kinds of hacks to break restrictions.  For example, I had a photo gallery inside a Facebook tab that leveraged a Dialog window to display a full size image, thanks to the old Javascript API.  Way cool effect for a photo gallery, but hacked out and not really supported which eventually caused it to break.

I’ve been working on a website for a few months, and I wanted to build something that would extend its reach to Facebook.  I wanted to create something that would really allow people to interact with each other, on Facebook, the way they used to with Apps like SuperPoke.

1) Pick a gift.
2) Pick a friend.
3) DIRECT INTERACTION that all your friends see.

The popularity of App provoked direct interaction between two people on Facebook is something that has really faded, probably due to horrible API documentation, and been replaced by a more pure, unaided post based interaction.  Our solution was to build an App that provided quality content worthy of sharing on Facebook while making it a very simple to share the content with a friend.

Facebook has built in facilities for sharing content with friends.  They used to provide access to some of those facilities in older versions of the API, but have since stripped out access to those facilities and replaced it with a lower level access to Facebook data, effectively moving third party developers closer to the database.  This is very beneficial to developers if they can figure out how to interface with the API, as it not only allows, but forces the developer to build out the full flow of interaction, but unfortunately, often becomes a task of blindly reverse engineering return values and function calls.

Alright, enough bitching about Facebook, lets take a look at the product … and I’ll bitch some more later.

Our wall is composed of a huge list of beers that you can scroll through.  Step 1 is simply to pick a beer.  When you click on the beer, you are asked to authorize the app, giving access to your basic information (friends list).  After Authorizing the App (you only have to authorize it the first time you use it, it will be stored in your preferences), you will be shown a list of your friends in alphabetical order.  ‘In alphabetical order’ doesn’t seem that impressive, but it’s not built in.  The Graph API uses lazy sorting when it returns the friends list, so it had to be sorted in Javascript by the browser.

Step 2 is just as simple, click on one of your friends.

Step 3: Facebook dialog asking if you want to post the chosen beer to the chosen friends wall.  Type in a description, and click share.  Thats it.  3 clicks and you can share any of the almost 200 beers with any of your 342,000 friends.  Simple enough, right?  Now lets look at the code …

<html>
<head>
<style>
// Put some style info for your div ids and classes here
</style>
<script src="//ajax.googleapis.com/ajax/libs/jquery/1.5.2/jquery.min.js" type="text/javascript"></script>
</head>

In the first block of code we setup a basic HTML layout and load the jquery script from Google’s Servers (Props to Google for hosting a lot of good frameworks for the masses).  The Jquery framework is going to help us with a few things, hiding and showing divs, getting and setting variable values, etc.

<body>
<div id="fb-root"></div>
<script>
window.fbAsyncInit = function() {
FB.init({
appId  : 'YOUR_APP_ID_HERE', //FILL IN YOUR APP ID
status : true, // check login status
cookie : true, // enable cookies to allow the server to access the session
xfbml  : true, // parse XFBML
oauth  : true // enable OAuth 2.0
});
//  FB.Event.subscribe('auth.statusChange', onFacebookStatusChange);
};
(function() {
var e = document.createElement('script');
e.src = document.location.protocol + '//connect.facebook.net/en_US/all.js';
e.async = true;
document.getElementById('fb-root').appendChild(e);
}());

The above code sets up the body element and uses javascript to load the Facebook Javascript API asynchronously.  Be sure to fill in your App ID or this will fail to load the API and all calls to the API will fail.

function onFacebookInitialLoginStatus(response) {
if (response.status != "connected" || response.authResponse == null) {
facebookLogin();
}
FB.api('/me/friends', function(response) {
var friends1 = response.data;
var friends = friends1.sort(sortByName);
var l = friends.length;
for (var i=0;i<l;i++) {
$('#friends ul').append("<li onclick=\"personSelected(" + friends[i].id + ");\"><img src=\"https://graph.facebook.com/" + friends[i].id + "/picture/\"><p>" + friends[i].name + "</p></li>");
}
$('.beers_image_list').hide();
$('#beers_page_header').hide();
$('#footer').hide();
$('#friends_header').show();
$('.friends_image_list').show();
});
}

The above function is responsible for checking the LoginStatus of the requesting user.  I had to reverse engineer the response object as there is no proper documentation outlining what actually gets returned.  What comes back is a list of friends stored in response.data, but the Graph API uses a lazy sorting method and returns the list without any useful sort performed.  We must therefore implement a method in Javascript to sort the returned list.  This all takes place in the browser instead of on the server.

function sortByName(a, b) {
var x = a.name.toLowerCase();
var y = b.name.toLowerCase();
return((x < y) ? -1 : ((x > y) ? 1 : 0));
}

The above function had to be implemented into the code (and was taken from HERE) to sort the list of friends.

function facebookLogin() {
FB.login(onFacebookInitialLoginStatus);
}

The facebookLogin() function does some stuff FILL IN EXPLAINATION

function shareBeer(selected_beer_img, selected_beer_link, selected_beer_name, selected_beer_brewery, selected_beer_type, selected_beer_locality) {
$('#selected_beer_image').html(selected_beer_img);
$('#selected_beer_link').html(selected_beer_link);
$('#selected_beer_name').html(selected_beer_name);
$('#selected_beer_brewery').html(selected_beer_brewery);
$('#selected_beer_type').html(selected_beer_type);
$('#selected_beer_locality').html(selected_beer_locality);
FB.getLoginStatus(onFacebookInitialLoginStatus);
}

The shareBeer() function is really the heart of what makes our product unique and easy to use.  By utilizing the Jquery framework, we are able to create a simple and easy to use user interface that allows users to perform step 1, Choose a Beer.  The function is fired by an onclick event attached to the <li> object that we will look at a little later in the HTML.  shareBeer() takes a few arguments, all of which are information that will get passed to the final dialog and describe the Beer that someone is going to share.  Because I am not overly familiar with Javascript, and it made debugging extremely easy, I chose to pass the variables from step 1 to step 2 inside of hidden div elements in the HTML.  The divs were hidden with CSS (display:hidden;).

function personSelected(person) {
FB.ui({
method: 'feed',
to: person,
name: $('#selected_beer_name').html(),
link: 'http://nationwidebarcrawl.com/link/',
picture: $('#selected_beer_image').html(),
caption: 'Free. As in Beer.',
description: '<center>Brewery: ' + $('#selected_beer_brewery').html() + '</center><center>Type: ' + $('#selected_beer_type').html() + '</center><center>Locality: ' + $('#selected_beer_locality').html() + '</center>'
}, function(response) {
if (response && response.post_id) {
alert('post published');
} else {
alert('post failed');
}
});
}
</script>

This function is responsible for popping the ‘post to wall’ dialog which is popped by calling the ‘feed’ method of the FB.ui() Graph API function.  We again utilize Jquery to pull the values from the Beer object variables that we set inside of hidden divs.  This function is triggered by an onclick event on the <li> that we will look at later in the HTML.  The onlick event passes the Facebook id of the friend who occupies the clicked <li>.  The FB.ui call utilizes this argument as the ‘to’ value for the call.  If you leave the ‘to’ value blank, the dialog will default to posting to the requesting users feed.  Without this ‘to’ argument, our Facebook App loses its ability to provoke social interaction, and thus, its value to the Facebook community.

The description utilizes the <center> tag to get line breaks in our post.  Currently, Facebook does not allow you to put line breaks in your post description, but wrapping each line inside of a <center></center> tag will display the content on separate lines.

<div id="friends">
<div id="friends_header"></div>
<ul></ul>
</div>
<div id="beers_page_header"><a href="http://nationwidebarcrawl.com/beers/" target="_blank"><img src="/media/images/facebook/beers_button.png" /></a></div>
<ul>
{% for beer in beers %}<li><a href="#" onclick="shareBeer('{{ beer.mainphoto.get_singlebeer_url }}', 'http://nationwidebarcrawl.com/beers/{{ beer.slug }}', '{{ beer }}', '{{ beer.brewery }}', '{{ beer.type }}', '{{ beer.get_locality_display }}');"><img src="{{ beer.mainphoto.get_singlebeer_url }}" /><p>{{ beer }}</p></a></li>{% if forloop.counter|divisibleby:"4" and not forloop.last %}</ul><ul>{% endif %}{% endfor %}
</ul>
<div id="footer"><a href="http://cloudcreativegroup.com/" target="_blank"><img src="/media/images/facebook/footer_logo.png"></a></div>
<div id="selected_beer_image"></div>
<div id="selected_beer_link"></div>
<div id="selected_beer_name"></div>
<div id="selected_beer_brewery"></div>
<div id="selected_beer_type"></div>
<div id="selected_beer_locality"></div>
</body>
</html>

The above HTML generates the entire 3 step process in a single page, embedded inside of a Facebook fan page, utilizing Jquery to require only the initial page load to facilitate the entire 3 step process of sharing a gift with a friend.

AN OPEN CALL TO FACEBOOK

Facebook, love the website.  In fact, it eats up a large amount of my daily time, but we have to have a talk about your API.  You guys have moved at an extremely fast pace over the last couple years, starting out as a College based social network and eventually expanding to encompass the whole world.  During this time, many developers have felt as though you haven’t put enough emphasis on keeping your API documentation up to date (and working for that matter).  I like how you guys have spent a lot of time trying to explain the concepts behind a lot of the inner workings of your API, but honestly, none of the documentation really helped me understand what was going on.

The one thing I think you guys could really improve, and quite easily, would be a full API reference.  If you’re not sure what one of those looks like, take a look at Google Maps API Version 3 reference here: http://code.google.com/apis/maps/documentation/javascript/reference.html

With a fully documented API reference, you will see a lot more quality apps being developed for your platform.

This is an updated version of an older blog post outlining a full (VE) build for django.  I had to update my server due to incompatibilities between the latest version of WordPress and the versions of PHP/MySQL found in the standard CentOS repos.

// SHOUTOUTS

Malcolm Frazier – (still) holding it down with the Linux knowledge.

// USER ACCOUNTS

The first step is to create a user account so you don’t have to use root

# useradd <username>
# passwd <username>

Add a user group so we can setup the sudoers file and add our new account to the group

# /usr/sbin/groupadd <new_group_name>
# /usr/sbin/usermod -a -G <new_group_name> <username>

I like to use the locate command a lot, so lets build the index of the file system that locate uses to search

# updatedb

Setup the sudoers config file

# vim /etc/sudoers

Add the following lines to the bottom of the file:

# Customizations
%<new_group_name>     ALL=(ALL)     ALL

*** The above modification more or less gives all users in <new_group_name> the ability to do anything root can do, without the root password.  This is fine for building the server, but after the server is built, you should restrict the permission levels a little bit more.

At this point you should be able to exit ssh and log back in as your new user account.  You can use sudo <command> to execute commands as root, or use sudo -s as a replacement for su.

// UPGRADE PACKAGES SYSTEM WIDE

# yum upgrade

// INSTALLING PYTHON 2.7

I’ve chosen to use Python 2.7 as my version of python for django.  CentOS 5.5 comes with Python 2.4 already installed.  I had some down time on a past project because I asked the techs at RackSpace to upgrade the version of Python on the server and they started by uninstalling Python 2.4.  The problem is that the yum package management system that CentOS uses is built on top of Python.  If you uninstall Python 2.4, you will not be able to use yum to install Python 2.7, or any other package at that point.  The solution is to install Python 2.7 in parallel to 2.4, have Django and all your other apps use the 2.7 install, and leave 2.4 to be used by yum and the underlying OS.

Before we start compiling, lets install the GCC compiler:

# yum install gcc

This will prevent the following error from occurring if you try to compile python without gcc:

configure: error: in `/root/Source/Python-2.7':
configure: error: no acceptable C compiler found in $PATH

Additionally, you’ll want to install a few extra optional dependencies for Python

# yum install readline-devel gdbm-devel sqlite-devel
# yum install openssl-devel ncurses-devel bzip2-devel

Theres a great tutorial on installing Python 2.7 on CentOS 5 here.

Instead of using /usr/src/ for all the source code, I created /root/Source/ to hold the source from all the packages.  Inside of Source, download and extract Python 2.7:

# wget http://www.python.org/ftp/python/2.7/Python-2.7.tar.bz2
# tar -xvjf Python-2.7.tar.bz2
# cd Python-2.7
# ./configure --help

Read through the configure help and see if there are any options you want to enable or customize.  Then run the configuration script:

# ./configure --prefix=/usr/local/python2.7 --enable-shared

–prefix tells python to install to a directory other than the default.  This is necessary if we want to run both 2.7 and 2.4 side by side.

–enable-shared will prevent an error later on when trying to build mod_wsgi.  If you get the following error when building mod_wsgi, recompile and reinstall python with –enable-shared:

/usr/local/python2.7/lib/libpython2.7.a: could not read symbols: Bad value
collect2: ld returned 1 exit status
apxs:Error: Command failed with rc=65536
make: *** [mod_wsgi.la] Error 1

Now its time to build and install Python:

# make
# make install

// SETUP ENVIRONMENT VARIABLES

$ vim ~/.bashrc

Add the following to the bottom of .bashrc:

# User specific aliases and functions
alias python='/usr/local/python2.7/bin/python'

Log out, Log back in, and you should be able to execute the new Python 2.7

$ python
Python 2.7
>>>

// INSTALLING PIL (PYTHON IMAGING LIBRARY)

At this point, if you install PIL without first satisfying the optional dependencies, PIL will be built without libjpeg and zlib (png support).  The output of python setup.py install would be:

*** TKINTER support not available
*** JPEG support not available
*** ZLIB (PNG/ZIP) support not available
*** FREETYPE2 support not available
*** LITTLECMS support not available

Unfortunately, PIL doesn’t complain very loudly and will still install a working version that will not be able to handle .jpg or .png files.  If you install PIL without the header libraries for the dependencies present, you will receive the following error in django’s admin when trying to upload an image file:

Upload a valid image. The file you uploaded was either not an image or a corrupted image.

You can further verify if the proper support is compiled in from the shell:

$ python
>>> from PIL import Image
>>> i = Image.open("/path/to/some/image.jpg")
>>> i.verify()
>>> i.load()
Traceback (most recent call last):
File "<console>", line 1, in <module>
File "/usr/local/python2.7/lib/python2.7/site-packages/PIL/ImageFile.py", line 189, in load
d = Image._getdecoder(self.mode, d, a, self.decoderconfig)
File "/usr/local/python2.7/lib/python2.7/site-packages/PIL/Image.py", line 385, in _getdecoder
raise IOError("decoder %s not available" % decoder_name)
IOError: decoder jpeg not available

You can see from the above error that the jpeg decoder is not available.  If you’ve already installed PIL, uninstall it.  If you havn’t installed PIL yet, this will save you a lot of time (:

# yum install zlib zlib-devel
# yum install libjpeg libjpeg-devel
# yum install freetype freetype-devel

Django relies heavily on the PIL.  Again in our /root/Source directory, install PIL:

# wget http://effbot.org/downloads/Imaging-1.1.7.tar.gz
# tar xvfz Imaging-1.1.7.tar.gz
# cd Imaging-1.1.7
# python setup.py build_ext -i

Check to make sure that libjpeg and zlib were found:

*** TKINTER support not available
--- JPEG support available
--- ZLIB (PNG/ZIP) support available
--- FREETYPE2 support available
*** LITTLECMS support not available

Run a test to make sure that everything works:

# python selftest.py
--------------------------------------------------------------------
PIL 1.1.7 TEST SUMMARY
--------------------------------------------------------------------
Python modules loaded from ./PIL
Binary modules loaded from ./PIL
--------------------------------------------------------------------
--- PIL CORE support ok
*** TKINTER support not installed
--- JPEG support ok
--- ZLIB (PNG/ZIP) support ok
--- FREETYPE2 support ok
*** LITTLECMS support not installed
--------------------------------------------------------------------
Running selftest:
--- 57 tests passed.

And finally, install PIL:

# python setup.py install

You should now be able to import PIL inside of python:

$ python
>>>import PIL
>>>

// INSTALLING MYSQL

Enable the Remi Repository to install MySQL 5.5 and PHP 5.3.  More information about the Remi Repository can be found here.

# wget http://download.fedora.redhat.com/pub/epel/5/x86_64/epel-release-5-4.noarch.rpm
# rpm -Uvh epel-release-5-4.noarch.rpm
# rpm -Uvh http://rpms.famillecollet.com/enterprise/remi-release-5.rpm
# yum --enablerepo=remi list mysql mysql-server
# yum --enablerepo=remi install mysql.x86_64 mysql-server.x86_64

Start the MySQL Server:

# /etc/init.d/mysqld start

In order to set the initial root password, and get rid of the built in tables/user accounts for testing, run:

# /usr/bin/mysql_secure_installation

Follow the instructions, pick your customizations … then make sure MySQL is installed and working:

# mysql -u root -p
Enter password:
mysql> SELECT VERSION();
+-----------+
| VERSION() |
+-----------+
| 5.5.14    |
+-----------+
1 row in set (0.00 sec)

Add MySQL to the proper run level:

# /sbin/chkconfig mysqld on

// MYSQL-PYTHON GAP

Next, you need to install MySQL-python, the python interface to MySQL.  If you do not install MySQL-python, later on when you try to do a ‘python manage.py syncdb’ django will not be able to communicate with MySQL and will throw the following error:

django.core.exceptions.ImproperlyConfigured: Error loading MySQLdb module: No module named MySQLdb

Setuptools is a required dependency of MySQL-python.  Download it from here and install it, setting the prefix to our freshly installed python2.7

# sh setuptools*.egg --prefix=/usr/local/python2.7

Now install the MySQL headers from the Remi repo, then install MySQL-python:

# yum --enablerepo=remi install mysql-devel.x86_64
# wget http://sourceforge.net/projects/mysql-python/files/mysql-python/1.2.3/MySQL-python-1.2.3.tar.gz/download
# tar -zxvf MySQL-python-1.2.3.tar.gz
# cd MySQL-python-1.2.3
# python setup.py build
# python seutp.py install

At this point django should be able to talk to MySQL using MySQL-python.

// INSTALLING APACHE

Next we have to install our web server, Apache.  There’s a pretty straight forward tutorial on this here.

# yum install httpd
# /sbin/chkconfig httpd on
# /etc/init.d/httpd start
Starting httpd:                                            [  OK  ]

At this point, you should spend some quality time with /etc/httpd/conf/httpd.conf to really squeeze some power out of apache.

// INSTALLING DJANGO

The django install docs can be found here.

# wget http://www.djangoproject.com/download/1.3/tarball/
# tar xzvf Django-1.3.tar.gz
# cd Django-1.3
# python setup.py install
$ python
>>> import django
>>>

// INSTALLING PHPMYADMIN

PhpMyAdmin is a web interface for controlling your MySQL database.

# yum install phpmyadmin

This will install PHP as a dependency, but you will still need to setup PHP.  Setup the PHP Cookie:

# vim /usr/share/phpmyadmin/config.inc.php

Add the Python Shared Libraries

# vim /etc/ld.so.conf.d/python2.7.conf

add the following line:

/usr/local/python2.7/lib

Create necessary links and cache the new libraries:

# ldconfig

// INSTALLING MOD_WSGI

mod_wsgi is the link between apache and django.  It is responsible for taking the web request from apache and getting it to your django app for handling.  The mod_wsgi installation docs are a great resource, they can be found here.

First, we need to install the source code for apache, as mod_wsgi needs it to build.  Install the httpd-devel package, which will install the headers for apache.

# yum install httpd-devel

Get and install mod_wsgi

# wget http://modwsgi.googlecode.com/files/mod_wsgi-3.3.tar.gz
# tar -zxvf mod_wsgi-3.3.tar.gz
# cd mod_wsgi-3.3
# ./configure --help
# ./configure --with-python=/usr/local/python2.7/bin/python
# make
# make_install

// POINT APACHE AT DJANGO USING MOD_WSGI

First, you need to tell apache which version of python to use so it doesn’t use the default 2.4:

# vim /etc/httpd/conf/httpd.conf

Add the following to the bottom of the file:

# Python Versioning Control for mod_wsgi
WSGIPythonHome /usr/local/python2.7

Make sure you load mod_wsgi in httpd.conf at the end of the LoadModule section

LoadModule wsgi_module modules/mod_wsgi.so

Then restart apache

# /etc/init.d/httpd restart

Now you can configure your virtual hosts in apache to point to a ‘django.wsgi’ file thats specific to each django project you create.  Add the WSGIScriptAlias to your Virtual Host configuration file:

WSGIScriptAlias / /path/to/your/django/project/django_project_name/apache/django.wsgi

Add the ‘apache’ directory to your django project, and create the django.wsgi file inside the apache directory:

$ cd /path/to/your/django/project/django_project_name/
$ mkdir apache
$ cd apache
$ vim django.wsgi

Copy the following into the django.wsgi file:

import os
import os.path
import sys

sys.path.append('/path/to/project/root')

os.environ['PYTHON_EGG_CACHE'] = '/path/to/a/directory/for/egg_cache'
os.environ['DJANGO_SETTINGS_MODULE'] = 'your_django_project_name.settings'

import django.core.handlers.wsgi
application = django.core.handlers.wsgi.WSGIHandler()

If you’ve made it this far, you should have a working django install.

(: