After a short search on the web, I found a nice little discussion on a newsgroup that explained how to do it for cygwin. I just wanted to note the steps for windows XP, just so I don’t forget (If you really care… you can find steps for other versions on the discussion board).

1. Edit Registry

Start regedit.exe.

HKEY_CLASSES_ROOT\Directory\shell\BashHere="Bash Here"
HKEY_CLASSES_ROOT\Directory\shell\BashHere\command="C:\\WINDOWS\\System32\\CMD.EXE /E:4096 /c C:\\cygwin\\cygwin.bat %1"

Adjust the path to cygwin.bat if necessary.

Finish regedit.

You should now see the entry “Bash Here” in the context menu of a folder. However, when you use it, it will start the shell in your home directory ($HOME).

2. Edit cygwin.bat in c:/cygwin

Insert “set BASHHERE=%1″ before the line with “bash…”. This Environment variable now contains the complete path of the opened folder and is availabile in the bash shell (echo $BASHHERE).

3. Edit profile

Make $BASHHERE the current directory by adding the following line to
/etc/profile or ~/.profile:

if [ "$BASHHERE" != "" ]; then
    cd $( echo $BASHHERE | tr "\134" /)
fi

• CTRL + R: Reverse search through history for a previously used command;
• CTRL + A: Moves your cursor to the beginning of the current line;
• CTRL + E: Moves your cursor to the end of the current line;
• ALT + F: Moves your cursor forward one word on the current line;
• ALT + B: Moves your cursor backward one word on the current line;
• CTRL + W: Deletes the word before the cursor;
• ESC + D: Deletes the word after the cursor;
• CTRL + U: Clears the line before the cursor position. If you are at the end of the line, clears the entire line;
• CTRL + K: Clears the line after the cursor;
• CTRL + C: Kills the current running process;
• CTRL + Z: Suspends the current job and runs it as a background process;
• TAB: Auto-complete files and folder names;

For the sake of completeness, I’ve added these other shortcuts that I saw on another website. However, I find that I do not use those on a regular basis. In reality, there are plenty more bash keyboard shortcuts around, but I just never bothered trying them out yet… For a much more extensive list of shortcuts (way too extensive for my tastes), visit web hosting uk‘s blog post on the subject.

• CTRL + L: Clears the Screen (I use the “clear” command);
• CTRL + H: Same as backspace;
• CTRL + D: Exit the current shell (I type “exit” in Putty);
• CTRL + T: Swaps the last two characters before the cursor;
• ESC + T: Swaps the last two words before the cursor;
• CTRL + XX: Moves between end-of-line and current cursor position;
• CTRL + Y: Recovers previous deletion (Not file deletion!);

A little on gzip files

A gzip file is simply a file formatted in a certain way, using a compression algorithm called DEFLATE, that makes the file smaller (read more on wikipedia) that It is best to use gzip when trying to save some space, but still want to have easy access to your files for peeking in them (see speed results of grepping through log files at bottom). The scenario where I use gzip the most is for compressing 100-200 log files, each 20-30 megs (again, see stats at bottom for space gains). An important feature of gzip is that it applies to single file (this is not a ZIP file people!) and so you will end up with 100-200 little gzip files, instead of big ones. This can be a little annoying for transferring to clients, and handling in general (notice the for loop in my bash script).

# gzip multiple files
for i in `find . -name "*.log"`; do gzip $i; done
 
# grep through all those gzip files
for i in `find . -name "*.log.gz"`;do zgrep "TIME" $i; done

A little on tarball files

The ideal situation in which to use a tarball is when you want to compress directories and data files, which you want to bundle up in one nice and tidy package for users/clients to download but still preserve some of the file system information such as permissions and directory structure (read more on wikipedia). Note here that the end product is one file, which can be extremely useful in some cases (even a necessity at times). I say a necessity because sometimes, when handing in log files through a ftp, you may want to have one package that you’ve encrypted for your client (using pgp), in which case you wouldn’t want to have 20-30 small packages all encrypted separately… In any case, to produce a tarball with a lot of logs, you can do the following under bash:

# Create a tarball
tar -czvf logs.tar.gz *.log
 
# grep through a tarball
zcat logs.tar.gz | tar -xvf - | xargs grep "TIME"

Storage vs Speed for grepping through different types of files

Notice enormous gain in space going from raw log files to gzip log files. You have a 93% reduction in size (RAW to GZIP), compared to a mere 0.05% reduction in size by going from many GZIP files to one tarball. Now, I didn’t even talk about the loss in speed when compressing. That is, of course, the most important thing to consider when dealing with files that you will need to peek through from time to time (logs are a perfect example).

In order to compare the speed for each scenario, i used a very simple bash script, which I copied here for documentation (notice that I redirect the output to a ‘toto’ file so that i don’t get anything printed on my screen). The performance of my ‘grep’ command on the RAW logs was very good, 2 seconds to find 107 336 occurences of “TIME” in the 10 logs. Now comparing this with the results of the GZIP logs and the TARBALL, 3 and 19 respectively, you can quickly see that it is extremely advantageous to use gzip for log files (Look at the little graph of the different time if you are a more visual person…). Not only the gain in storage is negligible when going from GZIP to TARBALL, but the speed at which you have access to your data is a lot slower.

echo "Testing speed of RAW"
echo "===================="
echo $(date)
for i in `find . -name "*.log"`;do grep "TIME" $i >> toto; done
echo $(date)
 
echo "Testing speed of GZIP"
echo "===================="
echo $(date)
for i in `find . -name "*.log.gz"`;do zgrep "TIME" $i >> toto; done
echo $(date)
 
echo "Testing speed of TARBALL"
echo "======================="
echo $(date)
zcat logs.tar.gz | tar -xvf - | xargs grep "TIME" >> toto
echo $(date)

Concluding remark

The are situations where a tarball is necessary (or advantageous), but, in general, to keep the size of many log files down and still be able to search through them, I recommend using gzip. Not to mention that all your favorite bash commands come in a gzip flavour (zcat, zgrep, zdiff, zmore, etc) and vi can easily read a gzip file on the fly! What more can you ask for!

I know that there are processes that backs up your whole $HOME on a regular schedule, I forget the name of this process, but that’s not exactly what I need. I always liked the idea of a “recycling bin” from the GUI Operating Systems like Windows (or KDE) and decided that that’s exactly what I needed. I found the next best thing on the internet (See John’s Bash Tools for his original post).

I simply put this in my .bashrc and now can use “junk” instead of “rm”… It’s a pretty neat little trick actually. I then can use “empty_junk” every now and then to keep the size of my home reasonable. I could even add “empty_junk” in my .bashrc so that it gets emptied everytime I log on (I won’t because I often log onto twice at the same time and would create problems…).

##############################
# Emulating a reclycling bin #
##############################
# This function creates a directory called .junk
# and creates directories labeled by the date
# inside of this directory. Then, when a file is
# "junk"ed, it is actually just moved to this
# directory. The command line accepts as many
# files as you would care to junk, and can even
# work on entire directories. Be careful, since it
# is really just a wrapped "mv" command, you may
# overwrite your junked files if they both have
# the same name and end up in the root directory.
 
function junk () {
    TODAY=$(date +%d-%m-%y)
    if [ ! -e $HOME/.junk/$TODAY ]
    then
        mkdir -p $HOME/.junk/$TODAY
    fi
 
    for x in $@
    do
        mv $x $HOME/.junk/$TODAY
    done
}
 
# A very simple function to empty the trash.
# I set -Ri so that it recurses but prompts you.
 
function empty_junk () {
    rm -Ri $HOME/.junk/*
}