VMBed

Moving your desktop to the cloud

2010-02-14T13:58:00.000-08:00

When I started VMBed three years ago I saw it as a tool for developers to try out applications in environments that they did not have immediate access too. Which would save them the effort in building and maintaining the matrix of software configurations necessary to get good test coverage. Over time I've noticed other use patterns. One that I did not expect is people looking to move their desktop to the cloud. Using a VMBed machine for this gives you the windows applications you are familiar with accessed via a remote desktop viewer. An alternate approach are services where a web browser essentially becomes a window to your desktop. While the applications run locally in your browser the data is stored remotely by the service. If you can get access to a browser you can access your data. One such service that impressed me is eyeOS. I am quite amazed by the usefulness and depth of their applications. I'm not sure I will be untethered from a physical machine anytime soon but if it happens I could see going with eyeOS.

Using rdp://host/ and vnc://host/ links

2009-05-28T16:48:00.000-07:00

These links appear in the booking panel once your VMBed rental has started. Without some configuration they won't work. Luckily someone has already figured it out for us Windows users. Make the changes as described by Electronic Samurai: "Run VNC and RDP from hyperlinks" and you will be good to go.

Remote Desktop Access for Windows XP Home Edition

2009-05-28T10:50:00.001-07:00

Windows XP home edition does not allow RDP access. So at VMBed we resort to using VNC to access these machines. VNC is fine but not optimal. I find that all VNC server offerings have some reliability or usability problems. Particularly with authentication, loss off interaction and connectivity. I do not mean in any way to disparage the fine work of the VNC server groups, it is understandably a tough undertaking to deal with all the Microsoft Windows versions and changing APIs.

There is a workaround but it entails converting the machine to XP Professional which somewhat defeats the VMBed purpose in that the machine you are testing in would no longer be a true XP Home machine. It is also not allowed by the Microsoft EULA. And so for now we are sticking with TightVNC which I have found to be the most reliable of the VNC servers out there.

Dynamic Rakefile Test Environments For VMBed

2009-04-01T20:04:00.000-07:00

I want to be able to run tests against various web servers (targets) and have them run on my local desktop or on various VMBed machines (environments). The following Rakefile will do just that for a NetBeans project. It makes a few assumptions:

Your tests are in a top level directory 'tests' (the NetBeans Ruby standard)
Your test cases are named tc_xxx.rb
Your test suites are named ts_xxx.rb
You have grabbed the files vmbed.rb and test.rb from the VMBed test API and dropped them into your test directory. See here.

You will need a .vmbed file to define your targets and environments. If you do not want to use VMBed environments that is ok, a default environment where the tests are executed locally will always be created.

Config file:

<config user="you" pass="yourpass">

  <!-- An already rented VMBed machine -->
  <environment name="field" type="vmbed" args='-n "field - 17"' />
  <!-- On demand renting, released only if the test passes -->
  <environment name="ondemand" type="vmbed" args="--noconfirm --release=success" />

  <target name="google UK"    args="--url=http://google.co.uk" />
  <target name="google main"  args="--url=http://google.com" />

</config>

Rakefile:

# Rakefile which creates test targets for NetBeans Rake task runner that
# get handled by the NetBeans Ruby test results viewer.

# Tasks are extrapolated to run against a configured set of targets and
# environments. These are defined in a ~/.vmbed config file.

# vmbed.rb and test.rb should be dropped into your test scripts dir
# (see http://vmbed.com/demo/code-examples/api-latest.tgz)
$LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__)) + "/test"

require 'rubygems'
require 'rake'
require 'vmbed'

# Handle running under NetBeans.
ruby_opts = ""
if ENV['NB_TEST_RUNNER']
  ruby_opts = "-r\"#{ENV['NB_TEST_RUNNER']}\""
end

# Load test targets (configurations) and test environments from the
# VMBed configuration file.
config = VMBed.load_config()
targets = []
(config/:target).each do |target|
  raise "target without a name" if !target["name"] || target["name"].empty?
  target["args"] = "" unless target["args"]
  targets.push target
end
if targets.length == 0
  # With no targets configured we can assume the tests will run
  # fine with no arguments.
  targets.push({ "name" => "noargs", "args" => "" })
end
environments = []
(config/:environment).each do |environment|
  raise "environment without a name" if !environment["name"] || environment["name"].empty?
  raise "environment without a type (should be local or vmbed)" if !environment["type"] || environment["type"].empty?
  environments.push environment
end
unless environments.find { |e| e["type"] == "local" }
  # Always include a localhost environment
  environments.unshift({ "name" => "localhost", "type" => "local" })
end

# Build test targets for each environment, configuration and file

environments.each do |environment|
  targets.each do |target|

    all_test_cases = []
    all_test_suites = []

    FileList['test/*.rb'].each do |t|
      if t =~ /t._/
        testfile = File.basename(t)
        taskname = testfile.sub('.rb', '')
        taskdesc = taskname
        taskname += "-" + environment["name"]
        taskname += "-" + target["name"]
        taskname.gsub!(' ', '_')
        taskdesc += ", " + environment["name"]
        taskdesc += ", " + target["name"]

        # Defines the task
        desc "Test #{taskdesc}"
        sym = "test:#{taskname}".intern
        task sym do
          Dir.chdir "test" do
            if environment["type"] == "local"
              ruby "#{ruby_opts} #{testfile} -- #{target['args']}"
            elsif environment["type"] == "vmbed"
              ruby "test.rb " + environment["args"] + " #{testfile} -- -- " + target["args"]
            else
              raise "Unsupported environment type #{environment['type']}"
            end
          end
        end
      end
      if t =~ /tc_/
        # Test cases by our convention start with tc_
        all_test_cases.push sym
      elsif t =~ /ts_/
        # Test suites with ts_
        all_test_suites.push sym
      else
        # NOP: test class or script
      end
    end

    # Define tasks for all the cases and suites defined for this
    # target and environment.
    taskname = "All_Cases-#{environment['name']}-#{target['name']}".gsub(' ', '_')
    taskdesc = "All Cases, #{environment['name']}, #{target['name']}"
    desc taskdesc
    task "test:#{taskname}".intern => all_test_cases

    if all_test_suites.length != 0
      taskname = "All_Suites-#{environment['name']}-#{target['name']}".gsub(' ', '_')
      taskdesc = "All Suites, #{environment['name']}, #{target['name']}"
      desc taskdesc
      task "test:#{taskname}".intern => all_test_suites
    end
  end
end

Rakefile test targets for NetBeans

2009-03-26T16:29:00.000-07:00

The following Rakefile will dynamically create test targets based on the contents of a projects test directory. I find this useful for NetBeans IDE integration. The rake task names are such that the test results are handled by the NetBeans Ruby test runner. So they are nicely formatted and allow you to jump to any failure locations quickly.

require 'rubygems'
require 'rake'

# Handle running under NetBeans.
test_runner = ENV['NB_TEST_RUNNER']
opts = ""
if test_runner
  opts = "-r\"#{test_runner}\""
end

all_test_cases = []
all_test_suites = []

FileList['test/*.rb'].each do |t|
  taskname = File.basename(t).sub!('.rb', '')
  desc "Test #{taskname}"
  sym = "test:#{taskname}".intern
  task sym do
    ruby "#{opts} #{t}"
  end
  # Test cases by convention start with tc_
  if t =~ /tc_/
    all_test_cases.push sym
  elsif t =~ /ts_/
    all_test_suites.push sym
  else
    raise "#{t} not a test nor a suite"
  end
end

desc "Run all test cases"
task :test => all_test_cases

desc "Run all test suites"
task "test:suites".intern => all_test_suites

Watir tests under NetBeans

2009-03-24T18:36:00.000-07:00

Background

This post covers writing a Watir web page test in a NetBeans IDE in preparation for running the test remotely using a VMBed machine. The test will accept a single --url parameter to simulate how you might configure NetBeans to run against a development, staging or production website. In this case the test will connect to different Googles, search for VMBed and expect the VMBed welcome page.

Install the latest Ruby and Watir.

Use the links above to get the latest Ruby and Watir. Note: Watir does not run under the JRuby that comes bundled with NetBeans as of Mar/25/2009.

Install NetBeans with Ruby support.

Create a test project.

NetBeans -> File -> New Project -> Ruby Application

Call it "Search"
Uncheck 'Create Main File'
Select your installed Ruby for 'Ruby Platform' e.g. "Ruby 1.8.6-p111"
Finish

Create a test script.

In the new "Search" project right click on "Test Files"
Select New -> Unit Test
Change the class name to "Search"
Finish

This will have created a ruby test file called "search.rb". NetBeans gives us a nice template and we can add to that to create something like:

# VMBed Search Test

$:.unshift File.join(File.dirname(__FILE__),'..','lib')

require 'test/unit'
require 'watir'

class VMBedTest < Test::Unit::TestCase
def test_vmbed_in_results
 br = Watir::Browser.new
 br.goto("http://google.com/")
 br.text_field(:name, "q").set "vmbed"
 br.button(:name, "btnG").click
 assert(br.text.include?("Machines when you want them"), "VMBed appears in the results")
 br.close
end
end

Run The Test

From the top menu select Run -> Test Project OR Alt - F6

Parameterize The Test

We'll use the Ruby Gem "getoptlong" to help with command line argument parsing. The test becomes:

# VMBed Search Test

$:.unshift File.join(File.dirname(__FILE__),'..','lib')

require 'test/unit'
require 'watir'
require 'getoptlong'

class Search < Test::Unit::TestCase

# Avoid parsing args for each and every test run
$args_parsed = false;

def setup
 unless (true && $args_parsed)
   opts = GetoptLong.new(
     [ '--help',    '-h', GetoptLong::NO_ARGUMENT ],
     [ '--url',           GetoptLong::REQUIRED_ARGUMENT ]
   )

   opts.each do |opt, arg|
     case opt
     when '--url'
       $url = arg
     when '--help'
       puts "USAGE: $0 --url=http://..."
       exit 1
     end
   end
   raise "Missing required --url" if defined?($url) == nil
   $args_parsed = true
 end
end

def test_vmbed_in_results
 br = Watir::Browser.new
 br.goto($url)
 br.text_field(:name, "q").set "vmbed"
 br.button(:name, "btnG").click
 assert(br.text.include?("Machines when you want them"), "VMBed appears in the results")
 br.close
end
end

Running A Parameterized Test

With NetBeans 6.5 there are two approaches. Use the project context menu option "Run/Debug Rake Task (Alt-Shift-R)". Or select the menu option "Run -> Test Project (Alt-F6)". Both of these options have one significant problem. You cannot pass parameters with a space in them e.g. --name="fred bloggs". This is a limitation in Rakes test loader and cannot be worked around with escapes etc. Believe me I've tried. Lets repeat that for emphasis: Don't use spaces in your test parameters, it will ruin your day.

For Run/Debug Rake Task

Set 'Parameters' to

TESTOPTS=-- --url=http://google.com/

TESTOPTS=-- --url=http://google.co.co/uk/

to pick the target for your test.

For Test Project

This approach is more configurable. From the configuration drop down you can customize an environment and then switch to the environment you want when you want to test. For this example I created two, "google.com" and "google.co.uk". For the former I set 'Rake Arguments' to

-- TESTOPTS='-- --url=http://google.com/'

and in the later

-- TESTOPTS='-- --url=http://google.co.uk/'

The exact syntax is important.

Automated Watir install in an XP VMWare Virtual Machine

2008-09-16T16:35:00.000-07:00

On VMBed we pretty much want to automate everything. We particularly want to automate anything we have to do on one or more VMs. Ideally all our VMs are already setup with all the software we want but as time progresses we find ourselves having to go back and add missing pieces or upgrading existing pieces.

VMWare has the handy VIX API for automation so here is the Perl and CMD.EXE scripts that we use to install Watir under an XP VM.

#!/usr/bin/perl                                                                                                                                             
                                                                                                                                                            
# Install Ruby and then Watir on a running windows VM                                                                                                       
                                                                                                                                                            
use strict;                                                                                                                                                 
use VMware::Vix::Simple;                                                                                                                                    
use VMware::Vix::API::Constants;                                                                                                                            
                                                                                                                                                            
# Hardcoded parameters - you will need to change for your environment                                                                                       
                                                                                                                                                            
my $hostName = '1.2.3.4';                                                                                                                                   
my $vh_userName = 'vmware';                                                                                                                                 
my $vh_password = 'xxxxxx';                                                                                                                                 
my $vmx = '/var/lib/vmware/Virtual Machines/donleavy - 14/Windows XP Professional.vmx';                                                                     
my $vm_userName = 'admin';                                                                                                                                  
my $vm_password = 'xxxxxx';                                                                                                                                 
my $cmdScript = '/vmbed/packages/install.cmd';                                                                                                              
my $rubyRelease = '/vmbed/packages/ruby186-26.exe';                                                                                                         
my $rubyVer = '1-8-6';                                                                                                                                      
                                                                                                                                                            
# Connect to the VMs Host                                                                                                                                   
                                                                                                                                                            
my $err = VIX_OK;                                                                                                                                           
my $hostHandle = VIX_INVALID_HANDLE;                                                                                                                        
                                                                                                                                                            
($err, $hostHandle) = HostConnect(VIX_API_VERSION,                                                                                                          
                                  VIX_SERVICEPROVIDER_VMWARE_SERVER,                                                                                        
                                  $hostName,                                                                                                                
                                  0,                                                                                                                        
                                  $vh_userName,                                                                                                             
                                  $vh_password,                                                                                                             
                                  0,                                                                                                                        
                                  VIX_INVALID_HANDLE);                                                                                                      
                                                                                                                                                            
if ($err != VIX_OK) {                                                                                                                                       
    die "HostConnect() failed: ".GetErrorText($err);                                                                                                        
}                                                                                                                                                           
                                                                                                                                                            
# Register                                                                                                                                                  
                                                                                                                                                            
$err = RegisterVM($hostHandle, $vmx);                                                                                                                       
                                                                                                                                                            
if ($err != VIX_OK) {                                                                                                                                       
    die "RegisterVM() failed: ".GetErrorText($err);                                                                                                         
}                                                                                                                                                           
                                                                                                                                                            
# Connect and login      

($err, my $vm) = VMOpen($hostHandle, $vmx);                                                                                                                  
if ($err != VIX_OK) {                                                                                                                                        
    die "VMOpen() failed: ".GetErrorText($err);                                                                                                              
}                                                                                                                                                            
                                                                                                                                                             
$err = VMLoginInGuest($vm,                                                                                                                                   
                      $vm_userName,                                                                                                                          
                      $vm_password,                                                                                                                          
                      0);                                                                                                                                    
if ($err != VIX_OK) {                                                                                                                                        
    die "VMLoginInGuest() failed: ".GetErrorText($err);                                                                                                      
}                                                                                                                                                            
                                                                                                                                                             
# Create working dirs on the VM                                                                                                                              
                                                                                                                                                             
my $root = 'C:\vmbed';                                                                                                                                       
my @dependent_dirs =                                                                                                                                         
  (                                                                                                                                                          
   $root,                                                                                                                                                    
   $root.'\packages',                                                                                                                                        
   $root.'\results',                                                                                                                                         
  );                                                                                                                                                         
                                                                                                                                                             
foreach my $dep (@dependent_dirs) {                                                                                                                          
    # (VIX API for server 1.0 does not support the VMDirectory commands)                                                                                     
    $err = VMRunProgramInGuest($vm, 'CMD.EXE', "/C MKDIR $dep", 0, VIX_INVALID_HANDLE);                                                                      
    die "VMRunProgramInGuest() failed: ".GetErrorText($err) if $err != VIX_OK;                                                                               
    sleep 2; # (VMRunProgramInGuest() seems to return before the mkdir is done)                                                                              
}                                                                                                                                                            
                                                                                                                                                             
# Copy over the packages as needed                                                                                                                           
                                                                                                                                                             
print "Copying Ruby release...\n";                                                                                                                           
$err = VMCopyFileFromHostToGuest($vm, $rubyRelease, $root.'\packages\ruby-'.$rubyVer.'.exe', 0, VIX_INVALID_HANDLE);                                         
die "VMCopyFileFromHostToGuest() failed: ".GetErrorText($err) if $err != VIX_OK;                                                                             
                                                                                                                                                             
my $remInstall = $root.'\packages\install.cmd';                                                                                                              
$err = VMCopyFileFromHostToGuest($vm, $cmdScript, $remInstall, 0, VIX_INVALID_HANDLE);                                                                       
die "VMCopyFileFromHostToGuest() failed: ".GetErrorText($err) if $err != VIX_OK;                                                                             
                                                                                                                                                             
# Run the cmd.exe install script - executed via CALL to block until it has completed                                                                         
                                                                                                                                                             
print "Installing Ruby & Watir...\n";                                                                                                                        
                                                                                                                                                             
my $remResults = $root.'\results\install.res';                                                                                                               
$err = VMRunProgramInGuest($vm, "CMD.EXE", '/C CALL '.$remInstall.' > '.$remResults, 0, VIX_INVALID_HANDLE);                                                 
die "VMRunProgramInGuest() failed: ".GetErrorText($err) if $err != VIX_OK;                                                                                   
                                                                                                                                                             
# Check the outcome.                                                                                                                                         
                                                                                                                                                             
my $locResults = "/tmp/install.res";                                                                                                                         
$err = VMCopyFileFromGuestToHost($vm, $remResults, $locResults, 0, VIX_INVALID_HANDLE);                                                                      
die "VMCopyFileFromGuestToHost() failed: ".GetErrorText($err) if $err != VIX_OK;                                                                             
                                                                                                                                                             
my $results = `cat $locResults`;                                                                                                                             
                                                                                                                                                             
if ($results !~ /Watir Stack Installed OK/) {                                                                                                                
    print $results;                                                                                                                                          
    die "Install failed";                                                                                                                                    
}                                                                                                                                                            
                                                                                                                                                             
print "Done.\n";                                                                                                                                             
                                                                                                                                                             
exit 0;

Still here?! The following is the install.cmd batch file to do the actual work:

@echo off                                                                                                                                                    
                                                                                                                                                             
echo %time%                                                                                                                                                  
                                                                                                                                                             
REM Automate the install of Ruby and then Watir                                                                                                              
                                                                                                                                                             
SET rubyDest=C:\ruby                                                                                                                                         
SET rubyRelease=C:\vmbed\packages\ruby-1-8-6.exe                                                                                                             
                                                                                                                                                             
REM try to remove any existing ruby install                                                                                                                  
                                                                                                                                                             
IF EXIST "%rubyDest%" (                                                                                                                                      
    echo %time% Removing previous install                                                                                                                    
    %rubyDest%\uninstall.exe /S                                                                                                                              
)                                                                                                                                                            
                                                                                                                                                             
REM wait for the uninstall to complete                                                                                                                       
                                                                                                                                                             
set count=1                                                                                                                                                  
set limit=1111111111                                                                                                                                         
                                                                                                                                                             
:_uninst_ruby_loop                                                                                                                                           
if EXIST "%rubyDest%" (                                                                                                                                      
    echo %time% Removing                                                                                                                                     
    ping 127.0.0.1 -n 4 -w 1000 > nul                                                                                                                        
    set count=%count%1                                                                                                                                       
    IF NOT [%count%]==[%limit%] goto _uninst_ruby_loop                                                                                                       
)                                                                                                                                                            
                                                                                                                                                             
IF EXIST "%rubyDest%" (                                                                                                                                      
    echo %time% Failed to remove Ruby                                                                                                                        
    goto :EOF                                                                                                                                                
)                                                                                                                                                            
                                                                                                                                                             
REM install ruby                                                                                                                                             
                                                                                                                                                             
echo %time% Installing Ruby                                                                                                                                  
%rubyRelease% /S                                                                                                                                             
                                                                                                                                                             
REM Check for install completion - the install blocks the script until                                                                                       
REM it completes unlike the uninstall.                                                                                                                       
                                                                                                                                                             
REM (the uninstaller is the last file to arrive)                                                                                                             
set rubyCheck=%rubyDest%\uninstall.exe                                                                                                                       
                                                                                                                                                             
IF NOT EXIST "%rubyCheck%" (                                                                                                                                 
    echo %time% Failed to install Ruby                                                                                                                       
    goto :EOF                                                                                                                                                
)                                                                                                                                                            
                                                                                                                                                             
echo %time% Ruby Installed                                                                                                                                   
                                                                                                                                                             
REM install watir                                                                                                                                            
                                                                                                                                                             
echo %time% Updating Gem                                                                                                                                     
cd C:\ruby\bin                                                                                                                                               
call gem.bat update --system                                                                                                                                 
echo %time% Installing Watir                                                                                                                                 
call gem.bat install watir                                                                                                                                   
echo %time% Watir Stack Installed OK

Now that you have Ruby installed you should not have to do any CMD.EXE scripting again. Yay!

VHD to VMDK conversion for VMWare Server 1.0.4

2008-07-22T16:44:00.000-07:00

It would be real nice to give people access to Microsofts trial VHD format machines at vmbed. And as I'm not planning on running Windows Server anytime soon I'll need to convert to VMDK format. Various blogs [1] tout WinImage as being the way to go.

An account is required to download one of the trial VHDs. (I had to use IE to complete the registration process *sigh*).
Pick a trial VHD. I decided to go with "Microsoft Windows Vista 30-Day Eval VHD". However this presented me with 18 file parts to download! Not exactly a compelling trial.
After downloading all the parts run the .exe this should extract to a .vhd file in the same directory. You'll need a large amount of free disk space for all this, 5GB for the .vhd and 5GB for the .vmdk.
Get a copy of winimage. http://winimage.com/
Start winimage.
Select Disk --> Convert Virtual Hard Disk Image
Select Create Dynamically Expanding Virtual Hard Disk
Click OK
Save As vista.vmdk
Wait a while...
Copy the vmdk file to the machine running vmware server.
Run VMWare Server Console and connect to the server.
Create a new virtual machine.
In the wizard choose "Custom configuration".
Choose other options as you see fit.
When prompted to "Select a Disk" choose "Use an existing virtual disk".
Browse to the vmdk file.
Click Finish.
Start the new VM and voila!

Trying out Amazon EC2

2008-07-17T12:36:00.000-07:00

I am intrigued by Amazons Compute Cloud. So I thought I'd try it out. To see if I could get a machine up and running with an end user desktop accessible via VNC in a few hours.

EC2 has some parallels with what I'm doing with VMBed. But it is more developer oriented and Linux only as far as I can tell.

Setup

I'm working on my laptop: XP with cygwin.

Read over the getting started guide.
Sign up to AWS, Storage and EC2.
Install JRE on your machine. http://java.sun.com/j2se/1.5.0/
Add some environment variables.

I ended up with the following additions to my ~/.bashrc:

export EC2_PRIVATE_KEY=~/.ec2/pk-XXXXXXXXXXXXXX.pem
export EC2_CERT=~/.ec2/cert-XXXXXXXXXXXXXX.pem
export JAVA_HOME=/cygdrive/c/Program\ Files/Java/jre1.5.0_16
export EC2_HOME=/home/gavin/work/ec2/ec2-api-tools-1.3-19403
export PATH=$PATH:$EC2_HOME/bin:$JAVA_HOME/bin

Finding a suitable machine

I went with a base ubuntu "Ubuntu 8.04 LTS Hardy" ami-26bc584f from alestic.

For this machine I needed a key for root access once the system starts.

$ ec2-add-keypair gsg-keypair > ~/.ssh/id_rsa-gsg-keypair && chmod 0600 ~/.ssh/id_rsa-gsg-keypair

To start it:

$ ec2-run-instances ami-26bc584f -k gsg-keypair
RESERVATION r-158d437c 082676351450 default
INSTANCE i-a38b59ca ami-26bc584f pending gsg-keypair 0 m1.small 2008-07-18T02:14:51+0000 us-east-1c aki-a71cf9ce ari-a51cf9cc

The output shows the instance id (i-a38b59ca) required for future operations.

To allow ping, ssh and vnc on port 5900:

$ ec2-authorize default -P icmp
$ ec2-authorize default -P tcp -p 22
$ ec2-authorize default -P tcp -p 5900

Login with:

$ ssh -i ~/.ssh/id_rsa-gsg-keypair root@ec2-75-101-207-240.compute-1.amazonaws.com

Run tasksel and select Ubuntu Desktop. This will take quite some time to complete with no initial status indication for the first few minutes.

Then install tightvncserver:

$ apt-get install tightvncserver

Create a user for the desktop:

$ apt-get install user-setup
$ user-setup

As the new user you should now be able to run tightvncserver:

$ su - newuser
newuser$ tightvncserver :0

Enter a password for your server and then connect from your desktop machine using your favorite VNC client (e.g. tightvnc) and the IP of the server.

When you connect there is no gnome-desktop but there should be a terminal window. You can use gnome-session to start gnome. (This worked for me with lots of errors but at this point I'd gotten as far as I wanted and felt no need to perfect the environment.)

Cleanup

You had better stop what you started or Amazon will continue to charge you:

$ ec2-describe-instances
RESERVATION r-158d437c 082676351450 default
INSTANCE i-a38b59ca ami-26bc584f ec2-75-101-207-240.compute-1.amazonaws.com ip-10-251-91-116.ec2.internal running gsg-keypair 0 m1.small 2008-07-18T02:14:51+0000 us-east-1c aki-a71cf9ce ari-a51cf9cc
$ ec2-terminate-instances i-a38b59ca
INSTANCE i-a38b59ca running shutting-down