sudo apt-get install ufraw-batch

Now, you can easily and quickly dump your RAW images into JPEGs:

find . -maxdepth 1 -type f -iname "*.cr2" | while read file do
    ufraw-batch --wb=camera --exposure=auto \
        --out-type=jpeg --compression=90 \
        --output="${file%.CR2}.JPG" \
        "$file"
done

The above command will find all files ending in CR2 in the current directory and convert them to JPEGs in the same directory.

You can ask MPlayer to dump WMA files into WAV files, which you can then transcode into MP3 files:

mplayer "myfile.wma" -vo null -vc dummy -af resample=441000 \
    -ao pcm:waveheader \
    -ao pcm:file="out.wav"

Alternatively, you can write it directly to lame‘s standard input to daisy-chain the operation:

mplayer "myfile.wma" -vo null -vc dummy -af resample=44100 \
    -ao pcm:waveheader \ 
    -ao pcm:file=>(lame -b 192 -q 0 - "out.mp3")

Pretty standard stuff, write all standard output to a file:

# write the stdout of mycommand to myfile.log
mycommand > myfile.log 

Write all standard output and standard error to a file:

# write the stdout and stderr of mycommand to myfile.log
mycommand 2>&1 > myfile.log

Write standard input to one file and standard error to another file:

# write stdout of mycommand to myfile.log and stderr of mycommand to myfile.error.log
mycommand 2> myfile.error.log > myfile.log

Append standard output to a file (not completely overwriting it as above):

# append stdout of mycommand to myfile.log
mycommand >> myfile.log

The same can be done with stderr:

# append stderr of mycommand to myfile.error.log
mycommand 2>> myfile.error.log

You can also force-clobber the file if you really want it to overwrite things:

# force-overwrite stdout of mycommand to myfile.log
mycommand >! myfile.log

Now, let’s move on to piping.

Instead of writing all standard output to a file, we’ll print it and write it to a file with tee:

# pipe the stdout of mycommand to `tee`, which will print it and write it to myfile.log
mycommand | tee myfile.log

What about standard error, though? You can redirect standard error to standard out:

# pipe the stdout of mycommand (pushing stderror to stdout) to `tee`
mycommand 2>&1 | tee myfile.log

Or, redux: accomplish that whole standard error redirect in less characters:

mycommand |& tee myfile.log

And, just for kicks, redirect standard output to standard error:

mycommand >&2 

As far as Bash i/o redirection goes, that’s pretty much it. Have fun!

There’s no command like drop all tables;, neither is there a command that will allow you to drop or truncate multiple tables at once like drop table users, addresses, locations;. You’re left with doing it line by line in a tedious, repetitive manner like so:

drop table users;
drop table addresses;
drop table locations;

If you have a lot of tables, this simply doesn’t work.

If you have a Bash-like shell, you can do it in a much more efficient way via the mysql command and the mysqldump command and some regular expression hackery:

mysqldump -u username --password=password --add-drop-table --no-data database_name | grep ^DROP | mysql -u username --password=password database_name

Winning! If you want to do the same thing for truncating all databases, look no further:

mysqldump -u username --password=password --add-drop-table --no-data database_name | grep ^DROP | sed "s:^DROP TABLE IF EXISTS:TRUNCATE TABLE:g" | mysql -u username --password=password database_name

Now that you’ve emptied your database, it’s time to weep that you forgot to make a backup

via thingy-ma-jig.co.uk

]]>

mpg123 -w output.wav input.mp3

Or, if you’d prefer to use lame:

lame --decode input.mp3 output.wav

Perhaps you live on the wild side and would like to use FFMPEG:

ffmpeg -i input.mp3 output.wav

As you can see, it’s pretty darn simple to do, so have at it!

find . -type f -iname "*.mp3" | while read file 
do
    mv "$file" "${file}.old" && \
    lame --mp3input -q 0 -b 320 --resample 44.1 "${file}.old" "$file" && \
    id3cp "${file}.old" "$file" && \
    mv "${file}.old" "/tmp/${file%.old} 
done

It’s pretty simple logic. We chain everything together with “&&” so that if any one piece in the puzzle fails, it’ll stop executing. First, we move the file to it’s name plus “.old” (so “01 – The Early Days.mp3″ becomes “01 – The Early Days.mp3.old”). Then, if that works we convert the file with lame. We force lame to assume that it’s an MP3 file, because it is, set it to highest quality and a constant bitrate of 320, resample it to 44.1kHz, and rename the output to the original file name. Then, if that worked, we copy all ID3 tags from the old file to the new one. When that’s done, we move the old file to the /tmp directory so we can delete it if everything went well or restore it if we need to.

First, let’s install everything we’ll need:

sudo apt-get install redmine redmine-sqlite libapache2-mod-passenger gitosis git-core

Note: you can replace redmine-sqlite above with either redmine-mysql or redmine-pgsql to use those databases rather than SQLite. I prefer SQLite, so that’s what I’m sticking to.

Redmine

Now let’s focus on getting Redmine installed. Let’s make it available via Apache with the Passenger module. First, symlink your Redmine configuration to exist in your web server. My web server’s root directory is at /var/www, so I’ll symlink mine to /var/www/redmine:

sudo ln -s /usr/share/redmine/public /var/www/redmine

Now, let’s edit Passenger so that the module runs as the right user. Edit the /etc/apache2/mods-available/passenger.conf file, adding the following line between the <IfModule ...> tags:

PassengerDefaultUser www-data

Save it, exit and let’s keep going. Now, configure the Redmine location in your Apache virtual host by adding the following few lines into your virtual host definition file at /etc/apache2/sites-available/default:

<Directory /var/www/redmine>
    RailsBaseURI /redmine
    PassengerResolveSymlinksInDocumentRoot on
</Directory>

Now, enable the Passenger module and restart Apache:

sudo a2enmod passenger
sudo /etc/init.d/apache2 restart

Finally, visit localhost/redmine in your browser and login using “admin” as a username and “admin” as a password. Coolness. Now, onto Gitosis.

Gitosis

We’ve already installed Gitosis using the command above. Now, let’s configure it for use.

First, reconfigure Gitosis to use your RSA SSH key. If you don’t have SSH set up, you should do that first so that this key exists.

sudo -H -u gitosis gitosis-init < ~/.ssh/id_rsa.pub

Now, let’s check out the Gitosis admin repository, so we can make our changes to the configuration settings.

git clone gitosis@yourserver.com:gitosis-admin.git

Note: if you’ve really locked down your SSH server and only permit certain users from connecting, you’ll have to add the user “gitosis” to your AllowUsers list in /etc/ssh/sshd_config.

How do we add a project? All we really need to do is to add the following to the gitosis-admin/gitosis.conf file:

[group {PROJECT_NAME}]
writable = {PROJECT_NAME}
members = {KEYFILE_NAME}

What this really translates to is something like this:

[group android-project]
writable = android-project
members = mykeyfile@myhost.com

Voila! Simply git add *, git commit, and git push to commit your changes. To add a remote origin to your existing Git projects, run the following command in the basedir of your Git repository:

git remote add origin gitosis@localhost:android-project.git
git push origin master

Now, simply point Redmine at your repository’s location, which follows the following pattern:

/srv/gitosis/repositories/{REPO_NAME}.git

or, in the real world:

/srv/gitosis/repositories/android-project.git

And we’re done! Pretty easy, huh?

#!/bin/bash
$@ > /dev/null 2>&1 &
disown $!

I know it’s not much, but let’s look at an example. Suppose you wanted to start ‘gedit’ in the background. Here’s how you’d do it with ‘fart’:

fart gedit

Here’s how you’d do it without ‘fart’:

gedit > /dev/null 2>&1 & \
disown $!

Much easier. Enjoy. Make sure you make ‘fart’ executable and put it on your path via the following:

chmod +x fart 
mv fart /usr/local/bin 

You want to find out if any ports are open between ports 1024 and 2048 on another computer on your network. With the legendary knowledge of netcat that you have, you enter the following in your terminal:

netcat -z 192.168.1.5 1024-2048

Note that this does actually take some time to complete. Alternatively, you can use the short form of the above:

nc -z 192.168.1.5 1024-2048

It’s as easy as that. netcat will dump out any info on ports it finds that are open.