Brian Leonard's Blog

Introducing The Observatory

Yesterday Gregg Sporar, Roman Strobl and I launched The Observatory, a blog dedicated to those learning to use OpenSolaris. The last couple of my blog entries have been about OpenSolaris and I've been waiting for someone to ask: "Dude, what are you doing talking about OpenSolaris on a Java site?" Plus, this blog also feeds into Planet NetBeans and I don't necessarily want to piss off that community either.

In many respects, my role does not change, as I'm still going to talk about NetBeans and other technologies I've come to love like Rails. The difference is that I will be showing off the advantages of doing those things from OpenSolaris.

OpenSolaris 2008.05: Installing MySQL 5

Looking at the MySQL web site, the instructions for Installing MySQL Community Server seem more complicated then they need to be. Maybe that's because there are no instructions for OpenSolaris (yet - I hope). Here are the easy steps that got me up and running.

Install MySQL

Open the Package Manager: System > Administration > Package Manager (give it a couple of seconds to load the package information):
Enter mysql5 in the Search text box .The list will filter as you type.
Select the check box for SUNWmysql5 and click the Install/Update button in the toolbar;
Wait while package dependencies are checked and then click Next on the Install / Update Confirmation dialog:
Wait while the packages are downloaded and installed:
After which, the Package Manager will show MySQL as installed:

Start the MySQL Service

Open System > Administration > Services and scroll down to MySQL RDBMS in the list:
Click the check box to enable the MySQL RDBMS:

Verify the Installation

Note, the MySQL documentation's Installation Layouts page does not cover OpenSolaris, but you'll find the binaries in /usr/mysql/bin and the databases in /var/mysql/data.

Open a terminal and start the MySQL client:

bleonard@opensolaris:~$ /usr/mysql/bin/mysql -u root
Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is 4
Server version: 5.0.45 Source distribution

Type 'help;' or '\h' for help. Type '\c' to clear the buffer.

mysql> show databases;
+--------------------+
| Database |
+--------------------+
| information_schema |
| mysql |
| test |
+--------------------+
3 rows in set (0.00 sec)
If you have NetBeans 6.1 installed it will also show you your MySQL databases in the services tab:

OpenSolaris 2008.05: Installing NetBeans 6.1

Unfortunately, NetBeans 6.1 has not yet made it into the package repository for OpenSolaris 2008.05 yet. Here's how to install it.

Step 1: Install the JDK

OpenSolaris 2008.05 does not ship with the JDK, so if you haven't already done so, it needs to be installed first.

Download JDK 6 Update 6 (or newer)
For the Platform select Solaris x86. Even if you're running in 64-bit mode you need to install the x86 version first:
Download the Solaris x86 packages -tar.Z. You can use the Sun Download Manager, but I just clicked the file name and saved it to a JDK folder I created on my Desktop (I created a folder so the extracted files would be easier to clean up):
Extract the tar file. Open a terminal and enter:

cd Desktop/JDK
zcat jdk-6u6-solaris-i586.tar.Z | tar -xf -
Install the JDK (OpenSolaris 2008.05 ships with the JRE, so there's no need to install that package):

bleonard@opensolaris:~/Desktop/JDK$ pfexec pkgadd -d . SUNWj6dev SUNWj6cfg SUNWj6man SUNWj6dmo

Processing package instance from

JDK 6.0 Dev. Tools (1.6.0_06)(i386) 1.6.0,REV=2006.11.29.05.03
Copyright 2007 Sun Microsystems, Inc. All rights reserved.
Use is subject to license terms.
Using as the package base directory.
## Processing package information.
## Processing system information.
4 package pathnames are already properly installed.
## Verifying package dependencies.
WARNING:
The package "Motif RunTime Kit" is a
prerequisite package and should be installed.

Do you want to continue with the installation of [y,n,?]

The Motif RunTime Kit (SUNWmfrun) isn't included with OpenSolaris 2008.05, so I'm just going to ignore this warning and continue...

Do you want to continue with the installation of [y,n,?] y

Installing JDK 6.0 Dev. Tools (1.6.0_06) as

## Installing part 1 of 1.
/usr/jdk/instances/jdk1.6.0/LICENSE
/usr/jdk/instances/jdk1.6.0/README.html
...

/usr/jdk/instances/jdk1.6.0/lib/tools.jar
/usr/jdk/instances/jdk1.6.0/src.zip
[ verifying class ]
## Executing postinstall script.

Installation of was successful.

Processing package instance from

JDK 6.0 Host Config. (1.6.0_06)(i386) 1.6.0,REV=2006.11.29.05.03
Copyright 2007 Sun Microsystems, Inc. All rights reserved.
Use is subject to license terms.
Using as the package base directory.
## Processing package information.
## Processing system information.
1 package pathname is already properly installed.
## Verifying package dependencies.
WARNING:
The package "Motif RunTime Kit" is a
prerequisite package and should be installed.

Do you want to continue with the installation of [y,n,?]

You get the same warning with the Dev. Tools package. Again, continue...

Do you want to continue with the installation of [y,n,?] y
## Verifying disk space requirements.
## Checking for conflicts with packages already installed.
## Checking for setuid/setgid programs.

This package contains scripts which will be executed with super-user
permission during the process of installing this package.

Do you want to continue with the installation of [y,n,?] y

Installing JDK 6.0 Host Config. (1.6.0_06) as

## Installing part 1 of 1.
[ verifying class ]
[ verifying class ]
## Executing postinstall script.

Installation of was successful.

Processing package instance from

JDK 6.0 Man Pages (1.6.0_06)(i386) 1.6.0,REV=2006.12.07.16.42
Copyright 2007 Sun Microsystems, Inc. All rights reserved.
Use is subject to license terms.
Using as the package base directory.
## Processing package information.
## Processing system information.
3 package pathnames are already properly installed.
## Verifying package dependencies.
## Verifying disk space requirements.
## Checking for conflicts with packages already installed.
## Checking for setuid/setgid programs.

Installing JDK 6.0 Man Pages (1.6.0_06) as

## Installing part 1 of 1.
/usr/jdk/instances/jdk1.6.0/man/man1/appletviewer.1
/usr/jdk/instances/jdk1.6.0/man/man1/apt.1
...

/usr/jdk/instances/jdk1.6.0/man/man1/wsimport.1
/usr/jdk/instances/jdk1.6.0/man/man1/xjc.1
[ verifying class ]

Installation of was successful.

Processing package instance from

JDK 6.0 Demo Programs (1.6.0_06)(i386) 1.6.0,REV=2006.11.29.05.03
Copyright 2007 Sun Microsystems, Inc. All rights reserved.
Use is subject to license terms.
Using as the package base directory.
## Processing package information.
## Processing system information.
3 package pathnames are already properly installed.
## Verifying package dependencies.
WARNING:
The package "Motif RunTime Kit" is a
prerequisite package and should be installed.

Do you want to continue with the installation of [y,n,?]

And one final warning with the Demo Programs package...

Do you want to continue with the installation of [y,n,?] y

/usr/jdk/instances/jdk1.6.0/sample/webservices/EbayServer/src/ebay/server/Main.java
[ verifying class ]

Installation of was successful.
bleonard@opensolaris:~/Desktop/JDK$

Delete the JDK directory

cd ..
rm -r JDK
If you're running in 64-bit mode, you can now optionally install the 64-bit version of the JDK. To check, run:

isainfo -b

The output will either be 32 or 64.

Step 2: Download NetBeans 6.1

Download NetBeans 6.1. Personally I'm choosing the "All" packs configuration, but any of the bundles should work with these instructions. Save the NetBeans installer to your Desktop (which is the default location if you haven't configured Firefox otherwise).

Step 3: Install NetBeans 6.1

Make the installer executable. Open a terminal and run:

chmod +x Desktop/netbeans-6.1-ml-solaris-x86.sh
Run the installer:

./netbeans-6.1-ml-solaris-x86.sh

You'll see the following as the installer GUI starts...

bleonard@opensolaris:~/Desktop$ ./netbeans-6.1-ml-solaris-x86.sh
Configuring the installer...
Searching for JVM on the system...
Extracting installation data...
Running the installer wizard...

Followed by the welcome screen where you can continue with the installation:

Step 4: Launching NetBeans

Once NetBeans is Installed you'll find an icon on your desktop:
As well as a menu item under Applications > Developer Tools:

Resources

OpenSolaris 2008.05: Configuring an External Monitor

If you have an NVIDIA graphics card, OpenSolaris 2008.05 comes with a sweet NVIDIA utility for working with their cards. The only problem is that is seems pretty worthless w/out an existing xorg.conf file and the proper permissions to write to it:

These are the steps I took to configure my external display.

Step 1: Generate an xorg.conf File

Open a terminal and run: pfexec nvidia-xconfig

bleonard@opensolaris:~$ pfexec nvidia-xconfig

WARNING: Unable to locate/open X configuration file.

sh: line 1: pkg-config: not found
sh: line 1: pkg-config: not found
New X configuration file written to '/etc/X11/xorg.conf'

bleonard@opensolaris:~$

Step 2: Configure NVIDIA Settings To Run with the Proper Privileges

Launching the NVIDIA X Server Settings GUI from the Applications > System Tools menu seems fairly worthless, as it doesn't have the proper privileges to make changes to xorg.conf:

NVIDIA Settings can be run from the command line using: pfexec nvidia-settings

But let's fix the menu so it's not so worthless:

From the terminal run: pfexec vi /usr/share/applications/nvidia-settings.desktop
Prefix the Exec command with pfexec. The complete line should look as follows:

Exec=pfexec /usr/bin/nvidia-settings
Save the changes (:wq)

Step 3: Configure You External Monitor

Run Applications > System Tools > NVIDIA X Server Settings
Select X Server Display Configuration:
Select your external monitor (mine's a Sun) and click Configure:
If necessary, you can change screen positions by dragging the screens, or by selecting the X Screen tab and setting the screen's Position:
Click Save to X Configuration File:
If you selected Separate X screen, log out and back in to restart the X server:

There are still some oddities. I use the Sun 24" monitor as my primary. Every now and then while working from the Sun display, a window opens on the laptop display. Also, for some reason, I cannot drag an open window from one display to the other, although my mouse moves easily between them and I can easily drag desktop icons across the displays.

OpenSolaris 2008.05 Meet the MacBook Pro

Okay, so I'm not the first to document this configuration ⁽¹⁾. However, I wasn't successful with any of the other approaches I discovered. Maybe this was because it most cases they were using a pre-release build of OpenSolaris 2008.05. So, for what it's worth, here are the steps that led me to success...

What I've Got

MacBook Pro w/ a 2.4 GHz Intel Core 2 Duo processor (model A1226) running OS X 10.5.1. I believe these steps would work for any MacBook w/ an Intel Core 2 Duo processor.

What You'll Need

OpenSolaris 2008.05
A blank writable CD (to burn OpenSolaris 2008.05)
Your OS X Installation DVD
rEFIt - a boot menu for EFI-based machines like the Intel Mac.
A USB thumb drive (for the network drivers)
A USB mouse (Solaris doesn't support ctrl-click :-()

What You Should Know

I still haven't gotten the audio to work :-(.

What I Did

Step 1: Burn the OpenSolaris 2008.05 Live CD

OpenSolaris comes as a live bootable CD, that once loaded provides you the option to install the OS.

Download OpenSolaris 2008.05.
Start Disk Utility.
Select the os200805.iso and the click Burn in the toolbar.

Step 2: Put the Ethernet Drivers on a USB Stick

Unfortunately, the drivers for the Ethernet adapter are not included on the Live CD. Save yukonxsol_x64v8.19.2.3.tar.Z to a USB thumb drive (you could also burn it to a CD if you don't have a USB drive handy).

Step 3: Create a Partition for OpenSolaris 2008.05

First I tried to create a partition from my existing Mac OS installation using "diskutil resizeVolume", but this kept failing on me because of insufficient disk space. Now my MacBook's about 9 months old and has been through an upgrade to Leopard, so I imagine the disk was pretty fragmented. Luckily I'm using Time Machine so I just decided to start from scratch.

Insert your OS X installation DVD. When it loads, click Install Mac OS X:

Then click the Restart button to launch the installer:

When you get to the Welcome screen, select Disk Utility from the Utilities menu.
When Disk Utility starts, select the MacBook's hard drive. Mine is a "149.1 GB FUJITSU MHW2160BHPL Media". Then select the Partition tab on the right panel.
Change the Volume Scheme to 2 Partitions.
Select the Untitled Partition 1 and set the following

Name: OPENSOLARIS
Format: MS-DOS FAT
Size: 55.00 GB

Select the Untitled Partition 2 and set the following

Name: MacOS
Format: Mac OS Extended (Journaled)
Size: (whatever's remaining - for me this was 94.05 GB)

Click the Options button and verify GUID Partition Table is selected as the partition scheme (we'll have to change this later as the OpenSolaris installer does not recognize GUID Partition Tables).
Click Apply and then Partition when the Partition Disk dialog appears. It only takes a couple of seconds for the new partition map to be created. This is what my disk looks like after the disk is repartitioned:

Quit Disk Utility

Step 4: Install OS X

You should now be back at the installer's Welcome screen. Click Continue to proceed with the installation of OS X.
Select the MacOS partition on the Select a Destination screen.
Select Install on the Install Summary screen and go do something else for a couple of hours as OS X installs.
Once the install is complete you'll be presented with the Welcome screen where you'll select your country, keyboard and then the option to restore from a Time Machine backup. Restoring from Time Machine took several more hours, so this time around I'm going to skip this step (I can always do a restore later) and just complete the vanilla installation (selecting Do not transfer my information now).
Complete the installation entering your Apple ID, Registration Information, etc.

Step 5: Install rEFIt

rEFIt is a boot menu that will allow you to choose between Mac OS and OpenSolaris at system start up.

Download and install rEFIt using the Mac disk image.

To ensure that rEFIt is always enabled, open a Terminal and enter the the following command:

$ sudo /efi/refit/enable-always.sh

After OpenSolaris is installed, the rEFIt boot menu is going to display the Linux penguin for OpenSolaris. While we're in Mac OS and have access to the EFI partition, let's replace the Linux icons with OpenSolaris icons:

Save these files to your /efi/refit/icons directory. Rename the original files if you don't want to loose them.

Step 6: Change the EFI partition ID

If you attempted to install OpenSolaris now, it would not recognize the new partition that was just created, only giving you the option to install over the entire disk. In this step we change the partition ID for the EFI partition from 'EE' to 'AF'.

Open a Terminal and run diskUtil list:

william-leonards-macbook-pro:~ brianleonard$ diskUtil list

/dev/disk0

#: TYPE NAME SIZE IDENTIFIER

0: GUID_partition_scheme *149.1 Gi disk0

1: EFI 200.0 Mi disk0s1

2: Microsoft Basic Data OPENSOLARIS 55.0 Gi disk0s2

3: Apple_HFS MacOS 93.7 Gi disk0s3

Your internal hard drive should show up as /dev/disk0. You'll also see disks for the OS X installation DVD and your Time Machine drive.
Next we will alter partition 1, the EFI partition. Run:

william-leonards-macbook-pro:~ brianleonard$ sudo fdisk -e /dev/disk0

Password:

fdisk: could not open MBR file /usr/standalone/i386/boot0: No such file or directory

Enter 'help' for information

fdisk: 1>
At the fdisk prompt, type p to print the partition table:

fdisk: 1> p

Disk: /dev/disk0 geometry: 19457/255/63 [312581808 sectors]

Offset: 0 Signature: 0xAA55

Starting Ending

#: id cyl hd sec - cyl hd sec [ start - size]

------------------------------------------------------------------------

1: EE 1023 254 63 - 1023 254 63 [ 1 - 409639]

2: 0B 1023 254 63 - 1023 254 63 [ 409640 - 115344664] Win95 FAT-32

3: AF 1023 254 63 - 1023 254 63 [ 115754304 - 196565320] HFS+

4: 00 0 0 0 - 0 0 0 [ 0 - 0] unused

fdisk: 1>

You'll see that partition 1 is of type EE . Let's change it to AF HFS+:

At the prompt type: setpid 1

fdisk: 1> setpid 1

Starting Ending

#: id cyl hd sec - cyl hd sec [ start - size]

------------------------------------------------------------------------

1: EE 1023 254 63 - 1023 254 63 [ 1 - 409639]

Partition id ('0' to disable) [0 - FF]: [EE] (? for help)
Enter AF:

Partition id ('0' to disable) [0 - FF]: [EE] (? for help) AF

fdisk:*1>
Then write:

fdisk:*1> write

Device could not be accessed exclusively.

A reboot will be needed for changes to take effect. OK? [n]
Then y:

A reboot will be needed for changes to take effect. OK? [n] y

Writing MBR at offset 0.

fdisk: 1>
Then quit:

fdisk: 1> quit

william-leonards-macbook-pro:~ brianleonard$

Eject the OS X Installation DVD and insert the OpenSolaris 2008.05 Live CD.
Restart
From the rEFIt menu, select the option to "Boot Legacy OS from CD"
As the Live CD boots, select your keyboard layout and desktop language and then wait for the desktop to load.
Close the license.
Click the Install OpenSolaris icon on the desktop:
Once the Welcome screen loads click Next to get to the Disk screen:
On the Disk screen you'll notice that OpenSolaris recognizes the newly created Win95 FAT32 partition:
Change the Partition Type to Solaris:
Click Next to select your Time Zone, Date and Time. Note, you can use the Map to select your region:
Select your Locale:
Set up your users:
Review the Installation summary and then Install:
It takes about 30 minutes for the installer to complete:
Once complete, select Reboot:

Step 8: Start OpenSolaris and Install the Wired Ethernet Driver

If you installed the OpenSolaris icons, you'll see them now in the rEFIt menu.
Insert your USB mouse.
Open System > Administration > Device Driver Utility. You see that both the wired and wireless network drivers are missing. Select the Marvel Technology Group Ethernet Controller and write down the Vendor ID and Device ID. In my case these are 11ab and 436a respectively:
Copy yukonxsol_x64v8.19.2.3.tar.Z from the USB drive to the desktop.
Open Applications > System Tools > Terminal.
You should be in your home directory. CD into the Desktop directory:

bleonard@opensolaris:~$ cd Desktop
bleonard@opensolaris:~/Desktop$
Unzip the archive:

bleonard@opensolaris:~/Desktop$ gunzip yukonxsol_x64v8.19.2.3.tar.Z
bleonard@opensolaris:~/Desktop$
Untar the archive:

bleonard@opensolaris:~/Desktop$ tar -xvf yukonxsol_x64v8.19.2.3.tar
YUKONXsolx/
YUKONXsolx/pkgmap
...
YUKONXsolx/install/yukonx.txt
yukonx.txt
yukonx.htm
bleonard@opensolaris:~/Desktop$
Install the package:

bleonard@opensolaris:~/Desktop$ pfexec pkgadd -d . YUKONXsolx

Processing package instance from

Marvell Yukon Ethernet Controller 64 bit driver(i386) 8.19.2.3
Marvell

----------------------
IP configuration
printf: ----------------------\n\n: unknown option
Usage: printf [ options ] format [string ...]
Do you want to configure the IP interfaces now (y/n)?
Yes, configure the IP interfaces now...

Do you want to configure the IP interfaces now (y/n)? y

Configuring Marvell Gigabit Ethernet interface 0

NOTE: If you want to configure the driver for the use of VLANs,
you should use the script /usr/sbin/yukonx_vlan_config.
You have to do this after driver installation is finished.

Please enter a hostname for the Marvell Gigabit Ethernet interface.
It should be different from all existing hostnames in
your system (see /etc/hostname.*).

Hostname [yukonx0]:
Select the default Hostname 'yukonx0'...

Hostname [yukonx0]:
DHCP will ultimately set the IP address, so for now I just enter 127.0.0.1...

Enter the IP address for 'yukonx0' []: 127.0.0.1

WARNING: The selected IP address has been found in
/etc/hosts:

127.0.0.1 opensolaris opensolaris.local localhost loghost

This can cause problems, but it
might be intentional in this case.

Enter the IP netmask for 'yukonx0' []:
Enter the IP netmask, I used 255.255.255.0, and review the settings...

Enter the IP netmask for 'yukonx0' []: 255.255.255.0

Settings for Marvell Gigabit Ethernet interface 0:
hostname : yukonx0
IP-address : 127.0.0.1
IP-netmask : 255.255.255.0
IP-netnumber: 127.0.0.0

NOTE: If the netmask does not consist of '255's and '0's only,
the netnumber in /etc/netmasks will require manual correction

Are these settings OK (y/n)?
Answer yes to confirm the settings and then no to configure another adapter...

Are these settings OK (y/n)? y

Do you have more Marvell Gigabit Ethernet adapters installed (y/n)? n
Using as the package base directory.
## Processing package information.
## Processing system information.
10 package pathnames are already properly installed.
## Verifying disk space requirements.
## Checking for conflicts with packages already installed.
## Checking for setuid/setgid programs.

This package contains scripts which will be executed with super-user
permission during the process of installing this package.

Do you want to continue with the installation of [y,n,?]
Answer yes to continue with the installation of the package...

Do you want to continue with the installation of [y,n,?] y

Installing Marvell Yukon Ethernet Controller 64 bit driver as

## Executing preinstall script.
## Installing part 1 of 1.
/etc/rcS.d/S50yukonx
/kernel/drv/amd64/yukonx
/kernel/drv/yukonx.conf
/usr/sbin/yukonx_vlan_config
/usr/share/man/man7d/yukonx.7d
[ verifying class ]
[ verifying class ]
## Executing postinstall script.
/var/sadm/pkg/YUKONXsolx/install/postinstall[14]: /usr/ucb/echo: not found [No such file or directory]
devfsadm: driver failed to attach: yukonx
Warning: Driver (yukonx) successfully added to system but failed to attach
/var/sadm/pkg/YUKONXsolx/install/postinstall[113]: /usr/ucb/echo: not found [No such file or directory]
pkgadd: ERROR: postinstall script did not complete successfully

Installation of partially failed.
bleonard@opensolaris:~/Desktop$
Don't worry about the failure, we'll update the driver next...

bleonard@opensolaris:~/Desktop$ pfexec update_drv -a -i '"pci11ab,436a"' yukonx
bleonard@opensolaris:~/Desktop$
Then plumb the interface...

bleonard@opensolaris:~/Desktop$ pfexec ifconfig yukonx0 plumb
bleonard@opensolaris:~/Desktop$
Then in a couple of seconds you should see the interface come up:
Test the connection:

bleonard@opensolaris:~/Desktop$ ping www.google.com
www.google.com is alive
Confirm that all is well (at least for the Marvell card) in the Device Driver Utility:

Step 9: Install the Wireless Adapter Driver

Now that we're connected to the Internet, the world is at your fingertips. However, let's do one more thing (for now) and install the wireless adapter driver.

Select the Atheros Communications Wireless PCI Express Adapter in the Device Driver Utility. Write down the Vendor ID and Device ID. In my case these are 168c and 24 respectively:
Download the SUNWatheros 0.7.2 package and save it to your desktop.
Return to the Terminal and gunzip and untar the package.
Install the package:

bleonard@opensolaris:~/Desktop$ pfexec pkgadd -d SUNWatheros

The following packages are available:
1 SUNWatheros Atheros 802.11b/g Wireless NIC Driver
(i386) 11.11,REV=2007.12.18.15.35

Select package(s) you wish to process (or 'all' to process
all packages). (default: all) [?,??,q]:
Press enter to select the default - all...

Select package(s) you wish to process (or 'all' to process
all packages). (default: all) [?,??,q]:

Processing package instance from

Atheros 802.11b/g Wireless NIC Driver(i386) 11.11,REV=2007.12.18.15.35
# ident "@(#)LICENSE 1.1 05/11/28 SMI"

SOLARIS WIRELESS DRIVER FOR THE ATHEROS 52XX CHIPSET (ATH)

LICENSE AGREEMENT

...

Using as the package base directory.
## Processing package information.
## Processing system information.
5 package pathnames are already properly installed.
## Verifying package dependencies.
## Verifying disk space requirements.
## Checking for conflicts with packages already installed.

The following files are already installed on the system and are being
used by another package:
* /kernel/drv/amd64/ath
* /kernel/drv/ath
* /kernel/misc/amd64/net80211
* /kernel/misc/net80211

* - conflict with a file which does not belong to any package.

Do you want to install these conflicting files [y,n,?,q]
Answer yes to install the conflicting files and yes to continue with the installation...

Do you want to install these conflicting files [y,n,?,q] y
## Checking for setuid/setgid programs.

This package contains scripts which will be executed with super-user
permission during the process of installing this package.

Do you want to continue with the installation of [y,n,?] y

Installing Atheros 802.11b/g Wireless NIC Driver as

## Installing part 1 of 1.
/kernel/drv/amd64/ath
/kernel/drv/ath
/kernel/misc/amd64/net80211
/kernel/misc/net80211
[ verifying class ]
## Executing postinstall script.

Installation of was successful.
bleonard@opensolaris:~/Desktop$
Remove and reinstall the driver...

bleonard@opensolaris:~/Desktop$ pfexec rem_drv ath
bleonard@opensolaris:~/Desktop$ pfexec add_drv -i '"pci168c,24"' ath
Plumb the interface...

bleonard@opensolaris:~/Desktop$ pfexec ifconfig ath0 plumb
Configure the interface for DHCP:

bleonard@opensolaris:~/Desktop$ pfexec ifconfig ath0 dhcp
Wired connections take precedence over wireless. Unplug the wired connection to test the wireless...
Scan for available networks:

bleonard@opensolaris:~/Desktop$ wificonfig scan
essid bssid type encryption signallevel
CowPlanet 00:1e:52:7a:26:e5 access point none 15
And connect:

bleonard@opensolaris:~/Desktop$ wificonfig connect 'CowPlanet'
wificonfig: connecting to essid 'CowPlanet'
bleonard@opensolaris:~/Desktop$
See it's status:

bleonard@opensolaris:~/Desktop$ wificonfig showstatus
linkstatus: connected
active profile: none
essid: CowPlanet
bssid: 00:1e:52:7a:26:e5
encryption: none
signal strength: strong(15)
And test:

bleonard@opensolaris:~/Desktop$ ping www.google.com
www.google.com is alive
Confirm that the network driver issues are now resolved in the Device Driver Utility:

Resources

Everything I've summarized here I was able to learn from these various resources:

OpenSolaris Dual Boot - I found no reason to use GParted.
How to Dual Partition a MacBook Pro with MacOS and Solaris - Over 1 year old, and many of the steps are no longer necessary, but I prefer Paul's approach to changing the EFI partition ID (instead of using GParted).
Solaris on a MacBook - Helped me with the Network configuration
BigAdmin - HCL: Apple MacBook Pro A1150 - The Hardware Compatibility List - not an exact match, but close enough.

Drag & Drop with Rails

The ability to drag and drop has been a staple of desktop applications for years. With the advent of Ajax, the ability to drag and drop has now found its way to web applications. In this entry I spice up the blogging application we've been building with the ability to drag comments to the trash. This is an appropriate feature to add as our own blogs here on java.net have been prone to spam attacks via the comments which require cleanup.

Setting Things Up

I'm going to continue from where the tutorial Using Ajax with Ruby on Rails leaves off. However, I'll be using NetBeans 6.1 and Rails 2.0, so you may want to start with this updated version of the rubyweblog project which has been updated to Rails 2.0 (the entire tutorial series is in the process of being updated).

Test the Existing rubyweblog Project

Open the rubyweblog project.
Note, if you are starting with the provided rubyweblog project, you will also need to create the rubyweblog_development database (Run Rake Task > db > create) and run the migrations.
Run the project and browse to http://localhost:3000/posts to verify that it works. Add at least one blog entry with a couple of comments.

The Plan

Currently, the application does not provide the means to delete a comment. Now, I know this application is severely lacking any sort of user model or administrative interface, but my intent is to show how to do cool things with Rails, not create a replacement for roller, so I squeeze the features in where I can. In this case, I'm going to add a trash can icon to the page and allow users to drag comments to the trash for deletion.

Step 1: Make the Comments Draggable

Here we'll employ the draggable_element helper, a Rails wrapper around the Scriptaculous Draggable object, to make the comments draggable.

Open _comment.html.erb, which is the partial for displaying a single comment, and make it draggable by adding the draggable element helper to the bottom of the file as shown in bold below:
```
<% comment_id = "comment_#{comment.id}" %>
comment_id %> >
  <%= h comment.comment %>

  
      Posted on <%= comment.created_at.strftime("%B %d, %Y at %I:%M %p") %>
  


<%= draggable_element(comment_id, :revert=>true) %>
```
Note, since comment_id is used twice, I pulled it out into a local variable to keep the code a bit cleaner. Revert returns the comment to its original location if we drop it anywhere but on the trash can (which we haven't added yet).
Add a visual indicator that the comments are draggable. Open scaffold.css (Public > stylesheets) and add the following style:
```
#comments {
    cursor: -moz-grab;
}
```
Test your changes. The comments are now draggable, but we haven't specified anywhere to drop them yet.

Step 2: Add the Trash Icon

Save (trashfull.jpg) to the public/images directory of your rubyweblob project directory.

Open show.html.erb and add the following after the :

<%= text_area 'comment', 'comment' %>
<%= image_tag "trash.jpg", :id=>'trash'%>

Step 3: Make the Trash Icon a Drop Receiver

Here we'll use the drop_receiving_element helper, a Rails wrapper around the Scriptaculous Droppables.add method to give the comment a drop destination and call the action to delete the comment.

Open show.html.erb and add the drop_receiving_element to the bottom of the file as show below:
```
<%= drop_receiving_element('trash',                             # The id of the receiving element
  :accept => "comment",                                         # The CSS class of the dropped element
  :with   => "'comment=' + (element.id.split('_').last())",     # The query string parameters
  :url    => {:action=>:trash_comment}                          # The action to call
)%>
```
Note the :with parameter - this is a piece of JavaScript code that extracts the comment ID form the DOM ID, which if you recall from above is something like "comment_123". We also still have some work to do: first, we don't have anything with a CCS class named "comment" and second we need to code the trash_comment action.
Open _comment.html.erb and add class="comment" to the
tag:
```
class="comment" id=<%= comment_id %> >
```

Open posts_controller.rb and add the following trash_comment action:

  def trash_comment
    comment_id = params[:comment]
    Comment.delete(comment_id)
    
    render :update do |page|
      page.replace_html "comment_#{comment_id}", "" 
    end          
  end

Test your changes. Dragging a comment to the trash can should delete it and clear it from the list, although the bullet still remains. That's because the replace_html method above is replacing the html inside of the bulleted list item. Wrapping the bulleted list items in a
solves this problem.
Open _comment.html.erb and wrap the

in a

, also moving the class and id properties to the

<% comment_id = "comment_#{comment.id}" %>
 > 
  
    <%= h comment.comment %>

    
       Posted on <%= comment.created_at.strftime("%B %d, %Y at %I:%M %p") %>
    

 


<%= draggable_element(comment_id, :revert=>true) %>

Now the comments should delete completely.

Step 4: Adding Visual Clues That Something's Happening

Save (trashfull.jpg) to the public/images directory of your rubyweblob project directory.

Add a couple of JavaScript methods to show.html.erb to swap the source of the trash image from empty to full and back:

Add a couple of properties to the drop_receiving_element method, :onHover and :complete:

<%= drop_receiving_element('trash',                             # The id of the receiving element
  :accept => "comment",                                         # The CSS class of the dropped element
  :with   => "'comment=' + (element.id.split('_').last())",     # The query string parameters
  :url    => {:action=>:trash_comment},                         # The action to call
  :onHover => "function() {fill_trash()}",                      
  :complete => "empty_trash()"
)%>

Note, I can't tell you why :onHover requires a function definition while :complete takes any arbitrary JavaScript, but that's the way it works.

Test your changes. You should now see a full garbage can when you drag a comment over it and then empty again once the delete completes.
There's still one minor problem - if you drag a comment over the trash but don't actually drop it, your trash can remains full. We can fix this using the onMouseOut event. Add it to the image_tag as follows:
```
<%= image_tag "trash.jpg", :id=>'trash', :onMouseOut=>"empty_trash()"%>
```
And that should pretty much complete the drag and drop functionality. Remember to refresh the browser to pick up changes to Javascript. Also, Firebug is your friend whenever you're working with Ajax and not seeing what you're expecting.

The Completed Application

RubyWeblogDND.zip

Autovalidation with Rails

Actually, I don't know what this feature is called, but I love it when a web application gives me instant feedback on the validity of my entry. For example:

This is especially true when I'm registering a new user account - submitting the page over and over again because the username I've selected is already taken or the password doesn't meet the requirements is always a drag. So I started looked for examples on how to do this in Rails and couldn't really find anything (possibly because I don't actually know what to call it) - I guess it's most similar to autocompletion, so I'm going with autovalidation. And here are the steps I've put together to get it to work...

Setting Things Up

Download and install MySQL.
Download and install NetBeans 6.1 RC1 or later.

Creating the Rails Project

Create a new Ruby on Rails Application named autovalidation. You can select Finish after the first page of the New Ruby on Rails Application dialog:
Right-click the project and select Run Rake Task > db > create:
Right-click the project and select Generate. Generate a scaffold with the Model Name User and the Attribute Pairs username:string:
Right-click the project and select Migrate Database > To Current Version.
Open user.rb and type the following:
```
vu[tab]
```
- this will expand to:

type username over the attribute and press enter.
On the next line in user.rb type the following:
```
vl[tab]
```
this will expand to:

type username over the attribute and press enter. Type 5..10 over the 3..20 and press enter. The completed code should look as follows:
```
class User < ActiveRecord::Base
  validates_uniqueness_of :username
  validates_length_of :username, :within => 5..10
end
```

Traditional Server Side Validation

Run the project and browse to http://localhost:3000/users. Try to create a new user such as bill:
Okay, create william.
Try to create william again:

Let's enhance this application with more user friendly "autovalidation"...

Lets Autovalidate

In addition to the server side validation that's being performed, we're going to add some client side validation using Ajax. We'll do this by displaying a message to the right of the field on the validity of what's been entered. Since we're validating against the database, we will need to make an XMLHTTPRequest back to the server. We can use Rails' observe_field helper method for this task.

First we need to create a named placeholder for the message. Open new.html.erb and add a tag after the text field as follows:
```
<%= f.text_field :username %>
```

Now we'll use Rails' observe_field method to watch changes to that field. Add the following before the closing <% end %> tag:

    <%= observe_field   :user_username,                         # The field to observe 
                        :with       => "username",              # The input to validate
                        :frequency  => 0.25,                    # The frequency in seconds to watch for changes
                        :url        => {:action => :validate }, # The action to call when changes occur
                        :update     => :message                 # The DOM ID to update
                      %>

Create the validate action. Open users_controller.rb and add the following:

  def validate
    color = 'red'
    username = params[:username]
    if username.length < 5
      message = 'Too short'
    elsif username.length > 10
      message = 'Too long'
    else
      user = User.find_all_by_username(username)      
      if user.size > 0        
        message = 'Taken'     
      else
        message = 'Available'
        color = 'green'
      end
    end
    @message = "#{message}"
    render :partial=>'message'
  end

You'll notice in the last line of the validate action above we're rendering a partial. This partial, which we'll create next, will be dynamically rendered inside the span tag we defined in step 1 above.

Create a new ERB file named _message in Views > users. Replace its contents with the following:
```
<%= @message %>
```
Open users.html.erb and add the following before the closing tag:
```
<%= javascript_include_tag 'prototype'  %>
```
All Rails applications come with the prototype and scriptaculous libraries ready to use, but you do need to tell the application that you want to use them.

Run with Autovalidate

Switch to the browser and start creating a new user (you'll need to refresh the browser once to load the prototype JavaScript libraries):

Troubleshooting

Firebug is your friend for troubleshooting Rails applications. With Firebug enabled, you can see the requests as you type:

A couple of things that tripped me up

Forgetting to include the Prototype libraries:

Misspelling the field to observe:

The Completed Application

autovalidation.zip

Blogging for Dollars (and T-Shirts)

The NetBeans team has started a blogging contest. Simply download the NetBeans 6.1 Beta and tell us your thoughts. What, you're not a blogger? Well, here are some places to get started:

See the blogging contest web site for details on how to enter, ideas for your blog, rules and deadlines.

Hello Grails!

NetBeans 6.1 M1 was just released, and with it comes rudimentary support for the Groovy language and the Grails framework. I say rudimentary because this is M1, but there's a lot of work in progress as you can see from this task list.

So, of course I'm anxious to compare Grails to Rails. What better way to do than by creating the same blog application I've been blogging about with Rails?

Setting Things Up

Unlike with Rails, the NetBeans Groovy plugin does not come bundled with Groovy and the Grails framework - these must be pre-installed on your system (don't worry, it's easy):

Download and install Groovy
Download and install Grails
Download and install NetBeans 6.1 M1.
Install the Groovy and Grails plugin (Tools > Plugins > Available Plugins)
Open the NetBeans Options dialog and select the Groovy category. Set the Groovy and Grails home directories.

Creating the Grails Project

Choose File > New Project to create a new Grails Application named GroovyWebLog. Your new Grails application will appear in the IDE:

Creating the Model

Or as Grails prefers to call them, Domain classes.

Right-click the Domain classes node and select "Create new Domain Class":
Name the class Post.
When Post.groovy opens in the editor, add a single field, title:
```
class Post {

    String title

}
```

Creating the Controller

Right-click the Controllers node and select "Create new controller"
Name the controller Blog.
For now, we'll use dynamic scaffolding to create the application views at runtime. Replace the default contents of BlogController with the following:
```
class BlogController {
    def scaffold = Post
}
```
Note, if our controller named matched the domain class name, we could then use def scaffolding = true. I kept the model and controller names different to match what we did with Rails.

Run the Application

Right-click the GrailsWebLog project and select Grails > Run Application.
If all goes well, NetBeans will start the Jetty server that comes bundled with Grails and launch your browser where you will see the Grails welcome page:
Click the BlogController link:
Create a New Post:

It's not immediately obvious, but the Id is a link which you can use to view the post details. From the detail page you can then edit and/or delete the post:

Adding Another Field

Our blog needs a body field.

Edit Post.groovy and add a body field:

class Post {

    String title
    String body

}

Return to the browser and depending on what you do, you may get an error. By default Grails is configured to drop and create the database every time a change is made, so if you tried to edit the existing record you were viewing, you got a NullPointerException. However, if you navigate back to the list, you will see that the body field has been detected and you can add a new record again:

A Friendlier Database Configuration

Surprisingly, we haven't had to talk about databases yet as the Grails framework magically took care of this for us. The Grails framework includes HSQLDB and all of the necessary configuration was setup for us in DataSource.groovy, which you'll find under the Configuration node:

You can also see from this configuration file that Grails supports the same three environments as Rails: development, test and production. It's also easy to switch to another database, just set the driver class name, jdbc url and copy the JDBC driver to the project's lib directory.

Do the following:

Change the dbCreate property from "create-drop" to "update".
Right-click the GrailsWebLog project and choose Grails > Stop Application.
Richt-click the project again and choose Grails > Run Application.
Now experiment with adding and/or deleting fields - you'll notice that the behavior is much more "Railsesque".

Validating Input

Like Rails, validation in Grails is very straightforward.

Open Post.groovy and add the following constraints:

class Post {

    String title
    String body
    
    static constraints = {
        title(blank:false)
        body(blank:false)
    }

}

Attempt to add a new Post without entering any data:

Customizing the View

Okay, enough with this dynamic scaffolding. Let's generate our controller and view code. Unfortunately, for this step I haven't found the menu option in NetBeans yet, so we'll resort to the command line for now.

Open your command prompt and navigate to the GrailsWebLog project directory. If you've forgotten where this is, you can find it in the project's Properties dialog.
Run the command grails generate-all Post:
Now this created a new controller named PostController. I don't see a way to specify a controller name when using generate-all (or generate-controller). That's fine - I'll leave BlogController to do the dynamic scaffolding and use PostController for my customizations.
Also created were a set of GSP (Groovy Server Pages) for managing the view for the PostController:
Open list.gsp and delete everything from from the
Post List
to the following the pagination buttons. In its place put the following:

The Groovy Blog
 

  ${post.title}
  ${post.body}
  permalink

Return to the browser and refresh the list page:
To display the blog with the most recent entry first, add .reverse() to the end of postList in list.gsp:

The Completed Application

GrailsWebLog.zip

Testing Rails Applications

All well developed applications are supported by tests. In this entry I extend the web log I've been building to include some unit, functional and integration tests.

Setting Things Up

I'm going to begin from where I left off in my previous post: An Introduction to using AJAX with Rails: Take 2. Alternatively, you can start from RubyWeblogAJAX.zip, which is the completed project from that post.

Test the RubyWeblog Project

Open the rubyweblog project.
Note, if you are starting with the provided rubyweblog project, you will also need to create the rubyweblog_development database and run the migrations.
Run the project and browse to http://localhost:3000/blog to verify that it works.

The Plan

We're going to look at the facilities Rails provides for testing our model classes, controller classes and entire application.

Model Testing (Unit Tests)

The Rails framework uses unit tests for testing of the model classes. Back when we first created the Post model class, a couple of test files were created for us, test/unit/post_test.rb and test/fixtures/post.yml:

The post.yml file contains test data that's made available to the unit test and reloaded in the database every time the test is run. Don't worry, this isn't going to affect your development database, but rather the test database that's configured in database.yml, which we haven't created yet:

Create the rubyweblog_test Database

Switch to the Services window and expand the Databases node. We'll use an existing MySQL connection to create the test database. If you don't already have an existing MySQL database connection, create one for the development database.
1. Expand the Drivers node, right-click the MySQL driver and choose Connect Using
2. Set the Database URL to: jdbc:mysql://localhost/rubyweblog_development
3. Set the User Name to: root
4. Leave the Password blank
5. Click OK to establish the connection
Right-click an existing MySQL connection (connect first if not already) and select Execute Command.
Enter create database rubyweblog_test
Right-click the commend and select Run Statement

Prepare the Database

We need to run the migrations against the test database. This is done using the rake task db:test:prepare

Right-click the rubyweblog project and choose Run Rake Task > db > test > prepare

Run the Default Unit Test

The default unit test that was created for us when the model was generated is very basic and really only servers to prove our test environment is properly configured.

Open post_test.rb
Right-click the file and select Run File.

If for some reason the test fails to run, the error messages are generally descriptive enough to alert you to the problem, like "Unknown database 'rubyweblog_test' if you forgot to create the test database first.

Test the Validations

The post model is pretty simple and doesn't offer a lot to test, but it does have a couple of validations when can test, so therefore, we can assert that an empty model is invalid:

  def test_invalid_with_empty_attributes
    post = Post.new
    assert !post.valid?                  # An empty Post model will be invalid
    assert post.errors.invalid?(:title)  # The title field will have validation errors
    assert post.errors.invalid?(:body)   # The body field will have validation errors
  end

Using Fixture Data

To give us something more to test, let's require blog titles be unique.

Navigate to the tested class (Navigate > Go to Tested Class)
Add
```
validates_uniqueness_of :title
```

Open fixtures/post.yml and add the following:

first:
  id: 1
  title: George Jetson
  body: Was a man ahead of his time

Navigate back to the post_test.rb and add the following test method:

  def test_unique_title
    post = Post.new(:title  => posts(:first).title, # Pull the title from the fixture 
                    :body   => "Whatever")
    assert !post.save
    assert_equal "has already been taken", post.errors.on(:title) 
  end

Run the Tests

There are several way to run the test:

From the test file, right-click the file and choose Run File or Test File, as both do the same when executed from a test file.
From the tested class, right-click the file and choose Test File.

Controller Testing (Functional Tests)

When the scaffolding was generated, Rails also generated a functional test stub in the test/functional directory, which has 8 tests for the actions created by the generator (index, list, show, new, create, edit, update, destroy).

Open test/functional/blog_controller_test.rb.
Right-click the file and choose Run File. You should see one failure:

This failure is caused by the validations we've added to the Post model as this line from the test_create method doesn't pass any arguments in with the post:
```
    post :create, :post => {}
```
(Note, the first "post" in the line above refers to the HTTP Post method, while ":post" refers to the Post model).

Add required parameters to the empty :post hash:

    post :create, :post => { :title => "Astro", 
                             :body  => "Was loved by George" }

All 8 tests and 25 assertions should now pass.

Testing the post_comment Action

The default tests provide excellent examples on how to create tests for other controller actions. I'll create a new test for the additional controller action we've created since the controller was generated, post_comment:

  def test_post_comment
    xhr :post,                                            # Simulate xml_http_request 
      :post_comment,                                      # the action to call  
      { :comment => { :comment => "What about Jane?" }},  # the parameters to post
      nil,                                                # session variables expected by the action
      { :post_id => 100 }                                 # flash variables expected by the action
              
    assert_response :success
    assert_template '_comment'
    assert_equal 'Comment was successfully added.', flash[:notice]
    assert_equal 'What about Jane?', Comment.find_by_post_id(100).comment
  end

Application Testing (Integration Tests)

Integration tests are used for testing application flow and generally test a scenario of events. The blog application is very simple, but we can still create a test scenario such as creating an entry, viewing the entry, editing the entry and adding a comment.

Integration tests are very much like functional tests, but since they can span multiple controllers you have to pass the controller as well as the action to the HTTP method (e.g., get "/blog/index"). Also, the Rails framework has not created a default integration test file for us, one must first be generated.

Generate an Integration Test named ApplicationUsage.

Add the following test method:

  def test_creating_a_post
    
    # Clear the database tables
    Comment.delete_all  
    Post.delete_all  
    
    # Load the home page
    get "/blog/index"
    assert_response :success
    assert_template "list"
    
    # Load the New post page
    get "/blog/new"
    assert_response :success
    assert_template "new"
    
    # Create a new blog post
    post "/blog/create", :post => { :title => "Integration Test Title", 
                                    :body => "Integration Test Body"}
    assert_response :redirect
    
    # Get the post variable from the controller so we can fetch the generated id
    # which we'll use to get the record.
    post_id = @controller.instance_variable_get(:@post).attributes['id']
    
    # Show the newly created post
    get "/blog/show/#{post_id}"
    assert_response :success
    assert_template "show"
    
    # Edit the post    
    get "/blog/edit/#{post_id}"
    assert_response :success
    assert_template "edit"
    
    # Post the edits    
    post "/blog/update/#{post_id}", :post => { :title => "Integration Test Title Updated", 
                                               :body => "Integration Test Body Updated"}
    assert_response :redirect
    
    # Verify the post exists
    posts = Post.find(:all)
    assert_equal 1, posts.size
    
    # Confirm it's contents
    post = posts[0]    
    assert_equal  "Integration Test Title Updated", post.title
    assert_equal  "Integration Test Body Updated",  post.body
  end

Run the file to execute the test.

You may have noticed that the test above does not test adding a comment. This is because I couldn't figure out how to set the flash from an integration test. Here's the signature for the xhr method I used from the functional test:

xhr(request_method, action, parameters = nil, session = nil, flash = nil)

and here's the signature for the xhr method for integration testing:

xhr(request_method, path, parameters = nil, headers = nil)

And I just don't see a way to set the flash. If anyone knows, please let me know.

Running All Tests

You can run the entire suite of tests by selecting Run > Test "rubyweblog" or right-clicking the project and selecting Test. You'll also see a nice summary at the bottom of the editor window (this summary is there for every test run - it's just more useful in this case because it shows the aggregate of all test runs).

The Completed Application

RubyWebLogTested.zip

References

Agile Web Development with Rails

An Introduction to using AJAX with Rails: Take 2

In my first take on introducing AJAX with Rails, when a new comment is posted to an entry, the entire set of existing comments is replaced with a new set containing the new comment. Although the request is asynchronous, it's still inefficient, especially if the list of comments grows large. Ideally I would just insert the new comment to the bottom of the existing list, and that's what I show here.

Setting Things Up

I'm going to begin where the Building Relationships Between Rails Models tutorial leaves off. Alternatively, you can start from RubyWeblogComments.zip, which is the completed project from that tutorial.

Test the rubyweblog Project

Open the rubyweblog project.
Note, if you are starting with the provided rubyweblog project, you will also need to create the rubyweblog_development database and run the migrations.
Run the project and browse to http://localhost:3000/blog to verify that it works.

The Plan

Currently, when a new comment is added, the entire page - blog entry and comments - are reloaded. Instead, we'll use AJAX to just insert the new comment to the bottom of the list. Just for fun, I will also show you how to apply a visual effect to highlight the most recently added comment.

Preparation

First we're going to move the fragment of rhtml that we want to dynamically insert, that being a single comment, into a partial template.

Open show.rhtml

Cut the following block of code from show.rhtml

<%= h comment.comment %>

  
    Posted on <%= comment.created_at.strftime("%B %d, %Y at %I:%M %p") %>

Create a new RHTML file named _comment and place it in the app\views\blog folder.
Paste in the code you cut above, replacing all existing content in _comment.rhtml.
Return to show.rhtml and insert a call to the partial from where you cut the code. Also, place a
tag with the id of "comments" inside the
- Test your changes. The application should behave as it did before.

Change the POST to an XMLHTTPRequest

First, let's make sure the JavaScript libraries we're going to use are included in our application. Open blog.rhtml and add the following line below the stylesheet_link_tag:
```
 <%= javascript_include_tag :defaults  %>
```
We're passing :defaults as the source because we're going to be using the Prototype and Scriptaculous libraries that come bundled with Rails.
In show.rhtml, change the form_tag, which performs a HTTP POST, to a form_remote_tag, which performs an XMLHTTPRequest, as follows:
```
<% form_remote_tag :url => {:action => "post_comment"} do %>
```
Test. The entire page is no longer reloaded on submit. This is because submit is now performing an XMLHTTPRequest rather that a POST. As a matter of fact, it appears as though nothing has happened. However, if you refresh the browser at this point, you will see the comments are indeed being added.
Open blog_controller.rb and navigate to the post_comment action.
Replace the existing redirect_to method with the following render method:
```
render :update do |page|
  page.insert_html :bottom, 'comments', :partial => 'comment'
  page[:comment_comment].clear
  flash.keep(:post_id)
end
```
The code above is dynamically inserting the _comment.rhtml partial into the bottom of the "comments"
we defined above. It's important to keep the post_id in the flash, otherwise, any additional comments the user decides to insert will have a nil post_id, and will therefore be orphaned (there's no referential integrity defined on the comments table).
Test and our comment should now be dynamically inserted into the bottom of the list.

Apply Visual Effects

The Scriptaculous library comes with a bunch of visual effects. I'm going to apply the highlight effect to the comment just posted. Once in place, you can easily swap in and try out any of the other effects.

Like we did above for the entire comments section, we need to label the comment to which we want to apply the visual effect. We'll do this by adding a unique, deterministic id to each comment - what better than the comment id itself? Open _comment.rhtml and add the following id property to the
element:
```
>
```
Then switch to blog_controller.rb and add the following to the block provided by render :update:
```
page["comment_#{@comment.id}"].visual_effect :highlight, :duration => 3.5
```
Test the end result:

The highlight will appear for 3 1/2 seconds and then fade away.

Troubleshooting

Working with AJAX can be frustrating because when things go wrong you often don't get a notification in the browser (or if you do, it's a bunch of confusing JavaScript). In such cases I found the server output invaluable. For example, if you misspell the partial "comment" above when inserting the html, nothing happens when you click Post to add the comment. However, looking at the server's output shows the following helpful message:

The Completed Application

RubyWeblogAJAX.zip

Brian Leonard's Blog

Introducing The Observatory

OpenSolaris 2008.05: Installing MySQL 5

Install MySQL

Start the MySQL Service

Verify the Installation

OpenSolaris 2008.05: Installing NetBeans 6.1

Step 1: Install the JDK

Step 2: Download NetBeans 6.1

Step 3: Install NetBeans 6.1

Step 4: Launching NetBeans

Resources

OpenSolaris 2008.05: Configuring an External Monitor

Step 1: Generate an xorg.conf File

Step 2: Configure NVIDIA Settings To Run with the Proper Privileges

Step 3: Configure You External Monitor

OpenSolaris 2008.05 Meet the MacBook Pro

What I've Got

What You'll Need

What You Should Know

What I Did

Step 1: Burn the OpenSolaris 2008.05 Live CD

Step 2: Put the Ethernet Drivers on a USB Stick

Step 3: Create a Partition for OpenSolaris 2008.05

Step 4: Install OS X

Step 5: Install rEFIt

Step 6: Change the EFI partition ID

Step 8: Start OpenSolaris and Install the Wired Ethernet Driver

Step 9: Install the Wireless Adapter Driver

Resources

Drag & Drop with Rails

Setting Things Up

Test the Existing rubyweblog Project

The Plan

Step 1: Make the Comments Draggable

Step 2: Add the Trash Icon

Step 3: Make the Trash Icon a Drop Receiver

Step 4: Adding Visual Clues That Something's Happening

The Completed Application

Autovalidation with Rails

Setting Things Up

Creating the Rails Project

Traditional Server Side Validation

Lets Autovalidate

Run with Autovalidate

Troubleshooting

A couple of things that tripped me up

The Completed Application

Blogging for Dollars (and T-Shirts)

Hello Grails!

Setting Things Up

Creating the Grails Project

Creating the Model

Creating the Controller

Run the Application

Adding Another Field

A Friendlier Database Configuration

Validating Input

Customizing the View

Post List

to the following the pagination buttons. In its place put the following:

The Groovy Blog

${post.title}

The Completed Application

Testing Rails Applications

Setting Things Up

Test the RubyWeblog Project

The Plan

Model Testing (Unit Tests)

Create the rubyweblog_test Database

Prepare the Database

Run the Default Unit Test

Test the Validations

Using Fixture Data

Run the Tests

Controller Testing (Functional Tests)

Testing the post_comment Action

Application Testing (Integration Tests)

Running All Tests

The Completed Application