I’ve played around with VMware server a bit in the past, ever since they offered it up free of charge. Since they recently released 2.0 beta I figured I’d give that a try. The new beta has replaced the old admin app with a slick new web interface. Even taking control over a vm is moved into a java control within the web interface, the first time you connect in it downloads a small browser plugin, but from then on you can control everything right within the browser. Pretty Impressive.

Setup is pretty much the same, you walk through a little wizard that lets you configure the various hardware (processor, ram, network, hard drive, etc) once you’ve built a shell vm you can mount an iso into the cd-rom and install the OS just as you would on a physical machine. Rather than download a different image (iso) I just grabbed what I had handy and installed Ubuntu 7.10 desktop edition. Everything installed very smoothly. After the box came back up I installed apache, ruby, rubygems, rails, mongrel, mongrel_cluster, and several other gems. I whipped up a quick sample app and pointed the apache configuration at it. With everything installed it probably only took 30 minutes of work and a couple hours just letting it install things… not bad. Also in the process I moved over the original rPath LAMP image to the new VMware server so that they’re all in the same place.

Another issue I was running into was with Rails. In Ruby on Rails it is wondrously easy to create webservices whether SOAP or even better with all the new fangled REST goodness. Though it is pretty painstaking to consume them… I think I may end up ditching all the SOAP wrappers and such in favor of some more simple Domino agents that will return busytime, perhaps JSON would be a nice format (and might come in handy for some other projects)

Our Domino server was already configured to run LDAP and allowed anonymous access which makes things a little tougher. I had to search around quite a bit and piece together information on how to connect to LDAP via Ruby and how to create a simple authentication system and login page.

To start things off you need the Net::LDAP library, you can download it from the ruby forge site, or just grab it with Gem.

gem install ruby-net-ldap

Next I created a module in the Rails’ /lib folder to hold the LDAP connection and authenticate method.
EDIT 9/20/2007:It seems I wasn’t very clear here, this code below was placed into “ldap_connect.rb” within the lib folder. It is then included into the rails application with the require statement below.

require 'net/ldap'
module LDAP
  def self.authenticate(user,password)
    if user == "" || password == ""
      return false
    end
    ldap_con = Net::LDAP.new({:host => 'your.dominoserver.com',
      :port => 389,:auth=>{:method=>:simple,:username => user,
      :password => password } } )
    return true if ldap_con.bind
    return false
  end
end

This code is pretty simple, its going to first do a reality check to make sure that a name and password were entered at all (necessary because we allow anonymous access), then it will attempt to create (bind) a connection to the ldap server using the username and password entered. Now on to the controller, I let rails generate the shell with a quick

script generate controller login

Instead of starting from scratch I found a nice simple base on the Rails Wiki. Really the only parts to worry about are the call to the LDAP.authenticate function, and the mention up top to skip_before_filter :authenticate (I’ll go into this more in a moment).

require 'ldap_connect'
class LoginController < ApplicationController
  skip_before_filter :authenticate
  def index
  end

  def authenticate
    if session[:person] = LDAP.authenticate(params[:login][:name], params[:login][:password])
      session[:username] = params[:login][:name].capitalize_each
      if session[:return_to]
        redirect_to_path(session[:return_to])
        session[:return_to] = nil
      else
        redirect_to :controller => "inspections"
      end
    else
      flash[:notice] = "Login failed!"
      redirect_to :action => "index"
    end
  end

  # logout
  # clears the session
  def logout
    session[:person] = nil
    session[:username] = nil
    flash[:notice] = "Logged out"
    redirect_to :action => "index"
  end
end

This is a pretty simple controller, it’s basically passing through the values entered to the authenticate method above and then redirecting the user depending on the result of the authentication. It does have some niceness where it previously stored the page the user was trying to access and redirects them to that page if they successfully login. Something is still missing… we need to tell the application to force people to login if they haven’t already. Since we want this to happen on any page they might go to we place this code in the application.rb controller. A few quick lines will do the trick

class ApplicationController < ActionController::Base
  before_filter :authenticate
  filter_parameter_logging "password"

  protected
  def authenticate
    unless session[:person]
      session[:return_to] = @request.request_uri
      redirect_to :controller => "login"
      return false
    end
  end
end

before_filter will take care of calling authenticate before displaying any page. Authenticate checks to see if they have our session variable set and will redirect them to login if need be. A quick note about the filter_parameter_logging, this is good to have in place otherwise all passwords will be recorded in plain text log files…:P

The final piece needed is a simple view to display the login fields. By default rails is configured to look for the index method of any controller (this can be changed). To keep things simple I made the login page views\login\index.rhtml

<!DOCTYPE html
     PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
     "DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" lang="en">
<head>
  <title>Login</title>
</head>
<body>
  <%= start_form_tag :action => 'authenticate' %>
  <fieldset>
  <div class="form-element">
    <label for="name">Username </label>
    <%= text_field 'login', 'name' , {:class=>"text-input"} %>
  </div>
  <div class="form-element">
    <label for="password">Password </label>
    <%= password_field 'login', 'password' , {:class=>"text-input"} %>
  </div>
</body>
</html>

That’s it… not entirely simple, but really not bad once you get the hang of Rails.