Jason Meridth :: Personal Blog

Readline Error With RVM and Rails 3 on Ubuntu

2010-11-25T00:00:00-08:00

Readline Error With RVM and Rails 3 on Ubuntu

25 November 2010 - San Antonio

So I'm using Rails 3 with RVM these days. The last few times I created a new slice or restaged a laptop/desktop with Ubuntu I always seem to have an issue when I try to run the Rails console:

my_app/(master)$ rails console
/home/jmeridth/.rvm/rubies/ruby-1.9.2-p0/lib/ruby/1.9.1/irb/completion.rb:9:in `require': no such file to load -- readline (LoadError)
  from /home/jmeridth/.rvm/rubies/ruby-1.9.2-p0/lib/ruby/1.9.1/irb/completion.rb:9:in `<top (required)>'
  from /code/my_app/shared/bundle/ruby/1.9.1/gems/railties-3.0.1/lib/rails/commands/console.rb:3:in `require'
  from /code/my_app/shared/bundle/ruby/1.9.1/gems/railties-3.0.1/lib/rails/commands/console.rb:3:in `<top (required)>'
  from /code/my_app/shared/bundle/ruby/1.9.1/gems/railties-3.0.1/lib/rails/commands.rb:20:in `require'
  from /code/my_app/shared/bundle/ruby/1.9.1/gems/railties-3.0.1/lib/rails/commands.rb:20:in `<top (required)>'
  from script/rails:6:in `require'
  from script/rails:6:in `<main>'

I looked at the RVM site and saw how to install the readline package:

$ rvm package install readline
$ rvm remove 1.9.2
$ rvm install 1.9.2 --with-readline-dir=$rvm_path/usr

I did this and it still didn't work. The advice I received from googling was to compile the readline extension by hand and see if any dependencies were missing:

$ sudo apt-get install libncurses5-dev libreadline5-dev
$ ruby ~/.rvm/src/ruby-1.9.2-p0/readline/ext/extconf.rb
checking for tgetnum() in -lncurses... no
checking for readline/readline.h... no
checking for readline/history.h... no
checking for readline() in -lreadline... no
...

This meant that I was missing the lncurses and libreadline libraries from apt-get.

$ sudo apt-get install libncurses5-dev libreadline5-dev
...they install...

Now when I run extconf.rb, everything is there:

$ ruby ~/.rvm/src/ruby-1.9.2-p0/readline/ext/extconf.rb
checking for tgetnum() in -lncurses... yes
checking for readline/readline.h.... yes
checking for readline/history.h... yes
checking for readline() in -lreadline... yes
...

A make file was generated, I run it, and then install:

$ cd ~/.rvm/src/ruby-1.9.2-p0/readline/ext/
$ make
...
$ sudo make install
...

Now the rails console works:

my_app$ rails console
Loading development environment (Rails 3.0.3)
ruby-1.9.2-p0 >

Gotcha with Gitosis and python-setuptools

2010-05-26T00:00:00-07:00

Gotcha with Gitosis and python-setuptools

26 May 2010 – San Antonio

Today I decided to upgrade my slicehost slice from Intrepid Ibex to Lucid Lynx (Intrepid → Jaunty → Karmic → Lucid). Yeah, yeah, I’m a little behind. Anyways, It upgraded just fine. However when I was trying to push code to my gitosis instance (which I installed over a year ago), I got the following stack trace:

~/code/gitosis-admin(master) > git pull origin master
/usr/bin/gitosis-serve:5: UserWarning: Unbuilt egg for setuptools [unknown version] (/usr/lib/python2.6/dist-packages)
  from pkg_resources import load_entry_point
Traceback (most recent call last):
  File "/usr/bin/gitosis-serve", line 5, in <module>
    from pkg_resources import load_entry_point
  File "/usr/lib/python2.6/dist-packages/pkg_resources.py", line 2655, in <module>
    working_set.require(__requires__)
  File "/usr/lib/python2.6/dist-packages/pkg_resources.py", line 648, in require
    needed = self.resolve(parse_requirements(requirements))
  File "/usr/lib/python2.6/dist-packages/pkg_resources.py", line 546, in resolve
    raise DistributionNotFound(req)
pkg_resources.DistributionNotFound: gitosis==0.2
fatal: The remote end hung up unexpectedly

This told me that I had been using python-setuptools for python 2.5. A little googling and praying that I wouldn’t have to roll back to the snapshot I took before I started the upgrade (Thank God!), I found the solution. I went onto the gitosis slice, cloned the gitosis repository:

git clone git://eagain.net/gitosis

and then ran the setup again:

~ > cd gitosis
~ gitosis/ > sudo python setup.py install

and it fixed the issue. Did I mention how much I love google. Hope this helps someone else.

Gitosis and Gitweb Part 3

2010-05-26T00:00:00-07:00

Gitosis and Gitweb Part 3

26 May 2010 – San Antonio

Gitosis and Gitweb – Part 1
Gitosis and Gitweb – Part 2
Gitosis and Gitweb – Part 3

So we are setup, have a project, and have contributors via the first 2 parts.

I know that we are all enamored by the UI of GitHub.com. I am. Unfortunately you can’t get private repositories for free (In all fairness it’s only $7/mo. – a very wise investment). I am aware of Gitorious like I mentioned in the first part, but I have no experience with that. I will after this series and update this series if I find it better. Again, I like to use the simplest thing that works. (Of course, “simplest” is in the eye of the beholder)

In this section I’m going to show you how to install Gitweb, a UI tool that let’s you view your repositories. I’m also going to mention how to get it to auto-detect any new repositories and ensure they show up on the web UI. I learned how to do most of this from my co-worker Antony Messerli. He is a true Linux and problem-solving Jedi.

Install Apache

First, you need to ensure apache2 is installed. Check to see if you have an /etc/apache2 folder. If you do, you should be okay. If you don’t, you need to install it.

sudo apt-get install apache2

For more in-depth advice, I always reference the Slicehost Articles

Once you have that installed the daemon restarted, go to your slices ip address in the browser of your choice (i.e,. http://123.123.123.123) and you should something like “It Works”

Voila! You have apache running.

Install the Package

sudo apt-get install gitweb

This will install gitweb into /usr/share/gitweb, create a conf file at /etc/gitweb.conf, and add four files to /usr/share/gitweb/static (git-favicon.png, git-logo.png, gitweb.css, gitweb.js).

You only need to edit the $projectroot variable in the /etc/gitweb.conf to point to your gitosis repositories folder:

# path to git projects (<project>.git)
$projectroot = "/home/git/repositories";
...

Since this isn’t a post about Apache, I just add the gitweb directory setup to the base Apache config. Since Ubuntu includes the entire /etc/apache2/conf.d directory, I just added the following information into /etc/apach2/conf.d/gitweb:

RewriteEngine on
RewriteRule ^/gitweb/([a-zA-Z0-9_\-]+\.git)/?(\?.*)?$ /cgi-bin/gitweb.cgi/$1 [L,PT]

Alias /gitweb /home/git/repositories
<Directory /home/git/repositories>
Options Indexes FollowSymlinks ExecCGI
DirectoryIndex /cgi-bin/gitweb.cgi
AllowOverride None
</Directory>

Restart Apache to make sure everything works

sudo /etc/init.d/apache2 restart

The first time you go to your website again, you’ll see Gitweb, but it’ll say no projects are available. Fix mentioned below.

Permission Hack (open to suggestions)

1. I had to make the repositories that I wanted visible in gitweb have permissions of 755 (aka owner has read, write, execute. group and others have read, execute.)

sudo chmod -R 755 /git/repositories/lostechies.git

Once that was done I can see the repository and it’s information on Gitweb.

If you want to edit the project description from “Unnamed repository; edit this file ‘description’ to name the repository.” go to the repositories description file (/home/git/repositories/lostechies.git/description for this repo) and edit the file and save.

Cron job

I, again with the leadership of Ant, utilized a cron job he wrote to automatically make the repositories have permissions of 755. I do have some repositories, like gitosis-admin, that I do not ever want visible on Gitweb. The cron job excludes them. Here is the cron job code, showing that I don’t want to show my personal.git and gitosis-admin.git repositories. This could be easily written in Ruby or any other “scripting language” of your choice:

#!/bin/sh

GITOSIS_REPO_PATH="/home/git/repositories"
GITOSIS_ADMIN_PATH="$GITOSIS_REPO_PATH/gitosis-admin.git"
PERSONAL_REPO_PATH="$GITOSIS_REPO_PATH/personal.git"

debug ()
{
    echo "[D]: $1" > /dev/null
}

for dir in `find $GITOSIS_REPO_PATH -maxdepth 1 -mindepth 1 -type d`; do
    if [ "$dir" != "$GITOSIS_ADMIN_PATH" ]; then
        if [ "$dir" != "$PERSONAL_REPO_PATH" ]; then
                `chmod -R 0755 $dir`
        fi
    fi
    debug "All repositories have permissions set to 0755"
done

I chose bash, so that I could take that time to learn it.
Translation: Find all the directories in my gitosis repository path (/home/git/repositories) and if they are not gitosis-admin or personal, change their permissions, recursively, to 0755.

I put this in a file called set_gitosis_permissions_to_view_on_gitweb.sh and put it in root’s home folder, /root. I then called the file from root’s crontab:

~ /> sudo su -
# /root > crontab -e
# m h  dom mon dow   command
*/5 * * * * /root/set_gitosis_permissions_to_view_on_gitweb.sh

This means that every 5 minutes, my bash file will set any new repositories to 0755. This is how to get Gitweb stood up. The next post will show how to hide it behind HTTP basic auth and a self-signed certificate.

Next Part: Hiding the Gitweb site

Gitosis and Gitweb Part 2

2010-05-22T00:00:00-07:00

Gitosis and Gitweb Part 2

22 May 2010 – San Antonio

Gitosis and Gitweb – Part 1
Gitosis and Gitweb – Part 2

So we are setup now thanks to Part 1.

Gitosis repository contents

If we issue the “find .” command locally inside the gitosis-admin directory we will see the following:

~/gitosis-admin(master) > find .
<a bunch of files from the .git folder>....
./gitosis.conf
./keydir
./keydir/user@local.pub

We have the .git folder, a gitosis.conf file, and a keydir with a pub key file.

Add our first project

Our project name for this example is lostechies. If you view the gitosis-admin.conf file you will see the initial content like so:

~/gitosis-admin(master) > cat gitosis.conf 
[gitosis]

[group gitosis-admin]
writable = gitosis-admin
members = user@local

This is the result of the following command from the last part:

sudo -H -u git gitosis-init < /tmp/id_rsa.pub

That command puts the public ssh key into the keydirs directory and adds the associated username from the file to be the first member of the gisotis-admin project. Hence seeing user@local as the member. It matches the filename of the pub file in the keydir directory (user@local.pub). That’s how gitosis relates members listed in the conf file to the keys in the keydir directory, filename minus the pub extension.

Let’s edit this conf file to include our lostechies project:

~/gitosis-admin(master) > cat gitosis.conf 
[gitosis]

[group gitosis-admin]
writable = gitosis-admin
members = user@local

[group lostechies]
writable = lostechies
members = user@local

It looks exactly like the gitosis-admin one. Now we commit it just like we would normally when using Git. We can add, then commit or commit with the -am argument. This is possible since the gitosis-admin.conf file is already tracked by the repository.

~/gitosis-admin(master) > git commit -am "add lostechies project"
[master 6b7a5da] add lostechies project
 1 files changed, 3 insertions(+), 0 deletions(-)

and push it to the remote gitosis-admin repository:

~/gitosis-admin(master) > git push
Counting objects: 5, done.
Delta compression using up to 2 threads.
Compressing objects: 100% (3/3), done.
Writing objects: 100% (3/3), 385 bytes, done.
Total 3 (delta 0), reused 0 (delta 0)
To git@YOUR_SERVER_HOSTNAME:gitosis-admin.git
   23842e9..6b7a5da  master -> master

We need to create the lostechies repository locally, add an initial item (README in this case), and push it remotely. Gitosis won’t create the repository until something it pushed to it.

~ > mkdir lostechies
~ > cd lostechies
~/lostechies > git init
~/lostechies(master) > touch README
~/lostechies(master) > git add README && git commit -m "initial commit"
~/lostechies(master) > git push origin master
Initialized empty Git repository in /home/git/repositories/lostechies.git/
Counting objects: 3, done.
Writing objects: 100% (3/3), 205 bytes, done.
Total 3 (delta 0), reused 0 (delta 0)
To git@YOUR_SERVER_HOSTNAME:lostechies.git
 * [new branch]      master -> master

The lostechies repository now exists remotely. Currently my account is the only that has access. Let’s add another contributor.

Add our first contributors

Say I want to allow my friend Joe to have commit (writable) access to my lostechies repository and I want my friend Ryan to only have readonly access. I tell them to send me their public ssh keys. I make sure the files are named joe.pub and ryan.pub. I then put them into my local gitosis-admin repository’s keydir directory and then I edit the gitosis.conf file to be:

~/gitosis-admin(master) > cp ~/joe.pub keydir/ && cp ~/ryan.pub keydir/
~/gitosis-admin(master) > vim gitosis.conf 
[gitosis]

[group gitosis-admin]
writable = gitosis-admin
members = user@local

[group lostechies]
writable = lostechies
members = user@local joe

[group lostechies_ro]
readonly = lostechies
members = ryan

Notice that I had to create a whole new group (lostechies_ro) to setup Ryan’s readonly access. You can’t combine readonly and writable permissions in gitosis (wish we could – open source contribution there?).

Now I need to “git add” the new keys, and commit the changes to the conf file. Finally I push the changes.

~/gitosis-admin(master) > git add keydir/joe.pub keydir/ryan.pub
~/gitosis-admin(master) > git commit -am "add joe and ryan and give them access to lostechies repository"
[master efb193c] add joe and ryan and give them access to lostechies repository
 3 files changed, 6 insertions(+), 1 deletions(-)
 create mode 100644 keydir/joe.pub
 create mode 100644 keydir/ryan.pub
~/gitosis-admin(master) > git push
Counting objects: 7, done.
Delta compression using up to 2 threads.
Compressing objects: 100% (4/4), done.
Writing objects: 100% (4/4), 470 bytes, done.
Total 4 (delta 1), reused 0 (delta 0)
To git@YOUR_SERVER_HOSTNAME:gitosis-admin.git
   20148cf..efb193c  master -> master

Now Joe or Ryan can clone this repository:

git clone git@YOUR_SERVER_HOSTNAME:lostechies.git

NOTE: Again, if they receive the following error:

~ > git clone git@YOUR_SERVER_HOSTNAME:gitosis-admin.git
Initialized empty Git repository in /Users/user/gitosis-admin/.git/
ssh: connect to host YOUR_SERVER_HOSTNAME port 22: Connection refused
fatal: The remote end hung up unexpectedly

The solution, involving the .ssh/config file is in the first post in this series.

That is how you create a repository and add users.

DEBUG

If you are unable to connect you have the option of editing the gitosis.conf file with more message verbosity by adding “loglevel=DEBUG” at the top of the conf file:

~/gitosis-admin(master) > vim gitosis.conf 
[gitosis]
loglevel=DEBUG
...

This will give you more information on the ouput when trying to push to the remote repository.

Can’t push changes

As Scott Chacon states in his gitosis section of Pro Git:

“If you’ve lost push access by pushing a messed-up configuration, you can manually fix the file on the server under /home/git/.gitosis.conf — the file from which Gitosis reads its info. A push to the project takes the gitosis.conf file you just pushed up and sticks it there. If you edit that file manually, it remains like that until the next successful push to the gitosis-admin project.”

The .gitosis.conf file in the git user’s home directory is a symlink to the actual conf file in the gitosis-admin repository:

lrwxrwxrwx 1 git  git    53 May 22 20:32 .gitosis.conf -> /home/git/repositories/gitosis-admin.git/gitosis.conf

Next Part: Gitweb

Gitosis and Gitweb Part 1

2010-05-22T00:00:00-07:00

Gitosis and Gitweb Part 1

22 May 2010 – San Antonio

Gitosis and Gitweb – Part 1
Gitosis and Gitweb – Part 2

I’ve had a number of people ask me where they should host their Git repositories. Of course, my default question back is, “Can the code be public or does it need to be private?”. Usually they say, “public”. Therefore, my repsonse is Github.com. If they say, “private” I still say Github. If they don’t ‘trust’ Github, which they should – click the link, then my response is Gitosis and Gitweb. This is by no means the only solution. I’m aware of other ones like Gitorious. I’ve never used Gitorious.

Back to Gitosis. My personal Gitosis server is a slice at Slicehost.com. You can use an Ubuntu server at home as long as you have remote access. I’ve personally only used Gitosis with an Ubuntu slice, so I don’t know if there are any quirks with other Linux distributions. After setting up a slice (after following the instructions here and here) I am ready to go.

Notice: This post is a combination of scie.nti.st’s gitosis post and Scott Chacon’s Pro Git gitosis section. They are my de facto references. Maybe my own will be now. :)

“Enough talk. Let’s fight” ~Po, Kung Fu Panda

Intall Git

After logging into your box, let’s install Git (if not already installed):

$ sudo apt-get install git-core
...
After this operation, 16.3MB of additional disk space will be used.
Do you want to continue [Y/n]?

Press enter or type ‘Y’ and press enter and git will be installed. Type the following to confirm:

~ > git --version

and you’ll see something like:

~ > git --version
git version 1.6.3.3

Intall python-setuptools

Also install the python-setuptools because we’ll need them (gitosis is written in python):

$ apt-get install python-setuptools
...
After this operation, 1126kB of additional disk space will be used.
Do you want to continue [Y/n]?

Press enter or type ‘Y’ and press enter and python-setuptools will be installed.

Download Gitosis

We need to clone the gitosis source locally to install it:

$ mkdir src && cd src
~/src $ git clone git://eagain.net/gitosis.git
Initialized empty Git repository in /root/src/gitosis/.git/
remote: Counting objects: 614, done.
remote: Compressing objects: 100% (183/183), done.
remote: Total 614 (delta 434), reused 594 (delta 422)
Receiving objects: 100% (614/614), 93.82 KiB, done.
Resolving deltas: 100% (434/434), done.

Install Gitosis

Now let’s install it:

~/src $ cd gitostis
~/src/gitostis $ python setup.py install
"result":http://gist.github.com/352769

Gitosis is now installed. Next steps are to create git user and handle a file permission on a git hook.

Create Git User

sudo adduser \
    --system \
    --shell /bin/bash \
    --gecos 'git version control' \
    --group \
    --disabled-password \
    --home /home/git \
    git

You’ll see something like the following if it is successful

Adding system user `git' (UID 103) ...
Adding new group `git' (GID 105) ...
Adding new user `git' (UID 103) with group `git' ...
Creating home directory `/home/git' ...

Use local, public ssh key

You need to initially use your public ssh key (id_rsa.pub). If you have one, it will be at $HOME/.ssh/id_rsa.pub and if you have never generated one, you can do so by running the following command (accept the default location and you don’t need to enter a passphrase when prompted):

ssh-keygen -t rsa

Now you need to upload it to the server/slice. I usually use the scp (secure copy command):

scp $HOME/.ssh/id_rsa.pub user@123.123.123.123:/tmp/

This will upload the local id_rsa.pub file to the /tmp/ folder on the server. Why there? So that the git user can use it. How is that possible? The folder has permissions of 777 (drwxrwxrwt) meaning everyone has read and write access to it.

Sidenote: SSH Port

If you have your sshd daemon running on a different port other than 22 (which is the default, but I highly suggest changing), then you need to use scp like this:

scp -P 12345 $HOME/.ssh/id_rsa.pub user@123.123.123.123:/tmp/

I believe the “-P” option must be capitalized.

Initialize gitosis-admin repository

On the server, issue the following command to set your public ssh key as the first authorized key of a new gitosis-admin repository:

sudo -H -u git gitosis-init < /tmp/id_rsa.pub

You will see something like the following:

~$ sudo -H -u git gitosis-init < /tmp/id_rsa.pub
Initialized empty Git repository in /home/git/repositories/gitosis-admin.git/
Reinitialized existing Git repository in /home/git/repositories/gitosis-admin.git/

This means it was successful.

Take note: If you put your id_rsa.pub file in a different location you need to use that instead of /tmp/id_rsa.pub

Change Permissions on post-update hook

You have to set the permissions on the post-update git hook of the gitosis-admin repository so that gitosis-admin can add new repository structures when they are added/removed to/from the gitosis.conf file.

sudo chmod 755 /home/git/repositories/gitosis-admin.git/hooks/post-update

Note: First round of this post, I didn’t make this change. When I added a new project, it failed because this hook didn’t have the right permissions.

Clone gitosis-admin repository

Now we’re going to use Git to administrate this gitosis instance. I think that is pretty ingenius. Let’s clone the gitosis-admin repository locally:

~ > git clone git@YOUR_SERVER_HOSTNAME:gitosis-admin.git
Initialized empty Git repository in /Users/user/gitosis-admin/.git/
remote: Counting objects: 5, done.
remote: Compressing objects: 100% (4/4), done.
Receiving objects: 100% (5/5), done.
Resolving deltas: 100% (1/1), done.
remote: Total 5 (delta 1), reused 5 (delta 1)
~ > cd gitosis-admin

We are now in the gitosis-admin repository folder locally

Two most common errors

FIRST ONE:

~ > git clone git@YOUR_SERVER_HOSTNAME:gitosis-admin.git
Initialized empty Git repository in /Users/user/gitosis-admin/.git/
ssh: connect to host YOUR_SERVER_HOSTNAME port 22: Connection refused
fatal: The remote end hung up unexpectedly

it is because you have used a port for SSH other than port 22 (the default). To fix this, you need to edit your .ssh/config file and add the following:

Host YOUR_SERVER_HOSTNAME
Port YOUR_PORT

Of course, you need to put in your server hostname and port number (i.e., mydomain.com and 12345)

SECOND ONE:

~ > git clone git@YOUR_SERVER_HOSTNAME:gitosis-admin.git
Initialized empty Git repository in /Users/user/gitosis-admin/.git/
Permission denied (publickey).
fatal: The remote end hung up unexpectedly

This has usually hit me because I locked down my /etc/ssh/sshd_config file to only allow in certain users or groups. I have to change the AllowUsers line in my file from:

AllowUsers jmeridth

AllowUsers jmeridth git

Once I restart the ssh daemon:

~ > sudo /etc/init.d/ssh restart

Now the git user has access to reach my server/slice via ssh.

The local gitosis-admin repository

You now have a local clone of the gitosis-admin repository. The contents are only a conf file and key directory:

~/gitosis-admin(master) > ls
total 8
-rw-r--r--  1 user  staff   114B May 22 21:31 gitosis.conf
drwxr-xr-x  3 user  staff   102B May 22 21:31 keydir

Note: before anyone asks, the (master) notation in my prompt is usage of the __git_ps1

Next Part: Add Projects and Contributors

git ps1

2010-05-22T00:00:00-07:00

git ps1

22 May 2010 – San Antonio

I like knowing which Git branch I’m currently in. I use the git-ps1 function feature that comes with git-core. If you clone or download the git source:

git://git.kernel.org/pub/scm/git/git.git

There is a file in the contrib/completion folder called git-completion.bash:

~/code/git/contrib/completion(master) > ls
total 96
-rwxr-xr-x  1 user  staff    44K Apr 14 15:26 git-completion.bash

I copy this file to my $HOME folder as .git-completion.bash and then reference it and the ps1 prompt feature in my .bashrc file

source ~/.git-completion.bash
export PS1='\w$(__git_ps1 "(%s)") > '

And now whenever I cd into a folder that is a Git repository I see something like the following prompt:

~/gitosis-admin(master) >

Notice the (master) notation. That is telling me I’m on the master branch. It’s just easier than issuing a “git branch” command everytime I want to know.

I know there are many other configurations out there, but I like to use the simplest thing that works.

OAuth

2010-04-02T00:00:00-07:00

OAuth

18 Jan 2010 – San Antonio

I have gotten tired of twitterfeed not handling our RSS feed and tweeting our new posts. So have the other LosTechies members. I decided to finally learn OAuth so that I can write a script/app to handle tweeting our new blog posts.

This is the way I learned so bare with me.

First things first, is you have to go to twitter and login to your account. Once done, register your OAuth application and click the Register a new application link. This will set you up with an OAuth consumer key and secret; which we need to obtain the OAuth request token/secret and our ultimate goal of an OAuth access token/secret.

Required fields that I had to fill out were:

Application Name
Descriptions
Application Website
Application Type (I chose Client)
Default Access Type (I chose Read & Write)
ReCaptcha at the bottom.

Once accepted you’ll be directed to a page displaying your consumer key and secret, like this:

I’ve looked at a few ways to do this and the easiest that I found was by using the twitter_oauth gem. Following the README for this gem I was able to get an access token/secret pretty easily.

I’m doing all of this through IRB because there is one part where you need to open a web page and allow your twitter client to post to Twitter.

~ > irb
irb(main):001:0> require 'rubygems'
=> true
irb(main):002:0> require 'twitter_oauth'
=> true
irb(main):003:0> client = TwitterOAuth::Client.new(
irb(main):004:1* :consumer_key => 'YOUR_APP_CONSUMER_KEY',
irb(main):005:1* :consumer_secret => 'YOURA_APP_CONSUMER_SECRET')
)
=> ...object output...
irb(main):005:0> request_token = client.request_token
=> ...object output...
irb(main):006:0> puts request_token.key, request_token.secret
=> [REQUEST_TOKEN]
=> [REQUEST_SECRET]

irb(main):007:0> request_token.authorize_url
=> http://twitter.com/oauth/authorize?oauth_token=TOKEN

Copy that url and put it into your browser of choice. When the “Deny” and “Allow” buttons become visible, click the “Allow” button. You will be presented with a numeric PIN. Copy that number into your clipboard because we’re going to use it on this final step to obtain the OAuth Access Token and Secret.

irb(main):007:0> access_token = client.authorize(
irb(main):008:1*   request_token.token,
irb(main):009:1*   request_token.secret,
irb(main):0010:1*  :oauth_verifier => 'THE_NUMERIC_PIN_YOU_GOT_FROM_TWITTER'
irb(main):0011:1* )
=> ...object output...
irb(main):0011:0> puts access_token.key, access_token.secret
=> [ACCESS_TOKEN]
=> [ACCESS_SECRET]
irb(main):0012:0> client.authorized?
=> true

You now have everything you need to use the TwitterOAuth gem without having to authenticate everytime.

irb(main):0013:0> client = TwitterOAuth::Client.new(
irb(main):0014:1*    :consumer_key => 'YOUR_CONSUMER_KEY',
irb(main):0015:1*    :consumer_secret => 'YOUR-CONSUMER-SECRET',
irb(main):0016:1*    :token => access_token.token, 
irb(main):0017:1*    :secret => access_token.secret
)
=> ...object output...
irb(main):0017:0> client.authorized?
=> true

That is how I figured out OAuth without a callback URL. Hacky, but it works.

Pro Git Cliff Notes

2010-03-30T00:00:00-07:00

Pro Git Cliff Notes

30 Mar 2010 – San Antonio

These are my notes from reading Scott Chacon’s Pro Git

I highly suggest buying this book if you are serious about using the Git version control tool.

pg 48

A branch in Git is simply a lightweight movable pointer

pg 50

a special pointer called HEAD…is a pointer to the local branch you’re currently on

pg 52

Creating a new branch is as quick and simple as writing 41 bytes to a file (40 characters and a newline).

pg 53

To create a branch and switch to it at the same time…git checkout command with the -b switch

pg 61

To see the last commit on each branch, you can run git branch -v

pg 69

git checkout -b [branch] [remotename]/[branch]

is the same as

git checkout --track [remotename]/[branch]

pg 81

Git protocol…listens on a dedicated port (9418)

pg 82

The Git protocol is the fastst transfer protocol available.

pg 111

The Git project provides a document that lays out a number of good tips for creating commits from which to submit patches—you can read it in the Git source code in the Documentation/SubmittingPatches file.

pg 116 *

git log --no-merges origin/master ^issue54

pg 121

Compare origin changes with local changes before merging:

git log origin/featureA ^feature

pg 126

git merge --no-commit --squash featureB

pg 130

git apply

It’s almost identical to running a patch -p1 command to apply the patch, although it’s more paranoid and accepts fewer fuzzy matches then patch.

pg 131

git apply --check

check to see if a patch applies cleanly before you try actually applying it

pg 134

git log contrib --not master

To find common ancestor of both branches

git merge-base contrib master

git diff [sha1 from previous command]

pg 135

git diff master...topic

shows you only the work your topic branch has introduced since its common ancestor with master.

pg 140

tagging releases with signed keys

pg 141

generating a build number with your tags

preparing a release as a tarball

pg 142

Show work by author since a specific time

git shortlog --no-merges master --not v1.0.1

pg 144

Git can figure out a short, unique abbreviation for your SHA-1 values

git log --abbrev-commit --pretty=oneline

wolves paragraph

pg 145

Find out the SHA1 of a branch

git rev-parse [branch]

pg 146

To see reflog information inline with your normal log information

git log -g master

Because reflog is a log, it will show you where the HEAD pointer was 2 months ago – if the repo is older than that

git show HEAD@{2.months.ago}

pg 147

^ is the first parent of the current commit
^2 is the second parent of the current commit (only works if the current commit is a merge commit, where first parent is the branch you on when you merged, second was the other)
~ is the first parent
~2 (or any number) is the grandparent(s) of the current commit only on the current branch or branch you were on when you merged

pg 148

Shows you any commits in your current branch that aren’t in the master branch on your origin remote

git log origin/master..HEAD

Git substitutes HEAD if one side is missing (git log origin/master..)

Just like above command and example shown on pg134

git log refB --not refA

pg 155

Tells the stash command to try to reapply the staged changes

git stash apply --index

pg 156

Create a branch from a stash, testchanges

git stash branch testchanges

pg 157

…don’t amend your last commit if you’ve already pushed it (git commit —amend command)

git rebase -i HEAD~3

Don’t include any commit you’ve already pushed to a central server—doing so will confuse other developers by providing an alternate version of the same change

pg 158

It’s important to note that these commits (interactive rebase) are listed in the opposite order (oldest first, newest last) than you normally see then using the log command (newest first).

pg 160

…make sure no commit shows up in that list (git log -4 —pretty=format:“%h %s”) that you’ve already pushed to a shared repository

pg 164

was wondering how to automate the good/bad declaration

pg 168

git submodule update
You have to do this every time you pull down a submodule change in the main projects. It’s strange, but it works.

pg 172

You want to pull the Rack project into your master project as a subdirectory

git read-tree --prefix=rack/ -u rack_branch

pg 175

global git config /etc/gitconfig
user global git config ~/.gitconfig
local repository git config .git/config

pg 182

git config --global core.autocrlf input

This setup should leave you with CRLF endings in Windows checkouts but LF endings on Mac and Linux systems and in the repository

pg 184

To tell Git to treat a specific file as binary data, add the following line to your .gitattributes file:
*.extension -crlf -diff

pg 185

…one of the most annoying problems known to humanity: version-controlling Word documents (LOL)

pg 192

post-receive hook…This scripts can’t stop the push process, but the client doesn’t disconnect until it has completed; so, be careful when you try to do anything that may take a long time

pg 194

Is practically the git log command…it prints out only the SHA-1 values and no other information

git rev-list [SHA-1]..[SHA-1]

Get the commit message from each of these commits to test

git cat-file commit [SHA-1]

Incantation:

git cat-file commit [SHA-1] | sed '1,/^$/d'

pg 196

See what files have been modified in a single commit

git log -1 --name-only --pretty=oneline:'' [SHA-1]

pg 198

anything your script prints to stdout will be transferred to the client

pg 200

Get your file listing from the staging area

git diff-index --cached --name-only HEAD

pg 224

Git is a content-addressable filesystem

hash-object (plumbing command)

pg 221

Pull the content back out of Git

git cat-file -p [SHA-1]

pg 226

Git will tell you what type of object it is [blob, tree, tag, commit]

git cat-file -t [SHA-1]

pg 231

Git compresses the new content with zlib

Git tracking branches

2010-03-23T00:00:00-07:00

Git tracking branches

23 Mar 2010 – San Antonio

I have encountered this message multiple times when dealing with Git:

~/code/blog/armmer.github.com(master) > git pull
You asked me to pull without telling me which branch you
want to merge with, and 'branch.master.merge' in
your configuration file does not tell me, either. Please
specify which branch you want to use on the command line and
try again (e.g. 'git pull <repository> <refspec>').
See git-pull(1) for details.

If you often merge with the same branch, you may want to
use something like the following in your configuration file:

    [branch "master"]
    remote = <nickname>
    merge = <remote-ref>

    [remote "<nickname>"]
    url = <url>
    fetch = <refspec>

See git-config(1) for details.

and I’ve been waiting for it again so that I can blog about it. What this means is that the local master branch of my github pages repository is not tracking a remote branch. The quickest way to get around this would be for me to explicitly state the remote name and branch:

~/code/blog/armmer.github.com(master) > git pull origin master

and it would pull successfully. Well, I don’t want to have to specify the remote and branch. The easiest way to do this is to edit the configuration file as suggested and add the following (at least in my case):

    [branch "master"]
    remote = origin
    merge = refs/heads/master

    [remote "origin"]
    url = git@github.com:armmer/armmer.github.com.git
    fetch = +refs/heads/*:refs/remotes/origin/*

The +refs/heads/:refs/remotes/origin/ notation is what I call the refspec format.

Now if I do a git pull I get:

~/code/blog/armmer.github.com(master) > git pull
Already up-to-date.

It worked. Now back to coding…

Git reset, checkout & "bare double dash", and revert

2010-03-22T00:00:00-07:00

Git reset, checkout & “bare double dash”, and revert

22 Mar 2010 – San Antonio

Some of the common questions I get are about how to reset or revert changes in Git. There are two typical scenarios you have to deal with. One is if you haven’t committed the code yet. The other is if you have committed the code.

Before you have committed the code

Well, if you want to unstage a file you simply do the following:

git reset

Say you staged a change (“git add”) and you realize you either don’t want the file tracked or the change staged. git reset is the command that will do this:

$ git reset HEAD <filename>

One of the suggestions I’ve read about and have given is to create an alias called unstage:

$ git config --global alias.unstage 'reset HEAD'

So now instead of:

$ git reset HEAD README

you can do:

$ git unstage README

I personally just stick to git reset HEAD filename. “Why?” you ask. It’s so that if I have to use git on another system that doesn’t have my aliases, I know the commands.

git checkout

Another common question is “How do I undo an unstaged/uncommitted change? I just want to roll my file back…”. git checkout — filename handles this:

$ git checkout -- README

This will roll the README file back to the last committed version in the working directory. Another question after I answer this is, “Why do you have to put the two dashes there?” The two dashes are canonically called the “bare double dashes”. The reason they are there is because it ensures that the checkout command know that we are trying to roll back a file and not change branches. Remember that the typical usage of the checkout command is to change branches. If you had a branch called README, this command:

$ git checkout README

would checkout the README branch and not rollback the current README file in the working directory.

After you have committed the code

If you committed code that you realized you shouldn’t have, you have two options:

git revert

git revert will create a new commit which undoes a specifc commit that you pass to it. The usual use is to undo the last commit:

$ git revert HEAD

If you need to undo a commit that happened before the last commit you can pass it a treeish argument or a specific SHA1 of the commit you want to undo:

Revert the next-to-last commit:

$ git revert HEAD^

Revert a specific commit by SHA:

$ git revert f8c7dd34

Just be aware that if you pass a reference to a commit other than the last one, if there are any merge conflicts created by undoing the change, you will have to deal with those at the time of your new commit (the revert one).

git commit —amend

git commit —amend is another command that allows you to change your last commit. Say I forgot to stage a file for the commit and I need to edit the commit message:

$ git commit -m 'initial commit'
$ git add awesome_file
$ git commit --amend

My visual editor of choice will open with the prior commit message allowing me to edit it, I change the message, save it and exit. The previous commit is overridden by adding the content of my awesome_file and now has my new commit message. Personally, I’ve only had to use this a couple times because I’m usually editing tracked files and by doing git commit -am “message” I rarely forget to stage my files. The times I’ve had to use git commit —amend is when I forget to add/stage a new/untracked file.

Refspec matches more than one

2010-01-18T00:00:00-08:00

Refspec matches more than one

18 Jan 2010 – San Antonio

I was trying to push to a canonical repository this morning and got the following error:

> git push origin master
error: src refspec master matches more than one.
error: failed to push some refs to 'ssh://user@host/srv/git/repo'

This happened because I had accidentally created a master tag locally. Once I deleted the tag locally:

tag -d master

I was able to push again.

Git post-merge hook to auto-fire rails migrations

2009-12-22T00:00:00-08:00

Git post-merge hook to auto-fire rails migrations

22 Dec 2009 – San Antonio

I saw Scott Bellware recently write on twitter: for christmas, i really want a git hook to detect if an update has changes in the db/migrations folder

Cory Foy, Aaron Jensen, and myself all responded in turn.

I think Cory and I were quickly searching for which git hook could be used for this idea. Cory found it first and it was the post-merge/post-rebase hooks. I researched the post-merge hook (scroll down to post-merge) and noticed it has no params that we could work with to find out if the last commit had migrations (aka changes/additions to db/migrations folder in a rails project)

I came up with the following :

#!/usr/bin/env ruby

`rake db:migrate && rake db:test:prepare` if `git diff HEAD^`.index("db/migrations")

This will grab the previous diff and look for “db/migrations” in the text. If it’s present, it would auto-run “rake db:migrate && rake db:test:migrate”. In other words, it will migrate the development database schema, then the test database schema.

Suspicious Patch Lines

2009-12-20T00:00:00-08:00

Suspicious Patch Lines

20 Dec 2009 – San Antonio

DISCLAIMER: This is only relevant if you or someone contributing to your project are doing cross-platform development. If you are typically just developing on Windows, you should be able to keep the config options set to false.

The Problem

While trying to commit changes to a file I have under source control with Git on a Windows box using cygwin, I received the following error:

jmeridth@web1 /cygdrive/d/site
$ git commit -am "changed the README to show authors"
*
* You have some suspicious patch lines:
*
* In README
* trailing whitespace (line 26)
README:26:

This type of error has been discussed quite a bit amongst .NET developers who are transitioning to Git. It has to due with the difference in handling of newlines between Windows and the Mac/*nix world. There are five solutions to this:

1) Run the following from inside the repository: (the one I usually use, due to my cross-platform development)

git config core.autocrlf true
git confit core.safecrlf true

The Github Help Pages provide an excellent explanation about this. Also read the direct documentation from git-core. This makes Git convert CRLF at the end of lines in the text files to LF when reading from the filesystem, and convert in reverse when writing to the filesystem. Just be aware also that if you do set this and one of your stored binary files is accidentally marked as text, there is a chance for it to become corrupted.

2) Edit the .git/hooks/pre-commit file and comment out the following lines:

if (/\s$/) {
  bad_line("trailing whitespace", $_);
}

The reason why this is a problem is because there is a space (\s in posix regex) just before the end of the line (aka a trailing whitespace). Normally this file wouldn’t fire off unless you made it executable, but on Windows all of the git hooks run because there is no concept of whether they are executable or not, they all are by default. On Mac/*nix Git repositories, you need to “chmod +x” (change to executable) the git hook files before Git will run them.

3) When commiting do the following:

git commit --no-verify

and the pre-commit hook will be ignored.

4) Rename/Move/Delete the .git/hooks/pre-commit file

mv .git/hooks/pre-commit .git/hooks/pre-commit.stop_working

5) Change the permissions on the .git/hooks/pre-commit file. In this case, I’m clearing the executable bit for all users (owner, group and rest of the world)

chmod a-x .git/hooks/pre-commit

Agile coaching

2009-12-13T00:00:00-08:00

Agile coaching

13 Dec 2009 – San Antonio

My manager let me borrow his copy of Pragmatic Programmer’s Agile Coaching. I’ve read a good number of Agile process and management books. I’m partial to the Pragmatic Programmer publishers due to their consistently well-written books. I also started using stickies instead of pens/pencils when I read my books. Mainly because they stand out better and allow me to find my notes quicker. The other reason is because I can remove them when I give the book away (which I’ve done a good deal lately. Of course, not with this book since it was my boss’). The stickies I use are these and can be found at most office stores.

Anyways, back to the book. The authors, Rachel Davies and Liz Sedley, do a good job explaining the different ways to start/continue agile coaching. The format of the book, multiple sections relevant to the chapter, Hurdles, and Checklist, worked very well for me. They share their experience, pain points, and give you a list that you can contain in your short-term memory.

I enjoyed reading this book because it made me, once again, focus more on the people aspect of software development and less on the coding. I haven’t focused much on that part because I’ve assumed the people I work with are all professionals. Unfortunately, I’ve forgotten that they are human, too and need to be approached as humans and not machines. I’m still convinced that all software developers are control freaks. Our computer does what we tell it to. If it doesn’t, it is usually our fault.

I highly recommend this book.

NOTES

—

Chapter 1 – Starting the Journey

Developing a Coaching attitude

Lead by example – follow the agile principles yourself
Keep your balance – never take criticism personally
Set a realistic pace – patience, change takes time
Mind your language – stay professional, of course, but use terms like “our/we/us” instead of “I/you/they”.
Learn as you go – most powerful lessons are learned from mistakes, expect to make them

PrOpER cycle

Problem: Pick a problem to work on. Watch how the team works. What needs to be improved
Options: Consider your options. What could you try that might influence the situation for the better? List at least three options
Experiment: Pick one option to try
Review: Review the outcome. Did you improve things? Even if things haven’t improved, have you learned something?

Credit the Team

Don’t expect to get recognition
Supporting Role
Success – credit goes to team
Failure – commiserate with the team

No Experience

Uknown situation – be open about it to the team rather than bluffing.

—

Chapter 2 – Working with People

Yes, I’m Listening

Create space
Be open
Show interest
Affirm

Gradient Scale for building agreement

Endorse
Agree with reservations
Mixed feelings
Disagree but go with majority
Block

—

Chapter 3 – Leading Change

Five Whys

will usually help you get to the real problem

When Not to Ask Questions

Take care not to ask questions when you actually want to give guidance.
If you ask a question, you have to accept the answer, even if you disagree, and this makes it harder to give the advice you wanted to give.

—

Chapter 4 – Building an Agile Team

If people feel really unsafe—for example, if the are scared that they will lose their jobs—you won’t be able to do any Agile coaching.

Not Too Easy, Not Too Hard

Foster a culture where is’s OK to experiment to learn more about a problem that the team is trying to solve.
Although, developing more than one solution may feel like a waste of time, it can be a quick qay to learn and a cheap way to mitigate the rise of making the wrong decision.

Find a Compelling Goal

Once they understand that they don’t need to wait for permission, it can free them to make a start.

Time For Innovation

If they don’t get time to explore new technology or experiment with innovative product ideas, teams become demotivated. Make time in iteration plans for them to explore new ideas. This can do wonders for motivation—and for the product.

Teams Aren’t Cross-Functional

Some companies organize teams by discipline, such as analysts, designers, testsers, software engineers, and so on, with separate reporting lines. This is a serious blocker to becoming Agile because a fundamental Agile principle is cross-functional teams with different disciplines working together to build the best software.

—

Chapter 5 – Daily Standup

For the Team by the Team

Standup is for them to synchronize their work.
It is not held for a project manager or team lead to gather progress from the team or give feedback on their work.
Encourage the team to direct their answers toward other team members.

Establising a Team Focus

Asking questions in the daily standup could cause members to focus responses to you, avoid this.
If response are continually directed at you, deflect them like this: “Please, can you direct your replies to the whole team? The daily standup is for you all to work out what you need to do today, not me”. Worst case: do not attend the daily standup at all
Avoid giving praise during the stand-up, again to avoid focus of work and responses on you

Handling Issues

Parking lot of issues on the whiteboard

Forget the Formula

Don’t let the rules, which are there to help you get started, become a straightjacket once you are more established.
Don’t let the stand-ups/scrum lose it’s meaning

Hurdle: Dail Standup Isn’t Wanted

…if the whole team objects to the daily standups, you have a more serious problem on your hands. It is possible that they’re struggling to work as a team or that the meetings are being badly run. We suggest you discuss their concerns in the retrospective.

—

Chapter 6 – Understanding What to Build

Life Cycle of a User Story

A story is a placeholder for a conversation and eventual task breakdown.
Ron Jefferies summarizes the critical aspects of users stories as the 3Cs

Card
Conversation
Confirmation

Story Templates

Purpose is to help team improve their understanding rather than a form to be filled in.

Confirming the Details

Another common term for story tests is acceptance criteria

Hurdle: No User-Facing Functionality

Still use your story templates and not short ambiguous task names

—

Chapter 7 – Planning Ahead

Decomposing into Tasks

…if the team already has a clear idea of the work, decomposing into tasks may be overkill.

Arriving at an Estimate

Use a story card matrix (grouping story cards with similar estimates into columns) to help the team keep their estimates consistent.

Keeping Track

Noticed that putting tasks in a tracking tool can lead to micromanagement.
Remind the team that stakeholders will be interested in whole user stories being finished rather than tasks because tasks aren’t deliverables.

Hurdle: The Team Is Asked to Overcommit

Try to convince the stakeholder or others in charge of the hard date, that all deliverables may not be delivered.

Hurdle: Plan Changes During the Iteration

Expect the team to create some additional tasks for a story as their understanding of the problem grows, but watch out if the tasks change a lot—that is a sign that the team didn’t come to grips with what needed to be done in planning.

Hurdle: Planning Doesn’t Make Sense

Rather than waste time on planning iterations during times of low resources due to vacation, training, etc, or many bugs, create a prioritized queue of work on the team board.
If this happens a lot, then consider moving to a kanban style of development, which doesn’t depend on iteration timeboxes to limit work in progress.

—

Chapter 8 – Keeping It Visible

Agile Planning Software Won’t Help

Adding “agile” software to an already broken process will only hinder communication further

Electronic Boards

Electronic tools don’t need to break down to tasks, as their lifespan is only as long as the story is being worked upon.

—

Chapter 9 – Getting to “Done”

Defining What “Done” Means

“Done” means the customer is happy with what has been developed, and all the story tests pass.

Managing Bugs

If story test is failing, it needs to get fixed before the story can be considered as “done”
Team disgression on other bugs that come up during the iteration

—

Chapter 10 – Driving Development with Tests

Test-Driven Development

…encourages a developer to think about solving one small problem at a time

Unit Test Rules by Michael Feathers, Object Mentor

A test is not a unit test if:
it talks to the database
it communicates across the network
it touches the file system
it can’t run correctly at the same time as any of your other unit tests, or
you have to do special things to your environment (such as editing config files) to run it

Don’t Force Toys on the Team

Team rituals spring up naturally
Don’t inflict the team with a forced, cute build token

—

Chapter 11 – Clean Code

Agreeing On a Way Forward

possibly use an outside expert, therefore, focusing on the issues and not the personalities

Pair Programming

when driving, don’t just type code in silence. Explain what you’re doing and why.

—

Chapter 12 – Demonstrating Results

Everyone Plays a Part

During the demonstration…take notes unobtrusively on index cards rather than writing them up on a whiteboard because this can distract from the demo

—

Chapter 13 – Driving Change with Retrospective

Looking Back

Possibly use a timeline, having each member fill in items with sticky notes, will provide a “clear” picture of past events.
Art gallery – have each member draw a picture (metaphor) of what the project/iteration felt like to them.

Mining for Gold

Dot voting – choose three most critical topics. Each member gets three votes. Prioritize critical topics based off dot summation.

Designing a Retrospective

example of how to break down the time:
Review the goal of meeting, and remind the team of the ground rules (5 minutes)
Create a timeline (15 minutes)
Mine the timeline for insights (15 minutes)
Select the topics to focus on (10 minutes)
Review the progress on previous actions (5 minutes)
Generate ideas for improvements (15 minutes)
Action planning (15 minutes)

Prime Directive

Ground Rules:
no laptops
cell phones on silent
taking turns to speak
Prime Directive: “Regardless of what we discover, we understand and truly believe that everyone did the best job they could, give what they knew at the time, their skills and abilities, the resources available, and the situation at hand.”
prime directive also helps counter fundamental attribution error, which is the human tendency to explain the actions of other people as deliberate choice and downplay the situational fears.

Retrospective Prework

email querying attendees to gauge direction

—

Chapter 14 – Growing You

Ways to Grow What You Know

Commit to read one technical book per month
Start your own blog
Contribute to an open source project
Post one a day to a community mailing list
Listen to a podcast on your way to work
Spare one evening a monh to attend an interest group

Making a Plan

Invest in your knowledge
Do not expect your employer to pay for you
your plans need to achievable, bear in mind your other commitments

Personal Reflections

write down your thoughts to help articulate your feelings

Take a Break

If you don’t take time to unwind, you will be unable to put events into perspective and context. If you are stressed, everything seems bigger, worse, and more important that it really is
Try to get a sense of perspective. What are you stressed about? When you look a year from now, will it still seem important? If not, then is it important enough to worry about now?

Getting Comfortable

Agile Coach == thick skin
Not everyone likes being challenged and stretched, and they may take it out on you

Be Kind

Don’t judge others harshly
assume everyone is doing their best and that they do everything for a reason
Don’t guess and then judge and gossip — go talk to them, find out about them

Pair programming with screen

2009-12-06T00:00:00-08:00

Pair programming with screen

06 Dec 2009 – San Antonio

I’ve decided, once again, to make the jump back to VIM full-time. It will help my bash-fu become stronger and also ensure that I can pair program with any other dev. TextMate is awesome for personal development, but using NERDTree (example) and vim.rails (cheat sheet) by @tpope has made my VIM experience much more pleasant..

Checkout my vim files on github

This post is for me to remember how to use Gnu screen to pair program. side note: here is the best cheat sheet on Gnu Screen.

startup screen:

screen -S sessionname

turn on multi-user

ctrl+a
:multiuser on

add permissions for the other user:

ctrl+a
:acladd user

instruct second user to connect with:

screen -x yourusername/sessionname

Ruby Design Patterns by Russ Olsen

2009-10-08T00:00:00-07:00

Ruby Design Patterns by Russ Olsen

08 Oct 2009 – San Antonio

After nudging by Joe Ocampo and Scott Bellware, I finally sat down at finished “Design Patterns in Ruby” by Russ Olsen.

The format of most of the chapters made the book an interesting read:
1. A introduction to why you might need the pattern
2. A static language developer’s approach with the Ruby language
3. A seasoned Ruby developer’s approach to the design pattern
4. Using and Abusing
5. in the wild
6. Wrapping up

Some of the items that I learned [LosTechies is not a cult contrary to some of the examples you read below; some of the examples below are using LosTechies nomenclature but closely resemble what the author had in the book]

If any of the stuff below intrigues you: GO BUY THE BOOK. You won’t regret it. Even if you are trying to understand patterns in another language. Russ Olsen does an excellent job explaining the INTENT of the patterns.

FUN

When teaching the reader about “Truth, Lies, and nil”, the author even pokes fun at himself:

  'russ' == 'smart'    # sadly, false

BOOLEAN

In Ruby, zero, being neither false nor nil, evaluates to true in Boolean expression.

if 0
 puts('Zero is true!')
end

will print out: Zero is true!

ARRAYS

Points for matrix reference in array examples

x = []
y = Array.new
a = ['neo', 'trinity', 'tank']

REGULAR EXPRESSIONS

The flow of the language when creating regular expressions:

/old/ =~ 'this old house'     # 5 - the index of 'old'
/Russ|Russell/ =~ 'Fred'      # nil - Fred is not Russ nor Russell
/.*/ =~ 'any old string'      # 0 - the RE will match anything

ARBITRARY PARAMETERS

Any author that uses DC comic character to explain arbitrary numbers of arguments, is a winner in my mind:

def describe_hero(name, *super_powers>
 puts("Name: #{name}")
 for power in super_powers
     puts("Super power: #{power}")
 end
end

describe_hero("Batman")
describe_hero("Flash", "speed")
describe_hero("Superman", "can fly", "x-ray vision", "invulnerable")   # w00t!

DUCK TYPING AND UNIT TESTS

He mentions duck typing and the fact that “Unit Tests Are Not Optional” is a section heading when teaching the Template Method Pattern.

PROCS AND BLOCKS

# using the do/end notation
hello = lambda do
 puts('Hello')
 puts('I am a follower of Pablo')
end

#you may use curly braces instead of do/end
hello = lambda {
 puts('Hello, I am a follower of Pablo')
}

#the preferred way to use curly braces
hello = lambda {puts('Hello, I am a follower of Pablo')}

STRATEGY PATTERN

using proc-based formatters to create a ruby-based strategy pattern

class Report
 attr_reader :title, :text
 attr_accessor :formatter

 def initialize(&amp;formatter)
   @title = 'Monthly Report'
   @text = ['Things are going', 'really, really well.' ]
   @formatter = formatter
 end

 def output_report
   @formatter.call( self )
 end
end

HTML_FORMATTER = lambda do |context|
...code to output HTML

report = Report.new &amp;HTML_FORMATTER
report.output_report

You could create any type of formatter you want in a proc instead creating new classes.

OBSERVER PATTERN

Modules exist that encapsulate things that some of us static developers might already be used to:

require 'observer'

class Employee
include Observable

attr_reader :name, :address
attr_reader :salary

def initialize( name, title, salary)
 @name = name
 @title = title
 @salary = salary
end

def salary=(new_salary)
 @salary = new_salary
 changed
 notify_observers(self)
end
end

ITERATOR PATTERN

Internal Iterators versus External Iterators: (had never heard it put this way)
External iterator – client drives the iteration…you won’t call next until you are good and ready for the next element
Internal iterator – the aggregate relentlessly pushes the code block to accept item after item.

COMMAND PATTERN

The Command pattern translates very smoothly into code blocks. Here is a PabloForPresidentButton class reworked to use code blocks:

class PabloForPresidentButton
  attr_accessor :command

  def initialize(&amp;block)
    @command = block
  end
  
  #
  # Lots of button drawing and management
  # code omitted ...
  #

  def on_button_push
    @command.call if @command
  end
end

new_button = PabloForPresidentButton.new do
  #
  # Make a developer stop looking so nerdy
  # by placing one over his pocket protector
  #
end

The author does not diminish the needs for classes. For straightforward actions, use a Proc object. For complex object or objects that will carry around a lot of state, create a command class.

ADAPTER PATTERN

Instead of adhering to some interface and trying to create your adapter, why not just extend the original class.

# load original class
require 'lostechies_text_object'

# now add some methods to original class
class LosTechiesTextObject
  def sponsor
    return friend_of_pablo
  end

  def blogger
    return follower_of_pablo
  end
end

Before any of you Open-Closed people attack, please re-read the definition of OCP – Open for extension, closed for modification. Doesn’t this adhere to that? :)

PROXY PATTERN

There are three tyes of Proxies: The Protection Proxy, Remote Proxy, Virtual Proxy
These are mentioned in the Gang of Four book. He introduces a Ruby-esqe way to approach proxies: the method_missing Method

class AccountProxy
  def initialize(real_account)
   @subject = real_account
  end

  def method_missing(name, *args)
   puts("Delegating #{name} message to subject.")
   @subject.send(name, *args)
  end
end

ap = AccountProxy.new( BankAccount.new(100) )
ap.deposit(25)
ap.withdraw(50)
puts("account balance is now: #{ap.balance}")

Will output:
delegating deposit method to subject.
delegating withdraw method to subject.
delegating balance method to subject.
account balance is now: 75

DECORATOR PATTERN

module Decorator1
  def do_something(common_item_to_decorate)
   #code
  end
end

module Decorator2
  def do_something(common_item_to_decorate)
   #code
  end
end

d = SimpleItem.new()
d.extend(Decorator1)
d.extend(Decorator2)

e.do_something('howdy')

SINGLETON PATTERN

The author admits the career of the singleton has been checkered, but still shows that you can use it in the Ruby world. An example he gives us to allow testing of singleton implementation code is to put the implementation code in a base class and have the child be the singleton:

require 'singleton'

class SimpleLogger
#  All of the logging functionality in this class...
#  Test this code
end

class SingletonLogger < SimpleLogger

FACTORY/ABSTRACT FACTORY PATTERN

I never had it straight, exactly, what the difference between these patterns were (yes, besides name). I never bothered to look. According to the author, Factory returns back a single object while Abstract Factory is “an object dedicated to creating a compatible set of objects”. According to GoF book (which I have open in front of me), Abstract Factory “provides an interface for creating families of related or dependent objects without specifying their concreate classes”. Which one do you think would have turned the light bulb off in your head? :)

The other item was using “Convention Over Configuration” to generate abstract factories:

class IOFactory
  def initialize(format)
   @reader_class = self.class.const_get("#{format}Reader")
   @writer_class = self.class.const_get("#{format}Writer")
  end

  def new_reader
   @reader_class.new
  end

  def new_writer
   @writer_class.new
  end
end

html_factory = IOFactory.new('HTML')
html_reader = html_factory.new_reader

pdf_factory = IOFactory.new('PDF')
pdf_writer = pdf_factory.new_writer

Notice the correct classes (reader/writer) are generated dynamically with the help of the const_get Ruby method.

BUILDER PATTERN

Magic methods: “very easy to implement using the method_missing technique…you simply catch all unexpected method calls with method_missing and parse the method name to see if it matches the pattern of your magic method name”.

#example method passed into computer builder class
builder.add_dvd_and_harddisk

#or
builder.add_turbo_and_dvd_dvd_and_harddisk

def method_missing(name, *args)
words = name.to_s.split("_")
return super(name, *args) unless words.shift == 'add'
words.each do |word|
 #next is same as continue in for loop in C#
 next if word == 'and'
 #each of the following method calls are a part of the builder class
 add_cd if word == 'cd'
 add_dvd if word == 'dvd'
 add_hard_disk(100000) if word == 'harddisk'
 turbo if word == 'turbo'
end
end

Last 3 Chapters are the meat of the book:
INTERPRETER PATTERN (place where Bellware told me to start)
DOMAIN SPECIFIC LANGUAGE (DSL)
CONVENTION OVER CONFIGURATION

Those stay obscure so you can go read it. I think the book is worth a visit on Safari books if you have an account or worth the purchase for the bathroom reading.

I enjoyed it. Thanks Scott and Joe

Move my personal blog to Jekyll

2009-10-08T00:00:00-07:00

Move my personal blog to Jekyll

08 Oct 2009 – San Antonio

Tonight I decided to finally move my blog to the Jekyll blogging engine. It’s about static content and no longer using a database to store your posts. I’ve been reading about it for a while and decided to make the jumpt tonight.

Hell, maybe I’ll try to contribute back to the project for needs that I have and that don’t exist. I like that idea a lot.

git local pre-commit hook

2009-10-08T00:00:00-07:00

git local pre-commit hook

08 Oct 2009 – San Antonio

I’ve personally added a pre-commit hook to my local git repos. It’s like a personal CI before I push back to origin/master. I run my tests locally anyway before committing and pushing, so I thought I would automate it.<

I open the .git/hooks/pre-commit file in my local repo (i.e, full path is something like /Users/jasonmeridth/code/rails/myapp/.git/hooks/pre-commit) and put the following:<

#!/bin/sh
rake db:migrate
rake db:test:prepare
rake

For non-rails developers, this will run any database migrations on my development database, then ensure the test database has the same schema, and then runs the tests.

The reason the last step above is “rake” is because I leave it to you to have your default rake task be “rake test:units” or “rake spec” depending on whether you are using a TestUnit framework or RSpec.

Git hooks are not made executable by default, except on Windows because it doesn’t understand the unix permissions. On my Mac, I have to issue the following command (from the app root):

chmod +x .git/hooks/pre-commit

This makes the pre-commit hook executable and Git will run it before every commit to this repo. If this process returns a non-zero value (failure), then the commit does not happen. I’ll be shown the failing tests and I can fix them and try to re-commit.

git instaweb

2009-10-08T00:00:00-07:00

git instaweb

08 Oct 2009 – San Antonio

I was reading Pro Git by Scott Chacon and was on the section about “git instaweb”. This is where you can run gitweb, a cgi script that comes with git, locally or on a server. I have successfully gotten gitweb up for my personal git repos on my remote server. I use it all the time. I was curious if I could get it working locally, for friends who prefer a visual tool to see their git logs, commits, etc.

I cd into a local repo (you have to cd into the .git folder of the app to get the desired view):

cd /code/app/.git

and run the instaweb command (note: I’m on a macbook pro that already has ruby installed, hence my choice of using webrick instead of the default lighttpd):

git instaweb -d webrick --start

I tried the command without the “—start” command and it kept trying to seek a browser. I tried “-b firefox”, “-b Firefox”, “-b /Application/Firefox.app/MacOS/firefox-bin”, etc and they all failed. I found the “—start” suggestion on StackOverflow.com

Once I ran this command, I could see the git log, commits, diffs, etc in gitweb for my local changes. What this will do is run the daemon on port 1234 of localhost. If you open your browser of choice and go to http://localhost:1234 then you will see gitweb for the git repository you ran the command in.

To stop the process, just change “—start” with “—stop”.

git instaweb -d webrick --stop

Note: I personally use “git log —graph”, gitk, gitx, or other tools for this, usually. Just thought it was a good addition to my git toolset.

Hudson service files

2009-06-09T00:00:00-07:00

Hudson service files

06 Jun 2009 – San Antonio

This post is strictly for my reference. These scripts are dependent on an existing user named hudson with a home directory of /home/hudson and the hudson.war file being located at /usr/share/hudson/hudson.war.

/etc/init.d/hudson

#! /bin/bash
#
# hudson    Start/Stop the Hudson Continuous Integration server.
#
# chkconfig: 345 91 10
# description: Hudson is a Continuous Integration server. \
#              It monitors a source code repository and triggers builds \
#              when it detects any changes. See https://hudson.dev.java.net/ \
#              for more details.
# processname: hudson
# pidfile: /var/run/hudson.pid


# Source function library.
#. /etc/rc.d/init.d/functions

# Get config.
#. /etc/sysconfig/network

# Check that networking is up.
#[ "${NETWORKING}" = "no" ] && exit 0

startup=/usr/local/bin/start-hudson.sh
shutdown=/usr/local/bin/stop-hudson.sh
export JAVA_HOME=/usr/java/jdk1.6.0
HUDSON_USER=hudson

start(){
 echo -n $"Starting Hudson service: "
 su - $HUDSON_USER -c $startup
 RETVAL=$?
 echo
}

stop(){
 echo -n  $"Stopping Hudson service: " 
 su - $HUDSON_USER -c $shutdown
 RETVAL=$?
 echo
}

status(){
 numproc=`ps -ef | grep hudson.war | grep -v "grep hudson.war" | wc -l`
 if [ $numproc -gt 0 ]; then
  echo "Hudson is running..."
  else
  echo "Hudson is stopped..."
 fi
}

restart(){
  stop
  start
}


# See how we were called.
case "$1" in
start)
 start
 ;;
stop)
 stop
 ;;
status)
 status
 ;;
restart)
 restart
 ;;
*)
 echo $"Usage: $0 {start|stop|status|restart}"
 exit 1
esac

exit 0

/usr/local/bin/start-hudson.sh

#!/bin/bash
HUDSON_WAR=/usr/share/hudson/hudson.war
HUDSON_LOG=/home/hudson/hudson.log
java -jar $HUDSON_WAR > $HUDSON_LOG Z>&1 &

/usr/local/bin/stop-hudson.sh

#!/bin/bash
kill -9 `ps -ef | grep hudson.war | grep -v grep | awk '{print $2}'`

Git post-receive hook with Integrity post call

2009-05-28T00:00:00-07:00

Git post-receive hook with Integrity post call

28 May 2009 – San Antonio

Using the following code:

#!/usr/bin/env ruby
 
require 'rubygems'
require 'net/http'
require 'net/https'
require 'json'
 
# EDIT POST_RECEIVE_URL
POST_RECEIVE_URL = 'https://my.domain.com/application_name/push'
 
old_head, new_head, ref = STDIN.gets.split
 
#puts "old_head: #{old_head}"
#puts "new_head: #{new_head}"
#puts "ref: #{ref}"
 
revision_text = `git-rev-list --pretty=format:'Author: %an <%ae>%nDate: %cd%n%s%n' #{new_head} ^#{old_head}`
revisions = []
revision_text.split(/\n\n/).each { |commit|
  s = commit.split(/\n/)
 
  s[0] =~ /commit (\w+)/
  sha1 = $1
  s[1] =~ /Author: (.*) <(.+?)>/
  author_name, author_email = $1, $2
  s[2] =~ /Date: +(.+?) -0/
  timestamp = $1
  message = s[3].strip
  revisions << {
    'id' => sha1,
    'author' => {
      'email' => author_email,
      'name' => author_name,
    },
    'message' => message,
    'timestamp' => timestamp,
  }
}
 
if revisions.empty?
  exit 0
end
 
payload = {
  'payload' => {
    "ref" => ref,
    "commits" => revisions,
  }.to_json
}
 
if pid = fork
  Process.detach pid
else
  uri = URI.parse(POST_RECEIVE_URL)
  post_req = Net::HTTP::Post.new(uri.path)
  post_req.basic_auth '53cr3t', 'p@55w0rd'
  post_req.set_form_data(payload, ';')
 
  req = Net::HTTP.new(uri.host, uri.port)
  req.use_ssl = true
  req.verify_mode = OpenSSL::SSL::VERIFY_NONE
  req.start {|http| http.request(post_req)}
end
 
puts "Running Integrity CI build for application_name application"

This git post-receive hook script queries the latest commit, gets the revision changes, and then passes that payload (via json) to a net/https POST call. I setup our Integrity CI server with a self-signed certificate and HTTP basic authentication.

The Net::HTTP::Post.new instantiation group handles populating the basic authentication information and putting the payload into the form data of the request. The Net::HTTP.new group handles telling the request that it will be via SSL (443) and to not verify the SSL certificate (since I’m using a self-signed certificate; otherwise, I’d get a warning and kill my automation process)

The other important part is the “if pid = fork”. The ruby fork command allows code to happen in the background, in the case the POST call, and therefore make the call synchronous. Otherwise, when the developers commit their code to the repository, they will have to wait for the build to finish before their prompt will be returned to them. fork will return zero (0) if it fails to create the background process.

I’m still checking whether the zombie process warning in the rdoc (for the fork command) is a problem. I’ll update this if it is.

The last line is notification for the user so they know what’s going on. Always good to keep the user in the loop. :)

Nerds

2009-04-06T00:00:00-07:00

Nerds

06 Apr 2009 – San Antonio

Joe Ocampo and I have been good friends for a while.

This is from one of our pairing sessions. I drink Monster.

And this is from this past weekend at the Alt.NET conference:

Should make someone laugh.

Git and sharedrepository

2009-02-26T00:00:00-08:00

Git and sharedrepository

26 Feb 2009 – San Antonio

Today I pushed some code changes to our canonical repository. Well, at least I tried. I couldn’t because the user and group that were associated to that change had been changed by the prior user’s push. It was the user change that was the problem, it was the group change.

I found out that we needed to add “sharedrepository=true” to the /srv/git/our_repository/.git/config file so that the group assigned to the repo’s objects (/srv/git/our_repository/.git/objects) doesn’t get changed to the local user’s.

All the developers are a part of the same group on the git server; the same group initially assinged to the objects. With the “sharedrepository=true” setting, that won’t change when anyone from that group pushes to the canonically repository.

Hudson and Nginx

2009-02-09T00:00:00-08:00

Hudson and Nginx

09 Feb 2009 – San Antonio

UPDATE: I left HTTP Auth in place via Nginx and removed security from my Hudson instance. This works for me because I don’t care about Hudson security. I’m just trying to prevent external access to the dashboard.

I’ve been having fun trying to figure out how to block a user’s ability of going to http://mydomain:8080 and bypassing my 80 to 443 redirect and htpasswd HTTP basic authentication. I even went as far as removing Nginx and installing Apache.
According to the Hudson site, we can use Apache to do this. Either I’m not smart enough or web pages like this reminded me why I hate the Java Enterprise stack as much as I do. Talk about installation obfuscation.

My problem exists because the Tomcat instance running the hudson war file uses Apache JServe Protocol (AJP) and will allow direct access on whatever port you used (default 8080). This is even if you proxy_pass to 8080 from 443 (SSL) or 80 (Web).

Through testing and research it seems that Nginx does not have a solution for this. I can’t allow access to my Hudson instance from external users. I have a self-signed certificate and a .htpasswd file to protect the instance, but is all useless is someone could just type in http://mydomain.com:8080. I want that redirected to https://mydomain.com which will then proxy internally to http://127.0.0.1:8080.

I didn’t want to fight this, so I just used iptables (linux firewall) to block external requests on port 8080 but allow internal requests to 8080. Here is the entry in my iptables file:

# Deny HTTP requests to port 8080 externally but allow internally
-A INPUT -i eth0 -p tcp -m tcp --dport 8080 -j REJECT

I only allow access to my server via 80 (web), 443 (ssl) and my ssh port (I’m not telling).

This works for now, but I’m experiencing another weird issue. I follow the Nginx way of using HTTP basic authentication:

location  /  {      
 auth_basic            "Restricted";
 auth_basic_user_file  conf/htpasswd;
}

If the user listed in the htpasswd file is also a registered user on the Hudson instance (through the Hudson UI) then the HTTP basic authentication will work. If they are in the htpasswd file but not registered with Hudson, it fails with a HTTP 401 (Unauthorized). Why would the HTTP basic authentication be “tunneled” through to Hudson?

I’ll update this post once I figure it out.

Slicehost articles

2009-01-31T00:00:00-08:00

Slicehost articles

31 Jan 2009 – San Antonio

If you are Linux newbie or are still unsure about how to setup your Linux box/slice/server (sorry Windows guys), take a serious look at the Slicehost Articles. Other articles include setup of Apache, Nginx, Postfix, MySQL, Ruby on Rails, Capistrano, SSH, Self-signed certificates, Django, etc.

For all the Only Windows guys who read this, these articles are a great way to get your feet wet with Linux. Can’t hurt your pocket book. It’s free. Ubuntu is my favorite.

I’ve tweeted about this a number of times.

These articles are phenomenal

Pair Programming

2009-01-29T00:00:00-08:00

Pair Programming

29 Jan 2009 – San Antonio

I recently found this post, Pair Programming all the time, by Jay Fields and loved it. I’ve felt the same way about pair programming.

“I define all the time (in terms of pairing) as when I’m writing code that I’m going to commit.”

That is perfect. Common sense but stated explicitly. I worked in an Agile shop for 2 1/2 years and the environment was setup to highlight pair programming. Pictures and little explanation here (Thanks Joe). We even marked tasks in the stories as low (L) or high (H) to dictate whether a pair was necessary (this was decided during our modeling week by the two developers who tasked the story, but always up for discussion during the iteration). It worked out pretty well.

I understand and have heard all the reasons to not pair program. Sometimes it works and sometimes it doesn’t. I’ve personally experienced the benefits. You learn to work with different personalities and that can only benefit you in your professional career. And, the obvious reason, is immediate code review. But, as my friend Scott C. Reynolds says (more or less):

“Not everyone is cut from the same cloth”

That is true and that is life. I hope this helps someone understand that not all pair programming enthusiasts are zealots. I know it’s a fine line though.