SYNTAX
        $ defaults write com.apple.screencapture location </new/path/>

EXAMPLE
        $ defaults write com.apple.screencapture location ~/Pictures/
        $ killall SystemUIServer

DEFAULT SETTINGS
        Default save location: ~/Desktop

Note: You’d need to kill SystemUIServer for changes to take effect.

Django comes with an optional redirects application that lets one store simple redirects in a database and handles the redirecting for you including returning "HTTP/1.0 410 GONE" responses. This "batteries included" application works great for many content redirects but I found I had a need to redirect entire sections of content to other sections requiring a wildcard redirect. Although there is no built-in functionality in the Redirect App for handling wildcard redirect patterns, the way the Django framework is setup allows one to easily modify and adapt new functionality such as handling wildcard redirects.

I copied the original middleware.py file (<python site-packages path>/django/contrib/redirects/middleware.py) into a new directory named redirects within my Django project directory and modified the code adding one additional code block and an optional check for relative vs. absolute URL paths. This method may not be perfect and could be modified to allow for complex pattern matching but it does demonstrate the ease at which the build-in code of the Django project can be modified for a more custom use. The full modified Django Redirect App middleware.py file is below.

Adding a Wildcard Redirect Check

        if r is None and settings.APPEND_SLASH:
        ...

        
        if r is None:
            # Try matching a wildcard
            try:
                r = Redirect.objects.get(site__id__exact=settings.SITE_ID,
                    old_path=path.rsplit("/", 1)[0]+"/*")
                # Check for 410 paths
                if r.new_path != '':
                    r.new_path = r.new_path + path.rsplit("/", 1)[1]
            except Redirect.DoesNotExist:
                pass
        
        if r is not None:
        ...

I added a second check, similar to the "APPEND SLASH" check, which splits the requested path at the last slash in the path and checks the database for the modified path appended with an asterisk such as "/manpage/*". For example, the request path: "/manpage/serveradmin.html" results in a 404 error. The path "/manpage/serveradmin.html" does not match any redirect entries in the database using the stock Redirect App middleware. The additional code block allows for the requested path to be slit looking for a matching base path. The middleware will query the database a second time looking for "/manpage/*". The entry's "new_path" value is the replacement for the matching part of the path. The "new_path" base: "/kbase/cli/" is prepended to the remainder of original requested path and returned as a "HTTP/1.0 301 MOVED PERMANENTLY" response redirect as "/kbase/cli/serveradmin.html".

Wildcard Redirect Entry for the Django Redirect App

Appending a Domain Name to the Redirect URL for Proxy Content

        if r is not None:
            if r.new_path == '':
                return http.HttpResponseGone()
            ## Include (cache server) domain name in path if missing
            if not r.new_path.startswith("http"):
                r.new_path = settings.MEDIA_URL.rsplit("/", 1)[0] + r.new_path
            return http.HttpResponsePermanentRedirect(r.new_path)
        
        # No redirect was found. Return the response.
        return response

For my specific setup, the public caching (edge) sever(s) and private application (origin) server use different domain names. A redirect that is proxy'ed back to the application server from the cache server causes a little redirect madness because of the domain names. To work around this issue, I added an if statement that checks whether the redirect path starts with "http". Should it not start with an absolute URL which starts with http, the MEDIA_URL set in the settings.py file is prepended to the redirect path making it an absolute path. The trailing slash in the MEDIA_URL is removed preventing a second "root" slash to the redirect path. The original request path "/manpage/serveradmin.html" is correctly redirected to "http://cmdz.org/kbase/cli/serveradmin.html" as are all path requests that start with "/manpage/".

Modified Django Redirects App

settings.py

# MIDDLEWARE_CLASSES settings from <project>/settings.py
MIDDLEWARE_CLASSES = (
    ...
    # 'django.contrib.redirects.middleware.RedirectFallbackMiddleware',
    '<project name>.redirects.middleware.RedirectFallbackMiddleware',
    ...
)

middleware.py

# Code from original redirect middleware file: <python site-packages path>/django/contrib/redirects/middleware.py
# The original file was copied into Django project as: <project name>/redirects/middleware.py
# code marked in red denotes changes made to the original file

from django.contrib.redirects.models import Redirect
from django import http
from django.conf import settings

class RedirectFallbackMiddleware(object):
    def process_response(self, request, response):
        
        
        if response.status_code != 404:
            return response # No need to check for a redirect for non-404 responses.
        path = request.get_full_path()
        
        
        try:
            r = Redirect.objects.get(site__id__exact=settings.SITE_ID, old_path=path)
        except Redirect.DoesNotExist:
            r = None
        
        
        if r is None and settings.APPEND_SLASH:
            # Try removing the trailing slash.
            try:
                r = Redirect.objects.get(site__id__exact=settings.SITE_ID,
                    old_path=path[:path.rfind('/')]+path[path.rfind('/')+1:])
            except Redirect.DoesNotExist:
                pass
        
        
        if r is None:
            # Try matching a wildcard
            try:
                r = Redirect.objects.get(site__id__exact=settings.SITE_ID,
                    old_path=path.rsplit("/", 1)[0]+"/*")
                # Check for 410 paths
                if r.new_path != '':
                    r.new_path = r.new_path + path.rsplit("/", 1)[1]
            except Redirect.DoesNotExist:
                pass
        
        
        if r is not None:
            if r.new_path == '':
                return http.HttpResponseGone()
            ## Include (cache server) domain name in path if missing
            if not r.new_path.startswith("http"):
                r.new_path = settings.MEDIA_URL.rsplit("/", 1)[0] + r.new_path
            return http.HttpResponsePermanentRedirect(r.new_path)
        
        # No redirect was found. Return the response.
        return response

Within a few minutes of reading the Twisted how-to tutorials for getting started with creating a simple TCP server" I had the response page serving correctly on my local machine.

Twisted installed on my Mac running Mac OS X 10.5.2 Leopard without a single warning. This is notable only because A.) I'm a moron, normally needing to use the gcc equivalent of a crowbar to wedge software into my development system, and B.) Once again I find that Leopard's pre-installed open-source software meets the minimal requirements for additional software so I can avoid dependence hell once again. FANTASTIC!

Below I have the Python script posted for the TCP server which follows the Twisted example for the most part. This service will respond with a predefined HTML statement to a request made to port 8007. The response doesn't need to be as drab (stable) as HTML. The self.transport.write can be altered to what is needed for your application.

Everything a language/computer/technology should do is _work_ and _get out of the way_ so that the task it is created or used for can be accomplished without out too much of that muck. Since everything is just a more complex version of simple pieces, like binary code or even DNA, incredible possibilities are possible once the simple piece can be created.

This is why I like Twisted. It was simple to implement and in some respects has gotten out of the way and allowed my mind to begin wondering past the "first response" and on to further tasks such as "what this should do".

#!/usr/bin/python

greeting = """
HELLO WORLD!
This is a TCP/IP Server written in Python using 
the Twisted networking framework.

It will respond on port 8007 of the local host
With a predefined greeting.
"""
print greeting

from twisted.internet.protocol import Protocol, Factory
from twisted.internet import reactor

class QOTD(Protocol):
	def connectionMade(self):
		self.transport.write("""
<!DOCTYPE html PUBLIC>
<html>
	<head>
		<title>Twisted TCP Server Example</title>
	</head>
	<body>
		<h1>HELLO WORLD!</h1>
		<pre>
This is a TCP/IP Server written in Python using 
the Twisted networking framework.

Further instruction can be found here:
<a href="http://twistedmatrix.com/projects/core/documentation/howto/servers.html">
	Twisted Documentation: Writing Servers
</a>

This server will respond on port 8007 of the local host
With a predefined greeting.
		</pre>
	</body>
</html>""")
		self.transport.loseConnection()

# Then lines are Twisted magic:
factory = Factory()
factory.protocol = QOTD

# Running under :8007
# Should be > :1024
reactor.listenTCP(8007, factory)
reactor.run()

Take away

Twisted is an amazing, simple to use, light weight Python based networking framework. Anyone interested in building applications that require networking connectivity should take a look at this project.

I was following along with the instructions from Chapter 2 of the Django Book, an online reference for learning and using Django a Python web framework when I hit a small snag in adding a database for my project. My initial experience with Mac OS X Leopard (10.5) and adding open-source software has been a pleasure.

I have yet to encounter the dependency nightmare I have experienced with previous Mac OS X systems. Of course, I have also tamed my need for the absolute bleeding edge of software by avoiding nightly builds and the like, at least for time being.

Installing Django

# Download Django <URL: http://www.djangoproject.com/download/ />
dev:www $ tar xzvf Django-*.tar.gz.
dev:www $ cd Django-*.
dev:www $ sudo python setup.py install

# Test the django module
dev:www $ python
>>> import django
>>> django.VERSION

Add MySQL Support to Python

Adding MySQL support for Python presented the only issue. A unexpected configuration error prevents the MySQLdb module from compiling and then a different issue throws a 'file not found' error when the module is loaded into Python.

I am not familiar enough with either system to say which developer has changed their installed path or even if it is some erroneous oversight on my part when originally installing MySQL or MySQLdb. In any case, here is what I need to do to complete the compile and install of MySQLdb for Mac OS X Leopard:

Update: Installing on Mac OS X Server Leopard 10.5

When compiling/installing MySQLdb for Mac OS X Server Leopard 10.5.x one will receive a different error for gcc about not being able to find my_conf.h. Because MySQL 5.0 is pre-installed in the Server addition this error stumped me until I read an Apple Support Article that explains that the client header files (.h) are not included with the Server edition for what I can only imagine is some sort of security preference.

$ curl -O http://www.opensource.apple.com/darwinsource/other/MySQL-43.binaries.tar.gz
# Follow the instructions to add MySQL header files.

Mac OS X (Client) Leopard does not come with MySQL pre-installed and the standard binary package for installing from MySQL includes the client and server files needed to interact with the service as well as the bits needed for MySQLdb. A small note that SQLite is supported by default as of Python 2.5+ and is the staple for use in many Cocoa applications for Mac OS X. For local application support or general 'tinkering' its pretty handy database, just not as fast as MySQL when it comes to dynamically serving content to web clients.

# Download the latest stable version of MySQLdb
# <URL: http://mysql-python.sourceforge.net/ />
$ tar xzf MySQL-python-*.tar.gz
$ cd MySQL-python-*
$ find / -name mysql_conf

# Edit site.cgf at line 13 to add your full mysql_conf path
mysql_config = /usr/local/mysql/bin/mysql_config

# <URL: http://forums.mysql.com/read.php?50,175059,179979#msg-179979 />
# Edit these lines from _mysql.c

 37	//ifndef uint 
 38	//define uint unsigned int 
 39	//endif 

484	//uint port = MYSQL_PORT; CHANGED to next line
485	unsigned int port = MYSQL_PORT;
486	//uint client_flag = 0; CHANGED to next line
487	unsigned int client_flag = 0;

# Issue 1 is now solved and you can compile MySQLdb
$ python setup.py build 
$ sudo python setup.py install 

# Issue 2 is solved by creating a symbolic link to libmysqlclient_r.15.dylib library.
$ sudo mkdir /usr/local/mysql/lib/mysql 
$ sudo ln -s /usr/local/mysql/lib/libmysqlclient_r.15.dylib\
	/usr/local/mysql/lib/mysql/libmysqlclient_r.15.dylib

# test MySQLdb module in python
$ python
>>> import MySQLdb

# no trace back errors == 'sweetness'

For future reference

System paths for Mac OS X Leopard (10.5) default pre-installed Python framework.

$ python
>>> import sys
>>> print sys.path
	''
	'/Library/Python/2.5/site-packages/MySQL_python-1.2.2-py2.5-macosx-10.5-ppc.egg'
	'/System/Library/Frameworks/Python.framework/Versions/2.5/lib/python25.zip'
	'/System/Library/Frameworks/Python.framework/Versions/2.5/lib/python2.5'
	'/System/Library/Frameworks/Python.framework/Versions/2.5/lib/python2.5/plat-darwin'
	'/System/Library/Frameworks/Python.framework/Versions/2.5/lib/python2.5/plat-mac',
	'/System/Library/Frameworks/Python.framework/Versions/2.5/lib/python2.5/\
		plat-mac/lib-scriptpackages',
	'/System/Library/Frameworks/Python.framework/Versions/2.5/Extras/lib/python',
	'/System/Library/Frameworks/Python.framework/Versions/2.5/lib/python2.5/lib-tk',
	'/System/Library/Frameworks/Python.framework/Versions/2.5/lib/python2.5/lib-dynload',
	'/Library/Python/2.5/site-packages',
	'/System/Library/Frameworks/Python.framework/Versions/2.5/Extras/lib/python/PyObjC'

Start a New Project

$ mkdir Django
$ cd Django/
$ django-admin.py startproject LearningDjango
$ ls -1 LearningDjango/
total 24
__init__.py		# Python sees this directory as a package
manage.py		# command-line utility
settings.py		# Django project settings and configuration
urls.py			# "Table of Contents" for the project

Start the Development Server

$ python manage.py runserver
Validating models...
0 errors found.

Django version 0.96.1, using settings 'LearningDjango.settings'
Development server is running at http://127.0.0.1:8000/
Quit the server with CONTROL-C.
[08/Jan/2008 20:12:10] "GET / HTTP/1.1" 404 2069