Jordan Elver

htop - a prettier top

2008-12-31T02:25:00+00:00

You use top right? No? Well, that’s probably because top is not the friendliest program in the world. Yes, it gets the job done, but it could be prettier. As I was using top more and more for monitoring my VPS, I looked for something a bit nicer.

This is where htop comes in. It’s top, but with colours, progress bars, and a process tree view. Much better. Try it, you might like it.

Changing Recent Commits with Git

2008-12-16T20:00:25+00:00

Have you ever committed to your repo and realised you’ve done something a bit silly? I just did that. I moved to a new machine and forgot to setup my .gitconfig with the correct username and email, so when I committed, the commit had the wrong user against it. Not a big problem, but it just looks a bit…well, untidy.

Fear not. Git is all-powerful and allows you to change your mistake even though you’ve already committed it. Thanks to Tekkub on the GitHub Google Group for the nudge in the right direction.

How does I dos it?

Like this.

   1  git reset --soft HEAD^

This will reset your working copy to the state before you committed and remove the commit so you can make changes to your working copy (if needed) and re-commit.

Re-commit the changes.

   1  git commit -m "Changed something"

If you’ve already pushed to GitHub or another external repo, you can re-push, but you’ll need to add --force because we have removed a commit locally and Git doesn’t like that.

   1  git push origin --force

I’m not sure whether this would be a good idea if someone else has cloned your repo, but I’m ok because I am the only person who pushes to this one.

Git is great, but powerful, so be careful. I’m sure it would be easy to completely trash your repo with the wrong series of commands.

Google Analytics Ecommerce Tracking

2008-08-07T15:46:41+01:00

So you’ve installed Google Analytics, the superb free web analytics software and it’s telling you all sorts of things about your site, most of which you don’t even understand. You’re learning what a Bounce Rate is and realising how powerful this thing really is.

Well, it gets even better. I’ve recently discovered its’ Ecommerce tracking feature. It allows you to capture Ecommerce related statistics alongside your normal web related statistics. Once you have it correctly setup for your site you can see how much money you’ve taken in sales, how many transactions have taken place, how many products have been purchased, and your Ecommerce conversion rate. Very nice.

Make it so

In order to activate Ecommerce tracking, you need to firstly turn on the feature within Google Analytics, and secondly add some extra JavaScript code to your receipt or thanks page.

To turn on the feature, go to the Profile Settings for your site, click Edit (top right) and under E-Commerce Website, select “Yes, an E-Commerce Site”. Here’s the extra code you need to add to the receipt page straight from Google’s help page.

   1  <script type="text/javascript">
   2  var gaJsHost = (("https:" == document.location.protocol) ? "https://ssl." : "http://www.");
   3  document.write(unescape("%3Cscript src='" + gaJsHost + "google-analytics.com/ga.js' type='text/javascript'%3E%3C/script%3E"));
   4  </script>
   5  
   6  <script type="text/javascript">
   7  var pageTracker = _gat._getTracker("UA-XXXXX-1");
   8  pageTracker._trackPageview();
   9  
  10  pageTracker._addTrans(
  11    "1234",                                     // Order ID
  12    "Mountain View",                            // Affiliation
  13    "11.99",                                    // Total
  14    "1.29",                                     // Tax
  15    "5",                                        // Shipping
  16    "San Jose",                                 // City
  17    "California",                               // State
  18    "USA"                                       // Country
  19  );
  20  
  21  pageTracker._addItem(
  22    "1234",                                     // Order ID
  23    "DD44",                                     // SKU
  24    "T-Shirt",                                  // Product Name 
  25    "Green Medium",                             // Category
  26    "11.99",                                    // Price
  27    "1"                                         // Quantity
  28  );
  29  
  30  pageTracker._trackTrans();
  31  </script>

If you’re already using Analytics, the first few lines will be familier to you. They’re just the standard page tracking calls. The bits we’re interested in are the pageTacker._addTrans(), pageTracker._addItem() and pageTracker._trackTrans() methods. You’ll need to fill in the relevant details, and more importantly repeat the _addItem call for each item within the order. The method for doing this will obviously differ depending on your server side choices, but for Rails I’ve got something similar to this.

   1  <% @order.items.each do |item| %>
   2  
   3    pageTracker._addItem(
   4      <%= @order.order_id %>,                     // Order ID
   5      <%= @order.sku %>,                          // SKU
   6      <%= item.product.name %>,                   // Product Name 
   7      <%= item.product.category %>,               // Category
   8      <%= item.unit_price %>,                     // Price
   9      <%= item.qauntity %>                        // Quantity
  10    );
  11  
  12  <% end %>

You should now start to get E-Commerce stats showing up under the Ecommerce section of Google Analytics. h4. References

Git Patching Flexibility

2008-08-04T15:33:26+01:00

I don’t know about you, but when I’m coding I’ll often need to make a change that’s unrelated to the current feature or bug I am working on. I’ll notice a spelling mistake, a typo, or some other small code change. You don’t want to commit the unrelated change as part of your overall commit because, well, it’s unrelated. It should be its own commit with its own commit message. This will make it much easier to read the commit log and cuts down on confusion. People won’t have to ask “Why did they change that? It has nothing to do with the change”

When I used Subversion, you had to remove the unrelated change, commit, then add it back in and commit again. Maybe there was a nicer way, but I didn’t know it. Git is much nicer.

When you stage a file ready for committing, Git allows you to only stage a certain part or parts of the file, which it calls hunks.

So, run:

   1  git add --patch <filename>

Git will show you a diff of the first difference that it wants to stage and will ask if you’d like to stage the current hunk, like this:

   1  Stage this hunk [y/n/a/d/s/?]?

The options in this example are:

y - stage this hunk
n - do not stage this hunk
a - stage this and all the remaining hunks in the file
d - do not stage this hunk nor any of the remaining hunks in the file
s - split the current hunk into smaller hunks

Choose what you’d like to do with the current hunk. Git will continue to go through the rest of the hunks in the file, asking you what to do with each one. When you’ve decided which hunks should be staged, commit as normal and only those changes will form part of the commit. You can then add the rest of your changes and commit again.

It’s the flexibility that’s great. It works with you, not against you.

For a much more in depth look at the capabilities of git add --patch, see the following article.

The Thing About Git by Ryan Tomayko

How to generate / request an SSL certificate

2008-07-24T14:28:04+01:00

Generating an SSL certificate can be confusing if you’ve never done it before. Actually, it’s confusing if you have done it before. Hopefully this should remind me how to do it in the future!

PLEASE NOTE: I am no expert on SSL, but this does the job for me.

I recently had to do this after the Debian security vulnerability affected one of my SSL certificates.

I currently get my SSL cerficiates through NameCheap for $10. They are re-sellers of RapidSSL and GeoTrust certificates. Mine is a RapidSSL.

Generate a private key and Certificate Signing Request

We need to generate an OpenSSL keypair and a Certificate Signing Request.

The keypair consists of two cryptographic keys. A public and private. The public key is included with the CSR along with other applicant information such as name, company, etc. The private key is used to sign the CSR request.

A CSR is what you send to your chosen Certificate Authority (CA) to request that they supply you with an SSL certificate. It includes your identifying information and the public key for your server/site.

Generate it like this.

   1  openssl req -new -newkey rsa:1024 -nodes -keyout example.key -out example.csr

You’ll be prompted to enter information such as Common Name, Organisation, Country etc.

It should be fairly straight forward, but your CA will let you know if you’ve done it wrong, I’m sure.

This will create example.key (the private key) and example.csr (the CSR).

Requesting your certificate

This part should be easy. Normally your CA will have a form on their website which allows you to paste in your CSR. This obviously varies from company to company. Once you have given them your CSR, they will first ask you for money, and then generate your CRT file. Yay!

I’m only scratching the surface of SSL here. OpenSSL has a massive amount of options. There is much to learn.

References

More information on OpenSSL commands

Rails Deployment with Git, Vlad and SSH Agent Forwarding

2008-07-10T20:51:50+01:00

I’m switching my code repositories over to Git from Subversion. For the most part it’s going well. I’m having some issues with line endings, but that’s for another post. I’m still getting to grips with day to day usage, but can already see that it’s going to be a great improvement on Subversion.

This is how I’ve setup Vlad, Git, and SSH to work together.

Vlad Configuration

I use Vlad to deploy my projects to the staging/live server, so I needed to re-configure Vlad to support Git. This was very simple to do. In my Rakefile, I included the Git class instead of the Subversion class. This removes the Subversion specific commands and includes the Git specific commands instead.

   1  -require 'vlad/subversion'
   2  +require 'vlad/git'

I also changed the repository address in my config/deploy.rb file.

   1  -set :repository, 'https://sub.version.server/repo'
   2  +set :repository, 'git@github.com:username/repo.git'

These are the only changes I needed to make.

SSH and Git setup

Git uses SSH keys to control access to repositories. As I’m using GitHub as my deployment Git repository, I needed to identify myself with them. To do this, I supplied them with my SSH public key. GitHub have good instructions on how to do this.

As the code is cloned from GitHub directly to the deployment server (not my machine), my private SSH key would also need to be installed on the deployment server.

Vlad deployment now works! This will checkout the latest HEAD and deploy it to the server. You can set the specific revision that you want in your config/deploy.rb as well if required. I’m not doing that at the moment.

So, what’s the problem?

The problem is that you need to install your private SSH key on the deployment server. I didn’t want to do this in case the server was ever compromised. If it was compromised, the attacker could also theoretically get into other systems using that key if it didn’t have a passphrase. This would be bad. My key does have a passphrase, but why install it when you don’t really need to?

Making it more secure

Fortunately, there’s a rather nifty solution to this problem — SSH agent forwarding. In order to do so, you must first be using SSH Agent. SSH Agent allows you to authenticate yourself once per session, so you don’t have to enter your password every time you connect to the server. If you’re already using SSH keys and have SSH Agent running on your system (which is the default in Ubuntu), you just need to do:

   1  ssh-add ~/.ssh/<keyname>

You’ll be prompted for the passphrase to the key. Once you enter it, you should be able to connect to any servers using that key without entering it again. This is very handy anyway regardless of whether you’re going to be using forwarding or not.

See this wikipedia page for more information.

How to setup the forwarding

This is where the forwarding comes in. SSH can forward requests for authentication back to the original SSH Agent process running on your machine. So, you can connect to your deployment server and then connect to another server without re-entering your passphrase or having to install any keys on the deployment machine itself. Much coolness. This negates the need to install any other keys on the deployment server itself.

There is a very well explained article called An Illustrated Guide to SSH Agent Forwarding over at Unixwiz.net that goes into a lot of detail about how this all works. It’s well worth a read.

This is how to set it up.

Edit your ~/.ssh/config file and add something like this:

   1  Host <name>
   2    HostName <ip or host>
   3    User <username>
   4    IdentityFile ~/.ssh/<filename>
   5    ForwardAgent yes

This is all you need. If you’ve got SSH Agent running, you’re sorted.

Incidentally, you can add these sections for as many hosts as required. It saves you having to type out lots of command line switches all the time. Just leave out the ForwardAgent yes line.

References

w00t! First post evar!

2008-06-17T14:28:27+01:00

Hello. The proper site is now live. It’s been way too long coming, but now it’s here. I built it using Webby. Hopefully there’ll be some posts explaining how that was done soon.

P.S. I know some people won’t like the colours, but I do.

Rake dependencies

2008-06-30T10:00:18+01:00

Rake tasks are great for all sorts of small tasks. They give you a bit of structure to what would normally be a shell or ruby script. However, the thing I like about rake tasks are dependencies.

A simple example

You see, you can make one task rely on another. Take this.

   1  desc "Make coffee"
   2  task :coffee => :get_mug do
   3    puts "Making a coffee"
   4  end
   5  
   6  task :get_mug do
   7    puts "Getting a mug"
   8  end
   9  
  10  rake get_mug
  11  > Getting a mug
  12  
  13  rake coffee
  14  > Getting a mug
  15  > Making a coffee

Easy to understand isn’t it? coffee depends on get_mug, so get_mug will be called before the main coffee task every time rake coffee is run.

A better example

You can also redefine task dependencies without altering the original task. For example, on this blog I have a task which creates index pages for the category pages. I want this to run everytime the build task is run. I could modify the original build task, but a much nicer and cleaner way is to redefine the task and add the dependant task like so.

   1  task :build => 'blog:categories:create_indexes'

This will keep any existing dependencies that the build task originally had and also add my new one. Ain’t it pretty?

References

Thanks to the guys at Rails Envy for their tutorial

Ruby on Rails Rake Tutorial [aka. How rake turned me into an alcoholic]

Git bash completion = Yay!

2008-06-19T00:05:16+01:00

If you’ve heard of, or are already using bash completion, you’ll know how great it is. Here’s how to use it with Git.

How to get the sweetness?

I’m using Ubuntu (Hardy), but setup instructions should be similar for others. For Ubuntu, uncomment this section in /etc/bash.bashrc and you’ve enabled bash completion. You’ll need to open a new terminal for it to take affect.

   1  #if [ -f /etc/bash_completion ]; then
   2  # . /etc/bash_completion
   3  #fi

How to enable Git completion

You’ll need the bash completion file for Git. This file details how the Git commands will be completed. The file comes as part of the Git distribution.

Download the lastest git release from http://www.kernel.org/pub/software/scm/git/
Find the git-completion.bash file in the contrib/ directory and copy to the /etc/bash_completion.d/ directory
Start a new login shell (logout/login or start a new Terminal tab)

Try it out

Now, typing git <tab><tab> should list all of the various git commands (of which there are many). However, the really cool part is that it will also list your branches for you. Typing git checkout <tab><tab> within your Git repo will list all of the branches you have.

   1  jord@jordan /home/jord/webby(master) $ git checkout <tab><tab>
   2  HEAD    master

RSI, be gone!

Thanks

Bitfluent