If you’ve got Django view code that gets & sets session values, you’ll want to test it properly, and the standard “self.client” from Django’s TestCase doesn’t really give you a usable session.  So, here’s the method I’m using:

def stuff_session(client, dictionary):
    """Given a client (self.client in a unit test TestCase) set the session to the contents of
    the dictionary given"""
    from django.conf import settings
    from django.utils.importlib import import_module
    engine = import_module(settings.SESSION_ENGINE)
    store = engine.SessionStore()
    store.save()  # we need to make load() work, or the cookie isworthless
    client.cookies[settings.SESSION_COOKIE_NAME] = store.session_key
    session = client.session
    session.update(dictionary)
    session.save()
    # and now remember to re-login!

So, in my setUp() methods, I just call stuff_session(self.client, {‘key’: ‘value’}) and it all works out great.

I had a need to implement a local port forward on my machine. (more details coming).  I could use ssh to do this, but decided to write a simple shell script using nc instead.  Here’s the script, which I’m calling port_forward.sh

#!/bin/bash
# Run as root if your listening port is < 1024!

FIFO=$(mktemp -u)
trap "rm -f $FIFO; killall -9 nc; exit 255;" SIGINT SIGTERM SIGKILL
mkfifo $FIFO

while true; do
    # echo "Listening..."
    cat $FIFO | nc -k -l localhost $1 | nc localhost 6543 > $2
done

And then, you run it like this:

$ ./port_forward.sh 80 8080

Enable the Universe repository and apt-get install zaz or use the Update Manager to install.  It’s got a pretty interesting dynamic and twist on the original Zuma.

(FYI this is on Ubuntu 8.04.4 LTS)

• Runs on Ubuntu
• Is either:
  • Available in the standard distro (i.e. via apt-get)
  • A simple self-contained script (Python, Perl, Bash, etc.)
• Uses ssh/scp/rsync to transport files
• Is incremental (i.e. does “what’s changed from last time”, and only backs up that much)
• Handles file renames & moves without re-transmitting the underlying data.
• Puts files in a simple “directory by date” format.  No fancy databases, no fancy metadata required for restoring.
• Preserves file permissions & modification dates.
• Correctly handles both hard & soft symbolic links.
• Is client-side only.  In other words, I don’t want to have to maintain 2 copies of this script, one for the server, and one for the client.

Is there anything out there that meets these requirements?

$ git push
Counting objects: 50, done.
Compressing objects: 100% (33/33), done.
Writing objects: 100% (36/36), 4.42 KiB, done.
Total 36 (delta 13), reused 0 (delta 0)
error: unable to write sha1 filename ./objects/fc/0bf175cf9bf2ecdf15eee84adad32230107aa7: Permission denied

fatal: failed to write object
error: unpack failed: unpacker exited with error code
To slacy@myhost.com:/home/git/name-of-repo
 ! [remote rejected] master -> master (n/a (unpacker error))
error: failed to push some refs to 'slacy@myhost.com:/home/git/name-of-repo'

The issue turned out to be that because I’m using ssh + git to push the files, the files in the .git/objects directories are created with the user+group of the user on the host.  So, the first user to create the file makes them with their own userid & groupid, and are set with default permissions as u=rxw,g=rx,o=rx, and thus, when the second user comes it to add a new file to that pre-existing subdirectory, they don’t have permissions.

I tried to solve this issue by creating “group git” and adding all users who are using the repository in /home/git/name-of-repo, but it still turns out that new files are created with userid:groupid as user:user not user:git.

How do you get around this issue?  How do I make it so that new directories created by git during the push process are given the correct permissions (u=rxw,g=rxw,o=) and assigned to group git instead of the user group?

This issue is easy enough to fix manually, by doing something along the lines of:

$ ssh userid@myhost.com
(myhost.com)$ cd /home/git/name-of-repo/.git/objects
(myhost.com)$ find . type d | xargs chgrp git
(myhost.com)$ find . type d | xargs chmod g=rxw

But, I’m going to have to continue to do this as new directories in the “objects” area are going to continue to be created with the wrong permissions.

GIT HAS THE WORST ERROR MESSAGES IN ANY PIECE OF USER-FACING SOFTWARE I’VE EVER SEEN.

There, I said it. Peace out.

UPDATE:

Just read about the git config setting “core.sharedRepository” which will automatically give group rwx permissions to newly created files in the repository.  So, I ran:

$ git config --add core.sharedRepository group

All I wanted to do was throttle a stdout pipe that’s being sent to the music player.  I found reference to a utility called throttle, but also found that it isn’t included in the Ubuntu 9.04 distribution.

There’s a maliing list post that says that the program cstream will do the same thing.

man cstream says:

-t num    Limit the throughput of the data stream to num bytes/second. Limiting is done at the input side, you can rely on cstream not accepting more than this rate. If the number you give is positive, cstream accumulates errors and tries to keep the overall rate at the specified value, for the whole session. If you give a negative number, it is an upper limit for each read/write system call pair. In other words: the negative number will never exceed that limit, the positive number will exceed it to make good for previous underutilization.

So, I changed my audio transcoding script to say:

lame –quiet -V6 $FILE – | cstream -t 25000

The number “25000″ comes from the fact that I don’t want to use more than 192kbps of my outbound stream, and cstream’s argument is in bytes per second.  192kbps = 24000 bytes/second, and I added a little extra.  It would probably be safer if I also passed “-B 192″ to lame, but that would actually limit my overall quality, so I’m just going to cross my fingers and hope that “-V6″ doesn’t produce >192kbps for very long.

mt-daapd is an iTunes daap-protocol server for Unix systems.  I’m using mt-daapd on by Ubuntu 9.04 system to stream music over the internet to my workplace.   The issue is that many of my mp3 files are 256kbps mp3 files, and streaming these takes up more bandwidth than necessary.

mt-daapd includes a transcoding system called “ssc” for “Server Side Conversion”.  This system works by either a shared-object plugin (i.e. ssc_ffmpeg) or via an external script file (i.e. ssc_script).

using the ssc_script functionality, one can invoke ‘lame’ (the mp3 encoder) to transcode high bitrate mp3 files into lower bitrate mp3 files.  The setup for this in mt-daapd wasn’t very obvious, so I’ll document it here.

Install mt-daapd

The version of mt-daapd provided by Ubuntu 9.04 includes support for transcoding, so you can just run:

$ sudo apt-get install mt-daapd

Turn on ssc

Edit your /etc/mt-daapd.conf file, and make sure you have the following lines in the correct places:

ssc_codectypes = mpeg

always_transcode = mpeg

ssc_prog = /path/to/script/shown/below/mt-daapd-mp3-ssc.sh

[plugins]

plugins = ssc-script.so

Create mt-daapd-mp3-ssc.sh

You’ll need to create a shell script to do the transcoding via ssc_scrpit / ssc_prog.  Here’s the script I’m using:

#!/bin/bash

FILE=$1
OFFSET=0

if [ "$2" == "" ]; then
OFFSET=0
else
OFFSET=$2
fi

if [ "$3" == "" ]; then
FORGELEN=$3
fi

lame -V6 –quiet “$FILE” -

Note that I’m looking at the 2nd and 3rd args, but I’m not doing anything with them.  These arguments are used to make sure that seeking works properly in your daap client.  I don’t care about seeking, and doing it properly is somewhat hard, so I’ve just ignored those arguments.  I think that this could be accomplished properly using the program ‘mp3splt’ but I haven’t looked into it enough to see what it would take.

Make sure the script above is put somewhere accessible by the user specified as ‘runas’ in your mt-daapd.conf.   Make sure the script is executable by this user as well.

Restart mt-daapd and see if it works

Restart mt-daapd via:

$ sudo /etc/init.d/mt-daapd restart

Then reconnect your daap client (I use rhythmbox).  You can see if the script is working by running “ps auwxww | grep lame” just after pressing play on a song.  You should see your script executing lame and doing realtime transcoding.

I started out with netjuke, which died and got absorbed into the horrible jinzora project.   So then I switched to Ampache, which worked fairly well, but needs some serious UI upgrades/changes to make it reasonably useful.

Now that I’m fully ubuntu-ized, I’m using mt-daapd through an SSH tunnel to listen via a native client app.  This solution has lots of interesting benefits:

1. Running mt-daapd locally means other people in my house can see my music, including my TiVo and any other desktops with an iTunes/daap compatible frontened.
2. I don’t have to worry about security issues with having all my music accessible via a web portal that could be hacked.
3. mt-daapd is available as a package in Ubuntu, so that means upgrades are easy.  Doing upgrades (by hand) of php-based web apps was really becoming a drag.
4. This means less junk on my slacy.com web server, which I’m trying to significantly trim down and make more secure by having less applications.

Several others are talking about compiling it from source, but this seems very wrong and unnecessary to me.

If you have any other information about how to easily via apt-get make RRDTool functions work in php in Ubuntu 9.04, please leave a comment here.

I’m not sure why this has to be so complicated.