In the mean time, I’m doing this 100 things meme. You highlight the things you have done. Got this from Empty Thoughts, who got it from Leah Culver.

1. Started your own blog

2. Slept under the stars (This is actually a really fun and relaxing thing to do. Highly recommended)

3. Played in a band (I do have a guitar though, yay?)

4. Visited Hawaii

5. Watched a meteor shower

6. Given more than you can afford to charity (But I have given)

7. Been to Disneyland

8. Climbed a mountain (Nothing large though)

9. Held a praying mantis (What kid hasn’t?)

10. Sang a solo (uh kind of)

11. Bungee jumped

12. Visited Paris

13. Watched a lightning storm

14. Taught yourself an art from scratch

15. Adopted a child

16. Had food poisoning (some kind of fish)

17. Walked to the top of the Statue of Liberty (didn’t have time for it when I went to NYC )

18. Grown your own vegetables

19. Seen the Mona Lisa in France

20. Slept on an overnight train

21. Had a pillow fight

22. Hitch hiked

23. Taken a sick day when you’re not ill (duh!)

24. Built a snow fort (Even an igloo once)

25. Held a lamb (I .. think)

26. Gone skinny dipping

27. Run a Marathon (I really want to this year as I’m more in shape)

28. Ridden in a gondola in Venice

29. Seen a total eclipse

30. Watched a sunrise or sunset

31. Hit a home run (couldn’t play paid sports as a child, but with friends .. sure)

32. Been on a cruise

33. Seen Niagara Falls in person

34. Visited the birthplace of your ancestors (soon!)

35. Seen an Amish community

36. Taught yourself a new language (Not born English, but I am learning French at the moment )

37. Had enough money to be truly satisfied

38. Seen the Leaning Tower of Pisa in person

39. Gone rock climbing

40. Seen Michelangelo’s David

41. Sung karaoke

42. Seen Old Faithful geyser erupt

43. Bought a stranger a meal at a restaurant

44. Visited Africa

45. Walked on a beach by moonlight

46. Been transported in an ambulance

47. Had your portrait painted

48. Gone deep sea fishing

49. Seen the Sistine Chapel in person

50. Been to the top of the Eiffel Tower in Paris

51. Gone scuba diving or snorkeling

52. Kissed in the rain

53. Played in the mud

54. Gone to a drive-in theater (We were going to one day but we COULDN’T find it!)

55. Been in a movie

56. Visited the Great Wall of China

57. Started a business (Not really, just hobby projects)

58. Taken a martial arts class

59. Visited Russia

60. Served at a soup kitchen

61. Sold Girl Scout Cookies

62. Gone whale watching (oh god want to so badly)

63. Got flowers for no reason

64. Donated blood, platelets or plasma

65. Gone sky diving

66. Visited a Nazi Concentration Camp

67. Bounced a check

68. Flown in a helicopter

69. Saved a favorite childhood toy

70. Visited the Lincoln Memorial

71. Eaten caviar

72. Pieced a quilt

73. Stood in Times Square

74. Toured the Everglades

75. Been fired from a job

76. Seen the Changing of the Guards in London

77. Broken a bone

78. Been on a speeding motorcycle

79. Seen the Grand Canyon in person

80. Published a book

81. Visited the Vatican

82. Bought a brand new car

83. Walked in Jerusalem

84. Had your picture in the newspaper

85. Read the entire Bible

86. Visited the White House

87. Killed and prepared an animal for eating

88. Had chickenpox

89. Saved someone’s life

90. Sat on a jury

91. Met someone famous

92. Joined a book club

93. Lost a loved one

94. Had a baby

95. Seen the Alamo in person

96. Swam in the Great Salt Lake

97. Been involved in a law suit

98. Owned a mobile phone

99. Been stung by a bee

100. Read an entire book in one day (Nothing lengthy obviously)

Looking at my list, makes me realize how much I have not travelled, mostly to my home continent (Europe). I will, but not yet .. still young

In this example, I am taking data from a mySQL database that held data for a PHP application and converting it to Django models. What I do is run the data through a ModelForm so that I can test for validation:

# We use the MySQLdb module to connect to a different database to get our old data.
db = MySQLdb.connect(user="me", passwd="password", db="mydatabase")
c = db.cursor(DictCursor)

c.execute("SELECT field1, field2, FROM some_table")
rows = c.fetchall()

for r in rows:
     form = AddItemForm(r)
     if form.is_valid():
         obj = Item(**form.cleaned_data)
         obj.save()
     else:
         # You probably want to log here instead of using print
         # form.errors will contain the errors, which you can log as well.
         print("Could not add Item %s" % r['field1'])

And that’s it! This is of course a very crude and simple example but it gets the job done and I find it much better then simply passing in data to my model. With the form, it allows me to catch the errors that the end-user may hit when they actually use the form in the application so it’s a win-win.

Whether you’re writing your application in Python, Ruby, or even PHP (Yes, even PHP) it feels good to know what’s exactly powering your software. Earlier this week I put together the setup for one of my Django sites and this guide will go through the process. The services are running off a 256mb slice from Slicehost, which I highly recommend.

What we’re running here: The end result is an Ubuntu Intrepid server using Apache2 with mod_python to serve Django, and lighttpd to serve media/static files. Memcache is used as a caching backend and mySQL 5.0 is our primary database. This is a very common Django setup and you will find similar guides all over the net. This is just my take

Getting the packages we need.

SSH to your server, authenticate and run the following commands to install our necessary packages:


$ sudo aptitude install apache2 apache2.2-common apache2-utils
$ sudo aptitude install libapache2-mod-python
$ sudo aptitude install python-setuptools # You need this for a few python modules we need to install
$ sudo aptitude install mysql-server mysql-client libmysqlclient15-dev
$ sudo aptitude install memcached
$ sudo aptitude install python-mysqldb
$ sudo aptitude install lighttpd

Setting up MySQL.

Setting up mySQL is rather simple. You already supplied a root password when you were initially installing the packages so all we really need to do now is create a database and grant access to a non-root user. This is very simple:

$ mysql -uroot -p
mysql> CREATE DATABASE mysite;
mysql> GRANT ALL ON mysite.* TO 'foo'@'localhost' IDENTIFIED BY 'password' WITH GRANT OPTION;


As I said, very simple. We create an initial database and then use GRANT to give us a user/password combo we can connect with. If you have an existing set of mysql data, you can now dump it into your database.

I don’t fancy myself an expert in mySQL user permissions so I recommend viewing the mySQL 5 Grant Documentation for more information. You may also want to take a look at your /etc/mysql/my.cnf configuration file to modify mySQL settings depending on your sites load.

Configure & run memcached as a daemon

Installing memcached is optional as you may not need or want caching, but it’s generally good practice to have it with your Django sites. To run it, we are going to execute this command:

$ memcached -u www-data -p 11211 -m 32 -d

What this does is tells memcached to run under the user www-data which is the user Apache runs under on Ubuntu. We run it on port 11211 (default), and give it 32mb of memory. You can adjust this memory to be larger or smaller depending on your machine and traffic of websites. As I only have 256mb of RAM and a single (small) site, this is sufficient. Finally, the -d flag runs it as a daemon.

Now we have to install some memcached python bindings. cmemcache is a popular choice but I can’t get it to work when installing memcached from a package (only from source, which we didn’t do), so we opt for the second best: python-memcached. Simply grab it and install it:

$ wget ftp://ftp.tummy.com/pub/python-memcached/python-memcached-latest.tar.gz
$ tar -zxvf python-memcached-latest.tar.gz
$ cd python-memcached-1.43
$ sudo python setup.py install


That’s pretty much it for memcached! The rest of the work is involved within your Django application which you can read all about from the official Django documentation.

Setup Django.

Of course, we actually need to get Django! You can fetch it in a variety of ways from the download page. Personally, I enjoy using the SVN trunk as it’s pretty stable while having the benefit of new features and bug fixes as soon as they are done. I like setting up Django in /home and then linking it to site-packages. This allows me to not worry much about permissions and everything just seems easier. Plus I love the ~ accessibility

First, let’s give our www-data user (see above, it’s our Apache user) access to our files.

$ sudo gpasswd -a www-data yourusername # In my case, it's admin
$ chmod g+w ~


Now, let’s get Django from trunk and setup some directories for our projects.

$ cd ~
$ mkdir projects
$ mkdir apps # This is not used in the tutorial, but this is where I place my portable django apps
$ svn co http://code.djangoproject.com/svn/django/trunk/ django
$ sudo ln -s `pwd`/django/django /usr/lib/python2.5/site-packages

That’s it for that. Django is now recognized as a package in Python’s sys.path

Setting up your project with Apache.

We’re almost there! Now, we finally need to tell Apache and mod_python that we have a Django project we want them to serve. If you have an existing project, simply fetch it from your favourite version control service. If not, you can start your own project quite simply:

$ cd ~/projects
$ ~/django/django/bin/django-admin.py startproject myproject


If you are starting from scratch, you will need to modify your settings.py file to match our setup of a mySQL database and the usage of memcached. There’s no point in me iterating over this, as the Django docs explain it quite well. So let’s get right down to it and setup our domain in Apache.

$ sudo vim /etc/apache2/sites-available/myproject.tld


And then paste the following, modifying as needed:

<VirtualHost *>

ServerName www.myproject.com
ServerAlias myproject.com

DocumentRoot /var/www/myproject.com

CustomLog /var/log/apache2/myproject.com.access.log combined
ErrorLog /var/log/apache2/myproject.com.error.log

SetHandler python-program
PythonHandler django.core.handlers.modpython
SetEnv DJANGO_SETTINGS_MODULE myproject.settings
PythonDebug On
PythonPath “['/path/to/my/projects/parent_dir'] + sys.path”

<Location “/media”>
SetHandler None
</Location>

</VirtualHost>
Some quick notes:

- Replace /path/to/my/projects/parent_dir and myproject.settings to the relative values. The path is to your projects PARENT directory. So in my case, it would be /home/bartek/projects
- /media is the directory where our django’s admin media will be linked to.
- Depending on your DNS settings, you may need to adjust the wildcard on the VirtualHost declaration.

Finally, let’s enable the site and setup the admin media link:

$ sudo ln -s /etc/apache2/sites-available/myproject.com /etc/apache2/sites-enabled/myproject.com
$ sudo ln -s ~/django/django/contrib/admin/media /var/www/myproject.com/
$ sudo apache2ctl restart # Restart Apache


…….And if you did everything right you should see either your Django project running or the default “It works!” Django page. Congrats!

Setting up lighttpd

Lighttpd setup is optional, but is highly recommended. It’ll keep your site running smoothly and doesn’t bog down Apache/mod_python trying to serve both Django and media.

First, you’ll have to edit Lighttpd’s settings to run on a different port. The default is 80, which is what our Apache setup is running on:

$ sudo vim /etc/lighttpd/lighttpd.conf


Uncomment the server.port line (around line 70)

server.port = 81


Next, enable the mod_evhost module. Simply uncomment it in the server.modules variable near the top of the config file. mod_evhost allows you to use a different directory for the static media depending on the domain name. Now, add the following line which basically says requests for myproject.com should look in this directory. I did this on the 124th line, right after the evhost patterns.

$HTTP["host"] =~ “myproject\\.com” {
evhost.path-pattern = “/home/admin/projects/myproject/static/”
}


Just so you’re not confused, I generally place my media in my project directory like I did above but you can have it anywhere you want. A commonplace is under /var/www/myproject.com

Note: If you are under Debian/Ubuntu and your site has a “images” directory, the default lighttpd config may not serve this. Some Debian/Ubuntu configurations reference “images” as a dir for the Debian policy and all your images will be broken unless you remove this reference. I found it at around line 160.

Start lighttpd:

$ sudo /etc/init.d/lighttpd start


And verify it is working by visiting http://myproject.com:81. You should see either your Apache or Lighttpd placeholder page.

Configure Apache to use Lighttpd

To serve files using Lighttpd from Apache we need to enable proxy on Apache. There are other methods of doing this, but I’ve found this the best documented, and hey — it works great!

$ ln -s /etc/apache2/mods-available/proxy.load /etc/apache2/mods-enabled/
$ ln -s /etc/apache2/mods-available/proxy_connect.load /etc/apache2/mods-enabled/
$ ln -s /etc/apache2/mods-available/proxy_http.load /etc/apache2/mods-enabled/


Or just as easily type sudo a2enmod proxy proxy_connect proxy_httpd if you are under Ubuntu. Finally, unsecured proxies are used by spammers so we want to configure ours to only accept local connections. Simply do this:

$ sudo vim /etc/apache2/mods-available/proxy.conf


And modify the wildcard in <VirtualHost> to state the local host like so:

AddDefaultCharset off
Order deny,allow
Deny from all
Allow from 127.0.0.1

Finally, configure the VirtualHost to use the Proxy

$ sudo vim /etc/apache2/sites-available/myproject.com


Add this somewhere in your <VirtualHost> declaration

ProxyRequests Off
ProxyPreserveHost On
ProxyPass /static http://127.0.0.1:81/
ProxyPassReverse / http://127.0.0.1:81/


And with that setup, reload and restart Apache and Lighttpd should now be serving your static media!

$ sudo /etc/init.d/apache2 reload
$ sudo /etc/init.d/apache2 restart


To double check if it is, you can use the lovely Firebug plugin and just look under the “Net” tab or just use curl:

$ curl -I http://myproject.com
$ curl -I http://myproject.com:81

Curl will send back a response on what is serving it. You’ll see the first one shows Apache/mod_python, and the second line should return a lighttpd reference.

It works!

And that about wraps it up! There are many things you can do to customize the services running your software but this is a basic setup that works great for small and medium-scale sites. From here, you can extend this by setting up PHP for other apps, and securing your server. I recommend the articles on Slicehost for some great walk throughs on securing your server.

References & Credits:

Of course, there are many people who have done this long before me and I got a lot of information from. These posts outline what I did, but in their own manner and some have other useful information. I recommend checking them all out as they are great at what they do:

• http://ventanazul.com/webzine/trackback/124
• http://lethain.com/entry/2007/jul/13/creating-my-dream-server-django/
• http://www.inerciasensorial.com.br/2007/06/10/perils-of-software-development/lighttpd-with-apache/
• http://articles.slicehost.com/

This is where xclip comes in. xclip allows you to pipe content into your clipboard directly from the command line as well as outputting your clipboard. In terms of my example, it’s as simple as this:

cat id_rsa.pub | xclip

There’s only one problem with this example. Piping simply to xclip will only fill the clipboard you can use via xclip -o itself. Not your usual CTRL+V, or Right Click->Paste board. So how do you do that?

cat id_rsa.pub | xclip -selection c

Now when I go into Firefox or anywhere else, hitting CTRL+V I get the contents of id_rsa.pub. You can do this with ANY standard input to your terminal. File listings, file diff’s, drive space, etc .. you are not very limited.

Since I never plan to use xclip -o, I made a simple alias so I don’t have to constantly type -selection c, like so:

alias xclip=’xclip -selection c’

Now whenever I use the xclip pipe like I did in the first example it goes straight to my regular clipboard.

You may need to install xclip as it does not come default with Ubuntu. The xclip manual (man xclip) has a variety of other information I did not cover in my post, but this is all I personally need from it.

Love it. Made me chuckle, first time I’ve ever noticed something like this (to be fair I generally don’t build from source unless I need to)

1) Setting a ROOT_DIR and using it in settings.py

This is very simple. You want to setup a ROOT_DIR variable that basically consists of Python code that figures out what directory the file is in. The code is very simple:

2) Using a local_settings.py for easy moving around between environments

Another very simple but super useful trick. This allows you to over-ride any variables in settings.py for that specific machine. A simple use case for this would be that I have my development environment here on my Ubuntu machine but when I commit my project to SVN on the Debian server the mySQL details are different as it’s an entirely different server. So what I do is at the bottom of settings.py:

Then, setup settings.py so it matches your production environments settings (In this case, my Debian server) and create a new file called local_settings.py in the same directory. In this file, you can just place whatever vairables you want to over-ride. I have variables over-riding my MySQL and DEBUG settings to fit my local development (Ubuntu) environment. The key here is to not commit/send local_settings.py to production.

And that’s about it. Those two small changes make it very easy for my projects to move around. It makes it very nice to be able to commit even settings.py to your production environment and not worry about values not being correct.

If you know of any other good portability techniques I’d be glad to hear them in the comments section below, I’m still learning Django!

Today I had the fun little project of building a very simple message sending system in Django that would fetch emails from a database of subscribers, check for the latest message in the queue, and send it out.

Sounds easy? Well yes, it is. But there’s a few things that Django can do to make the email sending much smarter.

First off, sending HTML emails in Django requires you to set an alternate content type. This is easily done using the django.core.mail.EmailMultiAlternatives class which is very similar to using the EmailMessage class but provides a few more options for HTML emails. Here’s a simple code snippet using this:

subject, from_email, to = 'Say Hello to our new website!', 'service@mycompany.com', 

                                          'someuser@gmail.com'
text_content = 'This is an important message.'
html_content = '<p>This is an <strong>important</strong> message.</p>'
msg = EmailMultiAlternatives(subject, text_content, from_email, [to])
msg.attach_alternative(html_content, "text/html")
msg.send()

This very simple example sends an email to someuser@gmail.com with an alternative minetype for html. What this allows is for people who have HTML-enabled email clients they receive the full on HTML view, while people who are stuck with text based emails simply get a nice clean cut text email instead of html garble.

Django offers another class that makes it extremely efficient on sending emails to mass amounts of users. Now there is little documentation on this so I do not know how far you can stretch this (hundreds, or thousands of emails?) but it has worked well for me.

It is the SMTPConnection class also found in django.core.mail. With it, you can store all your EmailMessage()’s or your EmailMultiAlternatives()’s in a list of data and then send them all using one single connection instead of re-connecting each time. This is similar to using send_mass_mail but that is just a thin wrapper that does not support alternative mimetypes like HTML and other goodies. Here’s a simple code snipper:

# If you do not provide any connection settings, it uses the default found in settings.py

connection = SMTPConnection()
connection.send_messages(messages) # messages can be a list of EmailMessage objects

So those are two great classes that make email sending just that much simpler in Django. How would you put this all together? Here’s a simple example script that fetches an email message from a model named Message, some subscribers, and then sends out a mass email to them. In this script, Message is a model that holds the actual HTML email and Subscribers is a list of our subscribers. To keep it simple, we only work with their email

from django.core.mail import  EmailMultiAlternatives, SMTPConnection

from mysite.email_app.models import Subscriber, Message

message = Message.objects.order_by('-id')[:1][0] # Fetch latest message in our list of emails

if not message.is_sent:

      subscribers = Subscriber.objects.all()

      emails_to_send = []

      for s in subscribers:

           msg = EmailMultiAlternatives(message.subject, message.body_text, 'myemail@foo.com', 

                                                                     [s.email])

           # Attach the html version of our email to the email

           msg.attach_alternative(message.body_html, "text/html")

           emails_to_send.append( msg )

      # Setup a single SMTPConnection to send all emails instead of re-connecting each time

      connection = SMTPConnection()

      connection.send_messages(emails_to_send)

      message.is_sent = True

      message.save()

That’s just a very simple example and if you know any ounce of Django I hope you can understand it. You could also add something like a send_time to your Message model and then run a daily cron script to check if an email has to go out to your user base. This is basically the setup I have now at the office and it works great.

For a full reference, see: Django | Sending e-amil

Kitchener - Waterloo Conscience is the name, and it’s devoted to following a green life style and “conscience”, specifically focusing on the K-W Region. His latest take, on the new Bay in Conestoga Mall is a great look at what they have done to really promote the green attitude. I didn’t even know there was also some solar panels!

While browsing through this blog, I discovered this man, Ian, is also the driver of the Veg Van! Doesn’t get much better then a creepy looking blue box van that’s running on grease. It’s definitely an interesting look into something totally different.

I also don’t plug my good friend Corey enough, who recently redesigned his blog and is focusing on some interesting writing lately. I recommend you check it out, he will be posting a neat short story this Monday.

Enter Songbird. Songbird is an open source music player that is labeled the Firefox for music players. Why? Because It’s doing a good job of giving me what I want and oh it has those precious addons we Firefox users love so much.

Songbird makes me feel quite at home because it looks like iTunes, almost. It has the same structure and nearly the same style making the switch pretty easy on the UI-centered part of my brain.

Out of the box, it invites you to try out some of the features like its built-in concert finder which is simply powered by Songkick (Unfortunately, not available in Canada!) as well as Last.fm support, which as an avid user I am a huge fan of. You can extend the power of Songbird quite easily with addons like mashTape which not only function great, but are super easy to install!

The real reason I decided to try it out was beause iTunes was slow slow slow. Songbird is actually pretty fast. Importing my entire library of 5,000+ songs took only about 5 minutes and moving around in the player itself is pretty quick. No random lag and weird UI glitches like iTunes for Windows. Oh, did I mention Songbird is available for Windows, Mac, AND Linux? Hell yeah, you guys rock.

Of course, Songbird is still in development and not even in 1.0 status yet. Adding Podcasts (Subscriptions) was a bit wonky and I’m still having some trouble with a few that I want to subscribe to and video isn’t quite there yet. These guys are working hard however to get new updates out make a name for themselves in the music player community. You can follow them on Twitter to get a bit more insight into their day-to-day workings

Overall, I am so far very happy with Songbird. It does what I need it to do with minimal hassle and the importing of my iTunes library made it quick and easy to switch. Once a few more bugs are squashed and a few features are tightened up it should be one hell of a killer music player.

P.S - Songkick, please get some Canadian support for your listings!

This plays on the same idea that having multiple sources of income, even if those extra sources are little in comparison to your main source, it still adds up.

For example, for my short-term (non retirement) savings, I save money in three ways:

1. Using automatic deposits into a high interest savings account like my ING Account. Every week, ING takes out a set amount of dollars from my chequing into my savings. This is most people’s first step to savings and it works great, because you end up budgeting around the weekly deposits.
2. Saving your change adds up too. With my girlfriend, we fill up a huge pickle jar with change. Once every 4-5 months it gets full. Our last take out, we cleared well over $200 on change we would have never thought of using.
3. Don’t just save your change, save your dollars and bills. A woman from Boston saved $12,000 just by collecting her $5 dollar bills. I’ve begun to start doing this slowly and it’s a nice companion to saving change.