This post outlines some changes I made that will allow me to use both bash and zsh with the same startup files, but still have some shell specific settings that will get sourced. I didn’t need to move the files to ~/.shellfiles, but I felt having all of them as symlinks instead of some being symlinks to other dotfiles. Some of the shell specific things are setopt/shopt commands, setting prompts, and history settings.

I am storing the files in ~/.shellfiles, it isn’t my preferred choice, but it is less likely to be used by something else. Since I use version control on my home directory I needed to first ‘hg rename’ each one of my files to the ~/.shellfiles directory. After moving the files symlinks needed to be created to the original files.

.bash_logout -> .shellfiles/logout
.bash_profile -> .shellfiles/profile
.bashrc -> .shellfiles/rc-shell
.profile -> .shellfiles/profile
.zlogout -> .shellfiles/logout
.zprofile -> .shellfiles/profile
.zshenv -> .shellfiles/env
.zshrc -> .shellfiles/rc-shell

Inside of ~/.shellfiles/profile two variables are set and two log entries are added to ~/.shellfiles/shell_history, which I added as a log of when shells are exec’d, what files are sourced, and the order they are sourced. The following shows what happens when I login, open a shell, do some work, and then switch from zsh to bash.

################################# LOGIN ########################################
02/20/10 10:19:12
 .shellfiles/profile

02/20/10 10:19:12
 .shellfiles/rc-shell
 .shellfiles/rc-zsh
 .shellfiles/completion-zsh
 .shellfiles/functions
 .shellfiles/aliases

02/20/10 10:19:36
 .shellfiles/env

02/20/10 10:19:36
 .shellfiles/rc-shell
 .shellfiles/rc-zsh
 .shellfiles/completion-zsh
 .shellfiles/functions
 .shellfiles/aliases

02/20/10 10:19:41
 .shellfiles/rc-shell
 .shellfiles/rc-bash
 .shellfiles/completion-bash
 .shellfiles/functions
 .shellfiles/aliases

From time to time I need to refresh a file like my aliases or functions so I created a function, ‘refresh’, that I can run to source files and take into account dependencies and add the log entry for that file. So that if I run ‘refresh aliases’, I would have a history entry like this.

02/20/10 10:47:30
 .shellfiles/aliases

I’ll admit the shell history might be a bit overboard, but I needed to implement it when I was initially splitting up files so that I could ensure the correct files were sourced in various situations.

Within ~/.shellfiles/rc-shell I have a section at the top that sources shell specific files, and below that it has shared exports, sourced files, and operations.

if [ -z "$ZSH_VERSION" ] && [ -z "$BASH_VERSION" ]; then
  CUR_SHELL=$(echo $SHELL  | awk -F'/' '{print $NF}')
elif [ -n "$BASH_VERSION" ]; then
  CUR_SHELL='bash'
elif [ -n "$ZSH_VERSION" ]; then
  CUR_SHELL='zsh'
else
  CUR_SHELL='bash'
fi

printf "\n$(date +"%D %T") \n .shellfiles/rc-shell\n" >> $SHELLHISTORY

if [ -f "$SHELLFILES/rc-$CUR_SHELL" ]; then
  . "$SHELLFILES/rc-$CUR_SHELL"
fi

#------------------------------------------------------------------------------#

# Shared between zsh and bash

if [ -f "$SHELLFILES/functions" ]; then
  . "$SHELLFILES/functions"
fi
.....

When a user is logging into the system the actual version of the shell is not available, so you need to base the startup files on the user’s shell. Within a console or within a script the versions are available, so if when you open a terminal it will determine if it is bash or zsh based on checking if the version variable for each shell has a value greater than 0. Once the it is known what shell we are in the proper files will be sourced.

I first wanted to have these be in a specific keyring for the purposes of knowing who was at each keysigning. To make sure your key gets added to the keyring you need to specify not to use the default keyring and use a specific keyring.. Make sure you include your keyid in the list of keys to pull from the keyserver as it will be needed when PIUS runs against the specific keyring.

I added this to my ~/.gnupg/gpg.conf file so I can have all the keyrings included all the time.

# List of keyrings
# Key Signing Party, 2010-01-22
keyring keysign-20100122.gpg

touch ~/.gnupg/keysign-20100122.gpg
gpg --no-default-keyring --keyring keysign-20100122.gpg --recv-keys F6F08D6A ...

With your key and the keys of the other participants in the new keyring download PIUS, a tool written by a friend and coworker, Phil Dibowitz. I preferred having it installed in ~/bin since that is added to my path automatically.

After it is installed run it against the keyring you created. The example below works with Gmail/Google Apps mail accounts.

KEYID="F6F08D6A"
USER="peter.manis@gmail.com"
MAIL="-P 587 -H smtp.gmail.com"
pius -s $KEYID -u $USER $MAIL -A -r keysign-20100122.gpg

We had to add our key to the keysign-20100122.gpg keyring so PIUS would use it to sign keys. So we don’t really need it in that keyring anymore. The problem with removing it is that GPG requires the secret key be deleted first so we need to work around this. Please BACKUP your files first so that if you make a mistake you don’t delete you entire keyring.

touch ~/.gnupg/empty.gpg
gpg --no-default-keyring --secret-keyring empty.gpg --delete-key F6F08D6A

My method for importing the keys was copying the PGP message in the email and saving it to a file with the extension ‘gpg’. After that I was able to run the following for loop and import them all.

for i in $(ls *.gpg); do cat $i | gpg -d | gpg --import; done

Now you can send the key to the keyservers

servers="x-hkp://pool.sks-keyservers.net pgp.mit.edu"
for server in $servers
    do gpg --keyserver $server --send-key F6F08D6A
done

Over time you need to refresh your keys since the other people will have signatures added to their keys.

gpg --refresh-keys

If you need to refresh keys in files you don’t have in gpg.conf you can run this

gpg --no-default-keyring --refresh-keys --keyring keysign-20100122.gpg

UPDATE: I would recommend maybe setting a variable before starting this with the details that will be used multiple times and substitute it in the commands above.

KEYID='F6F08D6A'
KEYRING=''keysign-20100122.gpg"

# .bash_functions
function register_alias() {
  local alias=$(echo $* | cut -d'=' -f 1)
  local TEMP_CMD=$(which $alias)
  local TEMP_ALIAS=$(echo "`alias`" | sed 's/alias\ \(.*\)=.*/\1/' | grep ^$alias$)
  if [ ${#TEMP_CMD} -gt 0 ]; then
    echo "Alias $alias conflicts with command $TEMP_CMD"
  elif [ ${#TEMP_ALIAS} -gt 0 ]; then
    echo "Alias $alias conflicts with alias $alias"
  else
    alias "$*"
  fi
}

# .bashrc
if [ -f ~/.bash_functions ]; then
  . ~/.bash_functions
fi

# .bash_aliases

register_alias sls='screen -ls'
register_alias sdr='screen -d -r'

Update: I changed the TEMP_ALIAS line to use sed instead of cut/sed

I prefer to just type in the machine I want to ssh to instead of typing ssh in front of it. This chunk of code goes in my ~/.bashrc file and creates an alias for each “Host …” entry in ~/.ssh/config. It checks to see if there is an existing command that matches the Host entry, and alerts you if there is a conflict

# Generate SSH aliases
for host in $(grep ^Host .ssh/config | sed s/Host\ //g); do
  TEMP_CMD=$(which $host)
  TEMP_ALIASES=$(echo "`alias`" | sed 's/alias\ \(.*\)=.*/\1/' | grep ^$host$)
  if [ ${#TEMP_CMD} -gt 0 ]; then
    echo "Alias $host conflicts with command $TEMP_CMD"
  elif [ ${#TEMP_ALIASES} -gt 0 ]; then
    echo "Alias $host conflicts with alias $host"
  else
    alias $host="ssh $host"
  fi
done

When you open a terminal you will see something like this if you have conflicts.

Alias www conflicts with alias www
Alias hg conflicts with command /usr/bin/hg
Alias git conflicts with command /usr/bin/git
[20:05:21] manis@baron:~$

Thing things I need to do on a normal basis with screen is list the sessions, and attach an already attached session. The sdr alias can have a session appended to it, or run by itself if you only have one session.

# Screen Aliases
alias sls='screen -ls'
alias sdr='screen -d -r'

There are a few commands I just think are way too long, these make it a little faster to do things, the alias md5 will make it easier to move back and forth between OS X and Linux.

# Command Shortening Aliases
alias md5='md5sum'
alias sha='sha256sum'
alias p='/usr/bin/python2.5'

Simple ls aliases, should be pretty straight forward.

# ls Aliases
alias lsd='ls --group-directories-first'
alias lsl='ls -l'
alias lsh='ls -lh'
alias ls1='ls -1'

The first alias here, just mounts a given ISO ($1) at mount point ($2). The 2nd is a manual mount for my filer. I didn’t want it automounting since it would give someone access to pretty much everything I have. A quick line count alias, quickie to grep history, and an alias to give me the size of a folder only showing 1 level below. The last alias in this group creates a screen session with the name irssi and executes irssi in side of it, but it also detaches the session. This was created because a lot of times I wanted to start irssi in the background, but didn’t want to have to detach the screen session.

# Various
alias iso='sudo mount -o loop $1 $2'
alias mount.filer='sudo mount host:/dir /dir'
alias lc='wc -l'
alias gh='history | grep'
alias fs='du --max-depth=1 -h'
alias irc='screen -d -m -S irssi /usr/bin/irssi'

This is a short script, that could probably be made into a one line alias. It uses screen to connect to a USB serial adapter. By default it connects at 115200, but the speed can easily be changed… ’s 9600′

#!/bin/bash

if [ $# -ne 1 ]; then
  SPEED=115200
else
  SPEED=$1
fi

screen /dev/ttyUSB0 $SPEED

I installed Lucid Lynx, the upcoming LTS release of Ubuntu. It is currently in its alpha stage, and when I get my desktop set back up I will reinstall to Lucid Lynx. The performance was suffering greatly running in a VM on my laptop, I really want to see how it will perform with the SSD.

I am really unsure what I want to do with my cabinet. I certainly don’t want to sell it, but it is taking up significant space and I don’t have use for much of the equipment right now. If I end up not getting a roommate I can put it in the 2nd bedroom in a couple months, but for right now I have it sitting in the living room, and it is taking up more space than I’d like.

Well thats all the randomness I can go on about right now. I’m tired, and my back hurts and I haven’t been doing much outside of work.

Right now I am talking with some people about the very interesting MySQL bridge integrated in Cherokee. The bridge allows you to send commands in a language and have it returned in the same language. So you can use Ruby, Python, JSON or PHP to send your SQL command and you will get your results back in the same language. There is built in media streaming support, built in SSL/TLS, support for FastCGI, SCGI, uWSGI, and tons more stuff.

I encourage you to check it out. I will definitely be posting more about Cherokee in coming weeks when I test out the MySQL bridge and compare it to the performance with the MySQL module for Python.

If you aren’t able to get your GTK theme to work apply one of the other themes available, and then select use GTK theme.

Also if you want to enable Flash do the following

$ sudo updatedb
$ locate libflashplayer.so
$ mkdir /opt/google/chrome/plugins/
$ cp [insert libflashplayer.so location here] /opt/google/chrome/plugins/

Now change the shortcut for Chrome to

/opt/google/chrome/google-chrome --enable-plugins %U

Enjoy the speed and smoothness that is Chrome.

#/usr/bin/python2.6
#
# ziptest.py
import sys
print sys.argv

and for the sake of this example we will have another file with the header. The best thing to do would be to make a system that added this to the beginning of the file when building it. We will name this file zip_template.py

#/usr/bin/python2.6
#
# Copyright 2009, ME

So lets zip up the __main__.py file and then concatenate the two files together to create our archive. We also need to make it executable.

$ zip tmp_appname.zip __main__.py
$ cat zip_template.py tmp_appname.zip > appname.zip
$ rm tmp_appname.zip
$ chmod +x appname.zip
$ ./appname.zip
['./appname.zip']

There you have it. You can now bundle your Python code in a zip file and run it just like you would a Java jar. It also doesn’t have to end with .zip you can name it .par or no extension at all if you like.

I would like to see support for encrypted zip files so that you can encrypt this archive and Python will prompt for the password.

/var/efw/main/settings
     HOSTNAME=$hostname
/var/efw/main/hostname.conf
     ServerName $hostname

To start this off you need to install Mercurial

sudo [yum or apt-get] install mercurial

The next step is initializing the repository in your home directory and protect others from being able to read files.

$ cd ~
$ hg init
$ chmod 700 .hg/

In my previous post a commenter pointed out something I was not aware of. When using git if you were to run ‘git clean’ all files not under version control would get deleted. You should be doing regular backups anyway, but that is certainly something we do not want to be able to do on accident. The hg equivalent is ‘hg purge’, but purge is a bundled extension that must be enabled, and because it might be enabled we want to explicitly disable that plugin from being able to work in our repository. To do so you put the following line in ~/.hg/hgrc, because that file will take precedence over conf files in etc and your ~/.hgrc file.

[extensions]
hgext.purge = !

You can store anything you would like to in this repository, but there is most likely going to be some files, and very large files at that, that you do not want to store. To fix that we are going to start off by ignoring everything in your home directory and selectively removing files from the list that we want to store. The following commands are going to list all non-hidden files, but listing directories first, the second command lists everything except for ‘.’ and ‘..’ directory references and greps for all hidden files and lists them directories first. One thing to note is that the –group-directories-first option is not available on CentOS and the only distro I can confirm it exists in is Ubuntu.

$ ls -1 --group-directories-first > .hgignore
$ ls -1 --group-directories-first -A | grep '^\.' >> .hgignore
$ cat .hgignore
Applications
bin
Desktop
...
.cache
.checkbox
.compiz
...
.bash_aliases
.bash_history
.bash_logout
...
.xsession-errors

Go through the list and either comment out (prepend with #) or remove from .hgignore any file/directory names that you DO want to store in version control, any file listed in .hgignore will be ignored by mercurial, unless you ‘hg add’ the file or directory.

If you want to see what files will be picked up by an ‘hg add’ you can run ‘hg status’

$ hg status
? .bash_history
? .bash_logout
? .bash_profile
? .bashrc
? .hgignore
? .hgrc
? .mysql_history
? .screenrc
? bin/mysqltuner.pl

If that is satisfactory you can now run ‘hg add’ to add the files listed here.

$ hg add
adding .bash_history
adding .bash_logout
adding .bash_profile
adding .bashrc
adding .hgignore
adding .hgrc
adding .mysql_history
adding .screenrc
adding bin/mysqltuner.pl

And you can verify it by again running ‘hg status’

$ hg status
A .bash_history
A .bash_logout
A .bash_profile
A .bashrc
A .hgignore
A .hgrc
A .mysql_history
A .screenrc
A bin/mysqltuner.pl

So go ahead now and run ‘hg commit’ and we can deal with individual files under ignored directories afterwards. Running ‘hg commit’ should be default use vi as your editor so after writing your description his Esc, then type :wq and it will commit.

Initial commit of home directory files.

Contains mostly bash dot files, but also a script in my bin directory

HG: Enter commit message.  Lines beginning with 'HG:' are removed.
HG: Leave message empty to abort commit.
HG: --
HG: user: Peter Manis <manis@pyverted.com>
HG: branch 'default'
HG: added .bash_history
HG: added .bash_logout
HG: added .bash_profile
HG: added .bashrc
HG: added .hgignore
HG: added .hgrc
HG: added .mysql_history
HG: added .screenrc
HG: added bin/mysqltuner.pl

So there were a couple directories I had in my .hgignore file that I would like to store certain files in version control. The first is .ssh and the second is .irssi. So to do this we run ‘hg add’ and then ‘hg commit’

$ hg add .ssh/config
$ hg add .irssi/config
$ hg status
A .irssi/config
A .ssh/config
$ hg commit
Adding files that are under ignored directories

HG: Enter commit message.  Lines beginning with 'HG:' are removed.
HG: Leave message empty to abort commit.
HG: --
HG: user: Peter Manis <manis@pyverted.com>
HG: branch 'default'
HG: added .irssi/config
HG: added .ssh/config

Let us now take a look at the local commits that we have.

$ hg log
changeset:   1:5ca5d6d283fe
tag:         tip
user:        Peter Manis <manis@pyverted.com>
date:        Thu Aug 13 19:48:16 2009 -0400
summary:     Adding files that are under ignored directories

changeset:   0:d0e3d9042208
user:        Peter Manis <manis@pyverted.com>
date:        Thu Aug 13 19:43:06 2009 -0400
summary:     Initial commit of home directory files.

We now need to prepare to push these local commits to our bitbucket private repository. To do this we need to setup ssh keys

$ ssh-keygen -t rsa -b 2048
Generating public/private rsa key pair.
Enter file in which to save the key (/home/mercurialguide/.ssh/id_rsa):
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in /home/mercurialguide/.ssh/id_rsa.
Your public key has been saved in /home/mercurialguide/.ssh/id_rsa.pub.
The key fingerprint is:
c5:fc:5b:3e:06:2c:3f:f9:17:51:bf:78:f8:60:ac:cb mercurialguide@hostname

Now sign up for a bitbucket account, create your first private repository, I called mine homedir. After you do that you need to go into your “Account” page and add your ssh public key to the list of ssh keys.

$ cat .ssh/id_rsa.pub
ssh-rsa AAAAB3NzaC1yc2EAAAABIwAAAQEAwRewbcXoot9nUUZzonryDYKBhxapI69JRW5TNsxfJQEAw4l7VoA681sgHVA2B8T876Tn9uZrzMBgcEz4GMGVsrU31wVNa9p/HtBJCyp1zWKoitoR1wu2FdNRSgsjFOdlMJ6BIxchmG58/hwA88FZXdYgcKMe2WWQP7pDInhHIJhLKPoctXURr6kSM7TWLh4eO81amSE2GB77mCRIoqxI6Y0uQGqO6JDhFUQAPuErCJcfXSkO+Lv9XIyCwhclki2oZUMwvDyYYrHVHWCNZ/azY1C4Ea722CFSWQjAUI9ljA8yaYmLaI4tbgWu9bNQdNy7v9x9EMtq8Q828BF9LGb+tw== mercurialguide@hostname

You will also need to edit your .ssh/config file for bitbucket.

Host bitbucket.org
  User hg
  Compression yes

Now we can push changes to bitbucket

$ hg push ssh://bitbucket.org/manis/homedir/
pushing to ssh://bitbucket.org/manis/homedir/
searching for changes
remote: adding changesets
remote: adding manifests
remote: adding file changes
remote: added 2 changesets with 12 changes to 12 files
remote: bb/acl: manis is allowed. accepted payload.
remote: quota: 103.6 MB in use, 500.0 MB available (20.72% used)

And you’re done! You just setup a remote repository with your home directory files. Now that you have that setup remember that until you ‘hg push’ your changes they are only local.

I never liked the status output of Git, the Mercurial output was much closer to Subversion, which is what I was used to. A quick side note, I have read that most feel Mercurial is an easier move for Subversion users. With my first real Mercurial involvement needing a lot of adds and removes it was nice to have an ‘addremove’ command that quickly took care of this for me. With Git you had to run add on the files, which was not fun if you added a large number of new files. Before anything is said about adding files I will say that yes, if you are adding a lot of new files it is probably from adding a directory, which is more easily added, but I found a number of instances where I had to add a lot of files where it wasn’t that easy and writing out a one liner to do it just isn’t enjoyable.

The ability to serve a web interface straight from the command line was a feature I found very interesting, again being able to setup a complete environment it wasn’t something I really needed, but it was certainly a nice feature to have. Setting up a Mercurial/Apache environment is also much easier than doing it with Git. I love Trac, I use it for everything I can, but it was very difficult to use with Git for a couple reasons. The first was that the versions of software needed for the Trac plugin didn’t mesh well with the CentOS 5 environment it would be hosted on. The 2nd, which is one of my biggest gripes about Git is the revision id Git uses. Git uses full hashes like “b3ef65139dea83be5965a972159aa628847b763c” while Mercurial will use a number and a short hash like “0:3f7766464126″ and revisions can be referenced by either. Here is a visual comparison of the two.

• Git: OhLoh Labs
• Mercurial: Pylons

I’m sure you can see what a difference that makes, the Mercurial revision id is 1/3 the length of the Git.

Mercurial itself is written in Python, and it is pointed out in some of the pages I link to later that this allows the developers to concentrate on adding features and paying more attention to creating the best version control system instead of having to deal with all the issues that can be involved in maintaining more low level code like C/C++. When you don’t have to spend time on garbage collection and finding memory leaks you have more time to add in features like Mercurial’s archiving option. I can simple link to http://webaddress.com/repository/archive/tip.{zip,tar.gz,tar.bz2} and it will create an archive version of the tip, or what is also known as the last revision, but you can also link to tags and create archives based on that. It also allows me to very easily add autogenerated links to my Trac project index as well, seen below.

I think that Mercurial being written in Python influences my decision more than I may realize. I like to have the power to add and change things and considering that I write Python more than I do anything else these days that fits in very nicely. It means that if I want a feature I can write it, I don’t need to know C or C++ and with the design of Python the features can be more easily added and shared with others. An example of a quick and easy extension is the InfoExtension, which if you are used to Subversion will look very much like ’svn info’.

Back in April, Google added support for Mercurial to their project hosting service, which you can see even has integrated branch graphing. More recently Python creator Guido van Rossum announced they will be moving from Subversion to Mercurial along with a followup from Brett Cannon about the decision. There is also a detailed PEP about the selection of a distributed VCS.

These are just some of the things that I really liked about Mercurial, you can read a little more on the following pages:

• Five Features from Mercurial That Would Make Git Suck Less
• Why Mercurial > Git, or How I Learned To Stop Censoring Myself and Participate in Flamewars.

chkconfig NetworkManager off
chkconfig --levels 2345 network on
/etc/init.d/network restart

The file gets placed in ~/.gnome2/nautilus-scripts/ and will take a restart of X.

#!/bin/bash

FILENAME=`gdialog --title "MD5 File" --inputbox "Enter the name of the MD5 file (without extension)" 100 200 2>&1`
if [ ${#FILENAME} -lt 1 ]; then
  FILENAME=temp_name.md5
else
  FILENAME=$FILENAME.md5
fi

echo "#!/usr/bin/md5sum -c" > $FILENAME
/usr/bin/md5sum $* >> $FILENAME
chmod +x $FILENAME

An example, the following will let you run ./filename.md5 and have it return the results of the md5 check.

#!/usr/bin/md5sum -c

bf185a69398a7fa91b6006aae61f8be1  TracMercurial-0.11.0.7-py2.4.egg

$ chmod +x mercurial_plugin.md5
$ ./mercurial_plugin.md5
TracMercurial-0.11.0.7-py2.4.egg: OK

This file defines the locations for Desktop, Music, Templates, etc so I went ahead and moved those files to Dropbox so I can maintain the files across multiple machines.

While I’m on the topic of these directories, I want to mention the awesomeness that is the Templates directory. If you add the file “Python Script.py” to that directory and put in the following text:

#!/usr/bin/python2.5
#
# Copyright 2009

import sys

# Enter text here

You can then right click in a directory, go to “Create Document” you will see “Python Script” listed and if you select it a .py file will be created with the previous text in it. This directory lets you create templates for anything you want and easily use it to create documents.

In Ubuntu 9.04 a new application was introduced called etckeeper. This application uses various version control systems to store versions of files within etc. Some machines that I work on I keep my home directory very clean, and I go out of my way to keep things organized and stored in version control. I have dropped the ball on being so organized when it comes to my home desktop, but tonight, that changed. This is how to use version control with your home directory. I am not going to cover indepth topics about using Git or any other version control, this guide simply explains how to maintain a local repository.

The first step is to install your preferred version control system. In this case I am going to use git, since a lot of people are familiar with it.

sudo apt-get install git

Now we need to initialize our repository and prevent other users from having access.

$ cd ~
$ git init
Initialized empty Git repository in /home/user/.git/
$ chmod 700 .git

We don’t need to put every file under version control so we need to create a list of everything in our home directory and then remove what we don’t want. To do this we are first going to list all non-hidden files directories first, and then list all hidden files directories first followed by leaving out the current and parent directories. This list gets put in a file called .gitignore, a file that git reads to determine what files it should ignore.

$ ls -1 --group-directories-first > .gitignore
$ ls -1 --group-directories-first -A | grep '^\.' >> .gitignore
$ cat .gitignore
Applications
bin
Desktop
...
.cache
.checkbox
.compiz
...
.bash_aliases
.bash_history
.bash_logout
...
.xsession-errors

Now you should go through and remove files and directories you would like to have maintained in version control. You can also temporarily comment out a file with a # so that it will get added and then uncomment the file so that in the future changes will be ignored.

After editing .gitignore you can run ‘git status’ to verify the files that are not ignored.

$ git status
# On branch master
#
# Initial commit
#
# Untracked files:
#   (use "git add <file>..." to include in what will be committed)
#
#       .bash_aliases
#       .bash_history
#       .bash_logout
#       .bash_profile
#       .bashrc
#       .gitconfig
#       .gitignore
#       .hgrc
#       .nvidia-settings-rc
#       .profile
#       .screenrc
#       .ssh/
#       .subversion/
#       .vim/
#       .viminfo
#       .vimrc
nothing added to commit but untracked files present (use "git add" to track)

Some things you may want to leave out like in my case I don’t really want to have the auth information for subversion or ssh private keys stored in version control. For those specific things you can add lines like the following to your .gitignore file.

.ssh/id_*
.subversion/auth/

To test what files will be added and what will not be added you can do a dry run.

$ git add -n -A
add '.bash_aliases'
...
add '.screenrc'
add '.ssh/config'
add '.ssh/known_hosts'
add '.subversion/README.txt'
add '.subversion/config'
add '.subversion/servers'
add '.vim/colors/astronaut.vim'
...

Now we need to add the files to git and commit them.

$ git add -A
$ git commit -m "Initial commit of files in home directory"

Now if you make a change to .profile you can easily revert it

$ echo 'testing' >> .profile
$ git status
# On branch master
# Changed but not updated:
#   (use "git add <file>..." to update what will be committed)
#   (use "git checkout -- <file>..." to discard changes in working directory)
#
#       modified:   .profile
#
no changes added to commit (use "git add" and/or "git commit -a")
$ git checkout .profile
$ git status
# On branch master
nothing to commit (working directory clean)

And you’re done.

Mercurial

I have not decided which DVCS I will be using so I initialized a hg repository along side the git repository so that I can see the differences first hand. The mercurial command is ‘hg’ and the ignore file is .hgignore so this guide can be easily adapted to using mercurial. One nice benefit is that BitBucket’s free plan comes with a private repository so you can easily setup a remote repository to store it all.

#!/bin/bash

DISPLAY=:0.1
vlc -f $*

The other problem I ran into was that I would be presented with a page saying “Database Upgrade Required”, after upgrading it would bring me back to the same page. The problem ended up being the wp-content/object-cache.php file, moving that out fixed the problem. However because the page was still cached in memcache moving the file back raised the same issues. The faster fix is to restart memcache all together to clear the cache.

$ imap_count.py manis@digital39.com
Password for manis@digital39.com: *****
56578 messages in account manis@digital39.com

Expand the code below and copy it to a file on your system. It takes one argument, and that argument is a comma separated list of email addresses.

#!/usr/bin/python2.4
#
# Copyright (c) 2009, Peter Manis
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
#
# Redistributions of source code must retain the above copyright notice, this
# list of conditions and the following disclaimer.
#
# Redistributions in binary form must reproduce the above copyright notice, this
# list of conditions and the following disclaimer in the documentation and/or
# other materials provided with the distribution.
#
# Neither the name of the Peter Manis nor the names of its contributors may
# be used to endorse or promote products derived from this software without
# specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

import getpass
import imaplib
import sys

results = []

def RetrieveMsgCount(username, password):
  """Retrieves message count by accessing Gmail or Google Apps IMAP account.

  Args:
    username: str, Username of the account we are accessing.
    password: str, Password of the account we are accessing.

  Returns:
    count: str, Number of messages in IMAP account

  Raises:
    imaplib.IMAP4.error: Failed to login to the IMAP account.
  """
  try:
    imap = imaplib.IMAP4_SSL('imap.gmail.com', 993)
    imap.login(username, password)
    status, [count] = imap.select("[Gmail]/All Mail")
    imap.close()
    imap.logout()
  except imaplib.IMAP4.error:
    return 'Unable to check'
  else:
    return count

def main():
  if len(sys.argv) > 1:
    accounts = sys.argv[1]
    for account in accounts.split(','):
      password = getpass.getpass("Password for %s: " % account)
      results.append('%s messages in account %s' % (
          RetrieveMsgCount(account, password), account))
    for account in results:
      print account
  else:
    print "Please provide a comma separated list of accounts to check."

if __name__ == '__main__':
  main()

What sparked this post was that someone on a mailing list I belong to asked about installing KDE in Ubuntu so that he could switch back and forth between KDE and Gnome, an email sent on the 8th of May. A few of us gave him commands he could run, and links to topics related to this, each one being shot down for some reason or another. Eventually a couple people made comments about how maybe Linux wasn’t for him, and so on, and he started to get defensive, which he has the right to do, but he started explaining how he works with over 100 servers and has been using Linux for like 8 years. Someone called him out by saying that with that much experience he should have been able to install KDE, which is very true, there might have been a couple problems to fix, but finding what packages to install should have been quite simple. The user then came back with this email about how we must have unlimited time to learn all of this stuff, and how he doesn’t have the time to spend figuring something out that many people have figured out already and then ending the email with comments about how if the list becomes unhelpful he will unsubscribe.

A big mistake he made was sounding ungrateful for the help he did receive. He thanked a few of us as we replied, but they were “Thanks, but” replies, telling us what was wrong with our response. By giving the attitude that your time is more valuable than ours is not the greatest way to get help. If you really want to make it about the value of an hour unless you are a doctor or a lawyer we can most likely bill more per hour than you can. Acting like you are some big shot by listing off the stuff you do isn’t a great thing to do either, you don’t know the audience, when you have people with a lot of experience hearing you make comments about how awesome you are, and you can’t install KDE it really makes you look like an ass.

Before you send an email to a list or to a group you need to think about the time you are taking away from other people’s day. If 200 people read your email, and it takes them 2 minutes a piece, but the answer to your question shows up in the top 5 results in Google, you just wasted 400 minutes of people’s time for something you could have found in 5 seconds. In the case of this guy it took me longer to read his replies than it did to search for a quick howto or give him a command he could run to find out what to install.

I hope this helps some of you who have been annoyed at your friend or acquaintance because they came across as having an attitude or they got upset with you.