MongoDB encourages you to embed documents for contains type of relations rather than creating relations between different collections. If you want to know more about embedding versus linking I encourage you to read the MongoDB documentation on schema design.

When you use Mongoid and add uniqueness validations on an embedded document you’ll soon discover that these validations only apply to the scope of the parent document (as described in the validations documentation). In many cases that’s exactly what you want, however there may be scenarios where you want a field in an embedded document to be unique across the entire collection. In this article I’ll show you how that can be done.

Lets get started with an example:

1
2
3
4
5
6
7
8
9
10
11

class Order
  include Mongoid::Document
  embeds_many :order_lines
end

class OrderLine
  include Mongoid::Document
  embedded_in :order
  field :article, type: String
  field :reference, type: String
end

The example is an order that has many order lines, where each order line has an article and a reference. Let’s say for the purpose of example that we want the reference on the order line to be unique across the entire order collection. The first thing to do to ensure the integrity of your collection is to add a unique index on the collection, you can define one on the Order model like so:

1
2
3
4
5

class Order
  include Mongoid::Document
  embeds_many :order_lines
  index "order_lines.reference", unique: true
end

Note that you need to create the indexes in order to enforce them (see the Mongoid documentation on indexes).

While the index ensures the integrity of your database you you may get some unexpected behavior:

1
2
3
4
5
6
7
8
9
10

Loading development environment (Rails 3.2.2)
[1] pry(main)> order = Order.create!(order_lines: [{article: "Tea", reference: "ref1"}])
=> #<Order _id: 4f5c7ae7d9fb2405e5000001, _type: nil>
[2] pry(main)> Order.count
=> 1
[3] pry(main)> order = Order.create!(order_lines: [{article: "Coffee", reference: "ref1"}])
=> #<Order _id: 4f5c7af8d9fb2405e5000003, _type: nil>
[4] pry(main)> Order.count
=> 1
[5] pry(main)>

The index protects the integrity of your collection, but it doesn’t tell you that it fails to save. You can force Mongoid to immediately save to the collection like so:

1
2
3

[5] pry(main)> order = Order.safely.create(order_lines: [{article: "Coffee", reference: "ref1"}])
Mongo::OperationFailure: 11000: E11000 duplicate key error index: orders_development.orders.$order_lines.reference_1  dup key: { : "ref1" }
from /home/mkremer/local/ruby-1.9.3-p125/lib/ruby/gems/1.9.1/gems/mongo-1.6.0/lib/mongo/networking.rb:95:in `send_message_with_safe_check'

While that works it isn’t performance or user friendly, ideally you’d want to use validations so you can define a friendlier error message and can use the standard save mechanism instead of forcing a direct write. This is actually pretty easy:

1
2
3
4
5
6
7
8
9
10

class OrderLine
  include Mongoid::Document
  embedded_in :order
  field :article, type: String
  field :reference, type: String

  validate do |order_line|
    order_line.errors.add :reference, 'must be unique' if Order.where(:id.ne => order_line.order.id, "order_lines.reference" => order_line.reference).count > 0
  end
end

And that behaves pretty much how you’d expect:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

Loading development environment (Rails 3.2.2)
[1] pry(main)> order = Order.new(order_lines: [{article: "Coffee", reference: "ref1"}])
=> #<Order _id: 4f5c7f2cd9fb24061f000001, _type: nil>
[2] pry(main)> order.valid?
=> false
[3] pry(main)> order.errors.messages
=> {:order_lines=>["is invalid"]}
[4] pry(main)> order.order_lines[0].valid?
=> false
[5] pry(main)> order.order_lines[0].errors.messages
=> {:reference=>["must be unique"]}
[6] pry(main)> order.order_lines[0].reference = "ref2"
=> "ref2"
[7] pry(main)> order.valid?
=> true
[8] pry(main)> order.order_lines[0].valid?
=> true
[9] pry(main)> order.save!
=> true
[10] pry(main)> Order.count
=> 2
[11] pry(main)>

That’s really all there is to it :)

• The website itself is now just static HTML, and because of this my server no longer needs to run PHP and MySQL and thus greatly decreasing the footprint of this blog.
• All of the blog entries and pages can be written in text files, edited with my favorite editor, and kept in version control make the whole lot much more portable.

You can follow along with the client examples from Yesterday’s article against the Rails implementation instead of (or in addition to) the Sinatra implementation. You can start the Rails project on port 9292 to use the clients unmodified like so: “rails s -p 9292”.

Have fun :)

The SOAP service that I’ve written for this article is the EchoService, it has two operations: Echo and ReverseEcho. Unsurprisingly Echo returns the message the client sent and ReverseEcho returns it reversed. The source is available on GitHub at https://github.com/mkremer/echo_service, go ahead and clone the repository or download the source from there. Have a look around to see how it works and follow the README to get it up and running.

In this article all my examples will show http://localhost:9292/echo_service.wsdl as the WSDL URL, if you’re not running the EchoService locally (but on a server or in a VM) then you have to change the URL appropriately to try the examples. Additionally the WSDL contains the URL to the endpoint, and that URL will in most cases be used automatically. You can set the environmental variable BASE_URL (in more detail described in the EchoService README) to alter the endpoint URL shown in the WSDL.

soapUI

If you have a WSDL for a SOAP service and want to play around with it without having to write code there are some tools that you can use to do just that, a tool I often use for this purpose is soapUI (in this example I used the free open source version).

Once you have the EchoService up and running and you’ve got soapUI installed and started up click on the “File menu” and click on the first option (labelled “New soapUI Project”), this will bring up the following popup:

Enter the details as I have above. Once you click the “OK” it adds a new project named “Echo”. You’ll see the EchoBinding (which represents the service that is specified in the WSDL) and the possible operations. If you expand any of the operations you’ll see that a test request named “Request 1” has been added to each of them. Double clicking on a request will open a new window (within soapUI) in which you can edit the request before sending it by hitting the green play button (in the top left of the request window), the resulting response will be shown in the right split. Below is a screenshot of what soapUI looks like after doing all of the above:

soapUI is a really awesome tool, there’s a lot more to it than I’ve shown here (you can create test suites, use it to run mocked web services based on WSDL files, and more). Its a tool worthwhile adding to your arsenal.

PHP

PHP 5 has SOAP support built in (if PHP has been compiled with –enable-soap), the documentation is available online here: http://www.php.net/manual/en/book.soap.php. Its extremely simple to consume SOAP services using PHP, below is a very brief example:

1
2
3
4
5
6

<?php
  $wsdl = "http://localhost:9292/echo_service.wsdl";
  $client = new SoapClient($wsdl);
  $response = $client->Echo(array("Message" => "Hello from PHP"));
  echo "EchoService responded to Echo: " . $response->Message . "\n";
?>

The above PHP script will output: “EchoService responded to Echo: Hello from PHP”.

If you want a more complete example implementation that includes explanatory comments and basic error handling then you can checkout my project on GitHub: https://github.com/mkremer/echo_service_client_php.

Java

To generate the code required to consume a SOAP service in Java I used the Apache CXF framework. The generated code uses the standard Java API and thus doesn’t have CXF as a runtime dependency. To get it setup up you need to do the following:

• Install the Java JDK (if you haven’t already – I am using JDK 7), and ensure that the JAVA_HOME environmental variable is set to the path where your JDK is installed
• Download Apache CXF (for this example I used 2.4.3) and unpack it somewhere appropriate
• Add /path/to/apache-cxf/bin to your PATH so you can easily use the CXF command line tools without having to spell out the entire path every time

Once that’s all done open a shell, create a new directory, go into it and enter the following command: wsdl2java -client http://localhost:9292/echo_service.wsdl. If all goes well the command gives no output, but it does create a new directory structure with Java files inside:

1
2
3
4
5
6
7
8
9
10
11
12
13

$ tree
.
└── net
    └── without_brains
        ├── echo
        │   ├── EchoMessageType.java
        │   ├── ObjectFactory.java
        │   └── package-info.java
        └── echo_service
            ├── EchoPortType_EchoPort_Client.java
            ├── EchoPortType.java
            └── EchoService.java  
4 directories, 6 files

The directory structure is a copy of the namespace URL, but in reverse (translating the namespace URI to a Java package name). If you’re using a Java IDE you can copy this entire directory structure into your Java project’s source directory to make use of the generated code.

net/without_brains/echo_service/EchoPortType_EchoPort_Client.java is an example client generated by CXF that calls each of the operations. Note that it won’t work as is, as it sets the Message parameter to null which isn’t allowed. You easily modify it to work properly or use it as a starting point to write your own implementation.

A simple example of using the code generated by CXF:

1
2
3
4
5
6
7
8
9
10
11
12

import net.without_brains.echo_service.*;
import net.without_brains.echo.*;
public class Echo {
  public static void main( String[] args ) throws Exception {
    EchoService client = new EchoService();
    EchoPortType echo = client.getEchoPort();
    EchoMessageType request = new EchoMessageType();
    request.setMessage("Hello from Java");
    EchoMessageType response = echo.echo(request);
    System.out.println("EchoService responded to Echo: " + response.getMessage());
  }
}

If you want an example implementation that includes explanatory comments and basic error handling then you can checkout my project on GitHub: https://github.com/mkremer/echo_service_client_java.

.NET

Consuming SOAP services with .NET is easy as pie through Visual Studio. If you don’t have a license for Visual Studio you can download one of the free versions (called Express editions) here: http://www.microsoft.com/visualstudio/en-us/products/2010-editions/express (I used the Express edition of Visual Studo C# in this example).

Once you have started up Visual Studio go ahead and create a new project, in this example I created a console application:

Right click on the “References” entry in the “Solution Explorer” (which is on the right side of the screen) and click on the option “Add Service Reference”. You’ll get a popup like the one shown below:

Enter the details as I have above and click on the OK button.

To make use of EchoService add some code like shown below:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace EchoClient
{
    class Program
    {
        static void Main(string[] args)
        {
            Echo.EchoPortTypeClient client = new Echo.EchoPortTypeClient();
            Echo.EchoMessageType request = new Echo.EchoMessageType();
            request.Message = "Hello from C#";
            Echo.EchoMessageType response = client.Echo(request);
            Console.WriteLine("EchoService responsed to Echo: " + response.Message);
        }
    }
}

Running the above code (you can use the shortcut CTRL+F5) should open a console window with the output: “EchoService responded to Echo: Hello from C#”.

If you want an example implementation that includes explanatory comments and basic error handling then you can checkout my projects on GitHub: https://github.com/mkremer/echo_service_client_csharp for C# and https://github.com/mkremer/echo_service_client_vb for Visual Basic.

Ruby (using Savon)

Consuming SOAP services in Ruby is pretty easy if you use Savon, here’s an example snippet:

1
2
3
4
5
6
7
8
9

client = Savon::Client.new("http://localhost:9292/echo_service.wsdl")
response = client.request :echo, "EchoRequest", :body => { "Message" => "Hello from Ruby" } do
  # The EchoService has its messages in a different namespace than the
  # targetNamespace of the WSDL, specify it here to have the request
  # rendered properly
  soap.namespaces["xmlns:echo"] = "http://www.without-brains.net/echo"
end
data = response.to_array(:echo_response).first
puts "EchoService responded to Echo: #{data[:message]}"

Like I have done for the other programming languages I have created an example implementation with explanatory comments and basic error handling that you can checkout on GitHub: https://github.com/mkremer/echo_service_client_ruby.

If you want an introduction to using Savon you can also watch the Railscast on Savon.

A few more notes on consuming SOAP services

In all of the examples in this article I’ve been pointing to the URL of the WSDL, its often desirable to download a copy of the WSDL (and files that it includes such as XML schema files) to include in your code base and use that instead. There are a two advantages to doing this:

• You can modify the URL of the endpoint in your local copy to match the endpoint that you’re going to be talking to, negating the need to write code to do that (this can be desirable for any number of reasons).
• Some of the above examples use the WSDL at runtime, if the WSDL becomes unavailable or if it gets changed it can cause your system to break down (using a local copy will prevent those types of crashes and reduces the amount of error handling required)

 If you’re still reading…

You’ve reached the end of my article, thank you for reading it! I’ve spent a considerable amount of time writing this up and writing the example implementations, I hope you’ve enjoyed it all and that it has been of use to you. If you have any feedback then please use the comments system.

Good luck with your SOAP endeavors!

Each Ruby that is installed by RVM has a @global gemset, no matter what gemset you’re using the gems of the @global gemset are always available. To install a gem into the @global gemset switch to it like you would to any other gemset (per example: rvm use 1.9.2@global) and install the gem using the gem install command. If you now create a new gemset (per example: rvm use 1.9.2@mynewgemset –create) and then type “gem list –local” you’ll see the list of gems that you installed in the @global gemset.

If you have a set of gems that you would like to have installed in the @global gemset for every new Ruby that you install using RVM you can edit the file ~/.rvm/gemsets/global.gems and add the names of the gems (each on a new line) that you want installed everywhere. If desired you can define the version of the gem to be installed by adding the -v flag as you would to the gem command.

If you want to know more about RVM then check out the RVM website at http://rvm.beginrescueend.com, its filled with lots of useful documentation :)

To see the result you’ll have to restart lightdm or by logging out. Restarting lightdm means restarting your entire X windows environment (which more or less has the same effect as logging out). To restart lightdm open a terminal and type “sudo restart lightdm”.

If you want to toy with your lightdm configuration and are comfortable on the terminal you can use another screen by hitting CTRL+ALT+F1 (through F6) to access a separate terminal session that isn’t running in X windows. You can go back to your X session with CTRL+ALT+F7 (restarting lightdm will force you back to it immediately).

I found that not all settings in the configuration files had impact on the actual result (per example I was unable to hide users in the login screen with /etc/lightdm/users.conf). Also I could not find a way to remove the grid of dots that overlays the image in the login screen (comments I found online suggest its hard coded into lightdm or unity-greeter).

As a final note: If you want to disable guest users from logging in from the login screen you can set the  allow-guest property to false in /etc/lightdm/lightdm.conf

Inside Foreman makes use of Process#fork to launch its processes and unfortunately that isn’t supported by JRuby. If you’re using RVM to manage your Ruby installations you can use its wrapper functionality to create a wrapper for Foreman to run it using MRI (or another Ruby implementation that supports Process#fork). Here’s how you do it:

Assuming you’ve installed Ruby 1.9.2 using RVM and have installed the Foreman gem inside a gemset named “dev”. Type the following command to create a shortcut to run Foreman with 1.9.2 regardless of the Ruby you’ve activated using RVM: rvm wrapper 1.9.2@dev mri foreman

You’ll now be able to type mri_foreman to start Foreman using Ruby 1.9.2. Simply create a Procfile in your JRuby project and use “mri_foreman” where you’de use “foreman” and you’re good. For more information on how “rvm wrapper” works type “rvm help wrapper”.

If RVM isn’t your cup of tea and you really need something that works with JRuby directly you can use Guard with Guard::Process (which makes use of the spoon gem to launch commands which works in JRuby and CRuby) to start and run multiple processes. Guard’s output isn’t nearly as readable as Foreman’s though (it doesn’t indicate which output came from which Guard with color coding), and controlling which how many of each process to start is strictly controlled through the Guardfile (whereas with Foreman you can influence this with the “foreman start” command using the -c flag), but it works!

You can define your own types based on file extensions using –type- set=name=.ext1,.ext2 and then tell ack to include or exclude those as well. You can configure the defaults for ack through a preference file (.ackrc) and/or through environmental variables (ACK_OPTIONS, ACK_PAGER, etc.).

Below is a sample .ackrc file that adds haml and sass file types and tells ack to use less in raw mode to page the results (this allows ack’s friendly colored output in less).

1
2
3
4
5

# Use less to page results
--pager=less -r
# Add file types
--type-set=haml=.haml
--type-set=sass=.sass,.scss

Here’s a few example commands taking the above .ackrc into account:

1
2
3
4

# search only haml files
ack --haml 'my test string' 
# search all files that ack knows about except haml files
ack --no-haml 'my test string'

For more information take a look at ack’s help by running ack –help.

Besides being a DNS forwarder and DHCP server Dnsmasq also offers you the capability to force domains of your choosing to route to specific IP addresses through it’s configuration file. Simply adding a TLD (top level domain) in there will give you a limitless pool of host names to use that will all go to the specified IP address. Note though that if you override existing domains that your configuration will take precedence… so be very conscious of what you setup or you may end up being very confused.

To get started install the packages dnsmasq and resolvconf. resolvconf ensures that Dnsmasq works with your preexisting DNS settings (if you wouldn’t install this package then your system would essentially ignore Dnsmasq). Once both packages are installed you’ll want to edit Dnsmasq’s configuration file: /etc/dnsmasq.conf

To get setup find and edit the below settings:

• address=/dev/127.0.0.1
• interface=lo
• no-dhcp-interface=lo

Using the above settings on top of the default does the following things (in the same order as the list above):

• Setup the top level domain dev to route to localhost (like Pow sets up for Mac OS X does, so any host name that ends in .dev will be resolved to 127.0.0.1 aka localhost). If you want more (top level) domains to route to specific IP addresses you can simply add addiontal address=… lines.
• Tell Dnsmasq to only work with the loopback interface (the virtual localhost network card, this prevents other systems from querying your Dnsmasq instance for DNS information)
• Disable the DHCP service on the loopback interface (since that’s the only active network interface for Dnsmasq we’ve disabled the DHCP service alltogether).  

To make this all work properly you’ll have to reboot, once you have you can test your settings by accessing a terminal and using the nslookup command:

1
2
3
4
5
6
7
8
9
10
11
12
13

mkremer@devlin:~$ nslookup test.me.dev
Server:       127.0.0.1
Address:  127.0.0.1#53  
Name: test.me.dev
Address: 127.0.0.1  
mkremer@devlin:~$ nslookup www.without-brains.net
Server:       127.0.0.1
Address:  127.0.0.1#53  
Non-authoritative answer:
www.without-brains.net    canonical name = without-brains.net.
Name: without-brains.net
Address: 97.107.137.114  
mkremer@devlin:~$

As you can see in the above output nslookup queries the DNS server running on localhost, where test.me.dev returns 127.0.0.1 and without-brains.net returns the IP address of the server hosting this blog.

Learning how to use sed can save you the effort of having to write more complicated programs or scripts in whatever programming language you’re versed to extract information out of text files and output. While it may initially take you a little bit of time to get your head around it, you’ll most likely have a moment of enlightenment where you will wish you had known about sed before… I certainly had!

What makes sed so great then? It allows you to take text input, process it line by line and use the power of regular expressions to match text and transform it using the result of your regular expressions. In this article I’ll give you a simple example of how you can use sed, if you want to know more about sed after reading this article then there’s an excellent introduction and tutorial page here which I found invaluable. Note that I’m still quite new at using sed myself, so this example may not be the best example of how you should use sed… but it works.

Let’s say we’re dealing with an order entry program that processes files sent in from a remote system. Each of these files can contain multiple orders. For each file that the program processes it outputs a log file with the details of what it has done with the contents of the order file. The output would look something like this:

1
2
3
4
5
6
7
8

Start processing file ORDER-001.TXT at 2011-05-28T21:18:02
File has 5 order(s)
Created order 1
Created order 2
Created order 3
Created order 4
Created order 5
Finished processing at 2011-05-28T21:22:10

Now your customer comes along and asks you how long it takes you to process the order files. Using the command line with a combination of grep and sed you can get this information out of those log files and convert it into tabular format, allowing you easily import the data for the customer into a spreadsheet (which they often really like). Here’s how you could go about that:

1
2
3
4

cat order-001.log | grep -E '^(Start|File has|Finished).*$' | sed -e 'N' -e
'N' -e 's/Start.*file \([^\s]*\) at \([0-9]\{4\}-[0-9]\{2\}-[0-9]\{2\}\)T\([0-
9]\{1,2\}:[0-9]\{2\}:[0-9]\{2\}\).*File has \([0-9]*\).*\([0-9]\{4\}-[0-9]\{2\
}-[0-9]\{2\}\)T\([0-9]\{1,2\}:[0-9]\{2\}:[0-9]\{2\}\)/\1 \2 \3 \4 \5 \6/'

That may look a little frightening, but it really isn’t that complicated. Let me break it down for you:

The command starts with the cat command which simply streams the contents of the file to the stdout, this is fed to grep through a *nix pipe. The grep command takes a regular expression to filter out all of the lines that I’m not interested in, the only lines left will be those starting with “Start”, “File has” and “Finished” (depending on the version of grep installed on your system the syntax may be different from what I used here). The resulting output is then fed to sed which I’ll explain in more detail.

The -e parameter is used to tell sed to execute a command, in my example I am passing the following commands to sed:

1
2
3

  1. N
  2. N
  3. s/Start.*file \([^\s]*\) at \([0-9]\{4\}-[0-9]\{2\}-[0-9]\{2\}\)T\([0-9]\{1,2\}:[0-9]\{2\}:[0-9]\{2\}\).*File has \([0-9]*\).*\([0-9]\{4\}-[0-9]\{2\}-[0-9]\{2\}\)T\([0-9]\{1,2\}:[0-9]\{2\}:[0-9]\{2\}\)/\1 \2 \3 \4 \5 \6/

The N command tells sed to keep the current line it just got and append the next line it gets to it (it’s important to know that the newline character is preserved here). By giving the N command twice I’m combining my three lines for processing. In my example I am thus depending on my output always having those 3 lines in the proper sequence, you can probably not depend on such a thing in the real world so you’d have to do smarter processing to reliably get the data you want ;)

The third command (s) is the substitute command, it receives it’s parameters separated by / characters (other characters can be used as well, see the earlier mentioned tutorial link for more details on that). The first argument is the regular expression to match, the second argument is what to output. The regular expression may look a bit complex with all those \ characters in there, but those are just there to escape certain characters so they’re used in the regex rather than being treated as literals. The regex simply catches the 6 pieces of data that we’re interested in groups, the output simply outputs each of these groups after each other separated by a space.

This then results in the following output

1

ORDER-001.TXT 2011-05-28 21:18:02 5 2011-05-28 21:22:10

Instead of just processing one file, you can obviously process multiple files with cat (by using cat *.log or something of the sort) generating a large report with ease! Sed really is an awesome tool :)

Black screen on reboot

I installed Ubuntu on my Alienware m11x, which has two videocards. An Nvidia chipset (for gaming) and a simple integrated chipset (for saving power). When I installed the Nvidia drivers on my machine my screen stopped functioning after reboot. After some searching on Google I found this was because the Nvidia Linux drivers can’t cope with the graphics card switching functionality of the Alienware m11x. The solution was simple, change the setting in the laptop’s BIOS so that it always uses the Nvidia chipset.

About me settings were not saved

You can enter some basic information about yourself in the “About me” application. When I tried this I found that it wouldn’t save… turns out that was a known bug. A comment on that bug report explains what you can do to fix this problem, the short version is as follows:

• Open a terminal and type “rm -rf ~/.local/share/evolution/addressbook/*’
• Open Evolution (you will have to configure an e-mail account to get in)
• Open the “Contacts” section (this will create the system address book: ~/.local/share/evolution/system)

After doing so the “About me” app will work as it should :)

Empathy will not connect to Google Talk

After entering my account details for Google Talk in Empathy (the default IM client) it seemed to try to connect without success indefinitely. The fix for this solution is simple:

• Open the “Advanced” section in the chat account details
• Tick the “Encrypt required (TLS/SSL)” checkbox
• Set the “Server” (under Override server settings) to “talk.google.com”

There’s a separate command to run a VM in headless mode as described in the manual here. When you run Windows and use VBoxHeadless you’ll notice that it hogs your command prompt (and that the only way to get it back is to kill the VBoxHeadless session with CTRL+C) which gives you the same effect as before: useless open Windows. There is a ticket open on the Virtual Box bug tracker here, and the ticket contains a couple of interesting workarounds. In this article I’ll describe a number of ways that I found to solve this.

Using the start command to run VBoxHeadless

Instead of running VBoxHeadless directly you can run it like so: start /b VBoxHeadless -s nameofvm. The start command starts a new process with the given parameters, the /b option stars the process without opening a new window.

Note that running your VM in headless mode will enable VDRE (remote desktop) for your VM. If you don’t want this you can add -v off to the list of options to the VBoxHeadless command.

While this is a really easy way to run your VirtualBox VMs in headless mode (especially if you usually have a command prompt open anyway) it has a downside: if you close your command prompt the processes you started with start /b will get killed with  it. This makes this solution kind of brittle (imagine closing your command prompt by accident and then losing your SSH connections to all the VMs you started and losing the work therein… that’s no fun).

I found a possible solution to that downside here, where the suggestion was given to write a vbs script that starts a shell in which the VBoxHeadless command is started and then severs the connection between that shell and the place it’s been started from. With a bit of effort you could write a script that accepts the VM name as a parameter so you don’t need a script per VM.

Running your VirtualBox VM as Windows services

VBoxVmService is an open source tool that allows you to add VirtualBox VMs as services in Windows. To use it you need to install the extension pack though, which binds you to the PUEL license (which has restrictions you may not like). Assuming that you don’t have a problem with these limitations this is a really easy solution, you just put it in a folder of your choice and configure it through an INI file. It has a command line tool that you can use to install and uninstall the Windows service. Another great feature is that it will cleanly shut down your VMs if you shut down Windows.

The downsides for me are that you have to configure your VMs in an INI file, and that you can’t track state of your VMs in the VirtualBox GUI (which you can with the first solution).

If you want to start one or more VMs at runtime, and do not want to worry about them being shut down cleanly when you shut down Windows then this solution is the way to go.

Running VirtualBox with phpVirtualBox

phpVirtualBox is an open source web GUI that runs your VMs in headless mode. While it doesn’t meet my needs (you have to install a webserver and PHP to get it running, and that’s stuff I want to run in my VMs and not on my Windows installation) it is a really cool project and it’s ideal for headless machines that run VirtualBox to offer VMs.

I haven’t tried this myself, if you have I would love to see some comments on this article about your experiences.

What I’d like to have ideally…

Ideally I’d like to see an option in the VirtualBox GUI itself to start a machine in headless mode (there is a ticket open for it with low priority, it has been open for quite some time so I don’t expect that feature to be there soon).

In conclusion

While not ideal the first option is the best option for me right now.

I’m hoping to find some time to take a look and see if I can modify the VirtualBox UI to allow me to start VMs in headless mode from there, or create a separate tool to do so conveniently using one of the VirtualBox APIs.

Assuming that you have access to gcc and gmake it’s easy to install Vim in your home directory. For this article I’ll provide examples using bash, if you’re using another shell your command syntax and the preference files you need to edit will likely be a little different. To get started simply download the source from vim.org, uncompress it and go into the resulting directory and use the following commands:

• ./configure –prefix=/path/where/you/want/vim
• gmake
• gmake install

Once that is done simply modify $HOME/.profile to include /path/where/you/want/vim at the start of your $PATH so that your local install of Vim is used before the system version (if there is one). To immediately be able to use Vim (without having to do a fresh login to get your $PATH setup) you can enter the command “export PATH=/path/where/you/want/vim:$PATH” after which you can enter “vim” to start Vim :)

The main application that we develop on has shell components and web components, and the shell components require us to use xterm emulation. The xterm emulation on Solaris doesn’t provide colour support however, and when you start using Vim you’ll notice that you have grey tones only. If you don’t require xterm you can use sun-color instead (setting the $TERM to sun-color will enable that). If you do require xterm then the simplest way to resolve this is by taking the xterm definition from another machine that does support colours (per example from a Linux box), you can do so with the following steps:

• On the source machine for the terminal definition use the command “infocmp > xterm_def”.
• Save the file xterm_def on the Solaris machine and continue from there
• Create a directory in your home directory to hold the terminal definition: mkdir -p $HOME/local/lib/terminfo
• Edit your $HOME/.profile and add “TERMINFO=$HOME/local/lib/terminfo”, to continue without reloading your profile enter “export TERMINFO=$HOME/local/lib/terminfo”
• Use the command “tic xterm_def” in the directory where you saved xterm_def to import the terminal definition

Start Vim and should see colors :)

Now to dive into the subject of this article, one of the new features in Rails 3 that I really like is the use of UJS (Unobtrusive JavaScript) taking away all the inline Javascript that was generated by Rails inline within your HTML. UJS has many advantages over inline Javascript, the main advantages in my opinion being that Javascript is now no longer treated as a second class citizen, more easily managed (because it isn’t all over the place anymore) and that it makes it easier to build pages that work with and without Javascript.

For those of us that have been using the existing AJAX functionality in Rails 1 and Rails 2 it involves a bit of work. Helper methods such as link_to_remote and remote_form_for have been taken away, instead you now specify :remote => true as part of the options to the helpers that they were AJAX alternates for (such as link_to and form_for). Specifying the :remote => true option adds a custom attribute to the tag: data-remote=”true”. Javascript event observing is used to properly trigger the AJAX requests on click or submit (depending on which helper it’s being used on). If you take a look at the file public/javascripts/rails.js you’ll see how it works exactly (assuming that you understand Javascript and the Prototype framework).

The standard callbacks that used to exist as part of the remote functions are now gone too (you could pass in options such as :success, :failure, :before, :after, etc.), instead you will have to program them in Javascript. One of the upsides is that you can specify global behavior for all your AJAX requests by observing the “ajax:*” events (public/javascript/rails.js details which ones are fired). This can be incredibly useful per example when you want to show a spinner for your AJAX requests, you simply observe the “ajax:before” and “ajax:after” to show and hide the spinner in application.js (making this behavior available on all your pages instantly, very DRY!). You could even influence the behavior for each AJAX request with additional custom data attributes (per example the id of the spinner to show and hide).

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

if has('win16') || has('win32') || has('win64') || has('win95')
 " Windows specific settings
 " Backup and swap file directories
 set bdir=~/vimbackups
 set dir=~/Temp
 " Use PuTTY SSH programs (Must be installed separately)
 let g:netrw_scp_cmd = 'pscp.exe -q -batch -agent'
 let g:netrw_sftp_cmd= 'psftp.exe'
 " When using SCP ensure that you don't get prompting DOS windows
 let g:netrw_silent= 1
else
 " *nix specific settings
 " Backup and swap file directories
 set bdir=~/.vimbackups
 set dir=~/.vimtmp
endif

Happy Vimming!

With CTRL+V (while in normal mode) you can activate the visual block mode, by using the standard movement keys (h, j, k, l or the arrow keys). You can perform various operations on visual blocks (check the help with :help v), in this article I will describe how you can prepend or append text to a block.

After selecting your block you can press SHIFT+i to start inserting before every line of the block, after you type what you want to insert hit the ESC key to apply the insert to all the lines. The below images show you how this would work:

Visual mode active, selected a block:

Hit the ESC key to apply the insert:

To append instead you can press SHIFT+a instead of SHIFT+i, the mechanism is exactly the same:

Visual mode active, selected a block:

Append mode activated (using SHIFT+a) and typed a “”:

Hit the ESC key to apply the append:

As you can see in the above example white space is appended to Dog and Cat, because these words are shorter than Bird. If you don’t want that white space you can use CTRL+V $ instead of CTRL+V to activate visual mode:

Visual mode active, selected a block:

Append mode activated (using SHIFT+a) and typed a “”:

Hit ESC to apply the append:

As noted earlier in the article there are more thing that you can do with visual mode in vim, you can read about it in Vim’s help using “:help v”.

Happy Vimming!

• USB flash drive of the appropriate size (I used a 6GB drive)
• Windows Vista install DVD
• Computer that has Windows Vista installed, a DVD drive and has a free USB slot (for use with the USB flash drive)

Open the command prompt on the computer that is already running Windows Vista (cmd.exe) and start “diskpart” (Yes, Windows XP also has diskpart, however the version I had on my XP box didn’t allow me to make flash drives bootable). diskpart gives you it’s own command prompt, identify the flash drive by typing “list disk”. Once you have determined which disk is the flash drive type “select disk x”, where x is the number in the list returned by diskpart. Type the following commands:

• clean
• create partition primary
• select partition 1
• active
• format fs=fat32
• assign
• exit

The above commands will remove any existing partitions from the selected disk (which is why it is important that you are absolutely certain that you selected the correct disk, if you mess this up any data that was on the drive is gone!), create a new primary partition, make it bootable, format it as a FAT32 disk, assign it a drive letter, and then exit the diskpart program.

Open Windows explorer to identify what drive letter the USB flash drive now has. Insert the Windows Vista installation DVD in your DVD drive. Go back to the command prompt and type the following command: “xcopy x:*.* /s /e /f y:" (where x is the drive letter of your DVD drive and y is the drive letter of your USB flash drive). Once the xcopy command is complete your USB flash drive is ready!

Note: When installing Windows Vista on a computer with multiple hard drives Windows Vista will refuse to install on any other disk than the first (in my experience at least).

Click on any of the existing menus and then click on the “New Item” button:

Once you’ve filled out the above fields and have clicked on the “OK” button the option will be added to your menu. You can give the option an icon by clicking the icon on the top left of the dialog (this allows you to browse for a picture to use).

The screen that pops up should look like the one in the screenshot above. If you look through the existing shortcut keys you’ll see some useful defaults, such as <Control>+<Alt>+L to lock your screen. The keyboard shortcuts editor is user friendly, if you choose a combination that is already taken you will be warned like so:

One of the programs that I tend to use a lot is the terminal, there’s a shortcut defined to run the terminal but it has no shortcut key assigned to it by default as you can see in the screenshot below:

You can set the shortcut key by clicking on the row, which will change the text to “New shortcut…” and then press whichever key combination that you want to use, which in my case is <Control>+<Alt>+T:

Say we want to run Firefox with a shortcut key, I’ll fill in the screen like so:

After clicking the “Apply” button the action is added to the category “Custom Shortcuts”:

You can set shortcut keys to these new actions like standard ones. If you want to change the name of a custom shortcut key, simply click the name to get the dialog to change the name (which looks exactly like the add dialog, but with the current values pre-populated). For custom shortcuts the “Remove” button is enabled, which allows you to delete them (the default shortcuts can’t be removed). Note that custom shortcuts are removed without warning!