https://github.com/cemeyer2/pidgin-closeoffline/archive/master.zip

Extract that folder, then open a terminal in that directory and run:

# ./install_ubuntu.sh

This should take care of setting up all the dependencies, compiling the plugin, and then installing it to the local user’s plugin directory.

If you care to browse the source code, its available in the downloaded zip file as well as in the github repository at: https://github.com/cemeyer2/pidgin-closeoffline

With almost all cell phone carriers, they offer an email to SMS gateway solution, wherein anyone can send an email with a short message in it to a specific address and it will be converted by the carrier into a text message and sent to your phone. For Sprint, the form is:

10digitnumber@messaging.sprintpcs.com

This is all fine and dandy, except that if you opt in for the enhanced Google Voice integration, that email to SMS gateway no longer will function for your number. There is a common solution posted on the Internet for this problem:

Have Google Voice forward text messages to your GMail account. From Google Voice, send a text message to yourself and wait for it to show up in your inbox. Look at that email and use the from address there as the address to send email to to send SMS to your phone. The problem with this is that Google generates a unique from address for each email it sends out as a text, which ties that from address to a specific recipient, so that threaded conversation can be maintained in Google Voice. Aka, you can save that specific from address and use it from your local GMail account to email texts to yourself, but if you give that email address to someone else, the emails from them will not go through to your phone.

I required a more robust solution, where I could provide a single email address to multiple outside people/services that would act as a gateway into a text message sent to my phone.  Here is my solution:

Requirements:

• a machine that continually is up and runs python
• a dummy GMail account
• a dummy Google Voice account (optional, may be hard to get if you don’t have an extra phone number to tie it to)
• pygooglevoice installed on the server machine (either in a virtualenv or system wide), patched as shown on https://code.google.com/p/pygooglevoice/issues/detail?id=58#c24
• python-daemon installed on the server machine (either in a virtualenv or system wide)

Here is the setup:

Run a python daemon on a machine that monitors the dummy GMail inbox periodically for new mail. When it finds on, it downloads the message, parses out the body text, logs into a Google Voice account, and texts the body of the message to your cell phone. Seem simple enough?

Here is the code for the daemon that I wrote:

'''
Created on Dec 4, 2012

Simple Python daemon that acts as a proxy to forward
emails to a cell phone (for me, my google voice number)

@author: Charlie Meyer <charlie@charliemeyer.net>
'''

import imaplib
import email
from googlevoice import Voice
import logging
import time
from daemon import runner

logger = logging.getLogger("SMSDaemon")
logger.setLevel(logging.INFO)
formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
handler = logging.FileHandler("/var/log/SMSDaemon.log")
handler.setFormatter(formatter)
logger.addHandler(handler)

class EmailReceiver:

    def __init__(self):
        logger.debug("Email Init")
        self.username = "yoursmsdummyaccount@gmail.com" #edit this
        self.password = "smsdummyaccountpassword" #edit this
        self.server = "imap.gmail.com"
        self.port = 993
        self.M = None
        self.response = None

    def login(self):
        logger.debug("IMAP Login")
        self.M = imaplib.IMAP4_SSL(self.server, self.port)
        rc, self.response = self.M.login(self.username, self.password)
        logger.info(self.response)
        logger.debug("IMAP Login complete")
        return rc

    def logout(self):
        logger.debug("IMAP logout")
        self.M.logout()
        logger.debug("Logged out")

    def get_messages(self):
        logger.debug("Getting unread mail")
        self.M.select("INBOX")
        logger.debug("Getting unread count")
        status, response = self.M.status('INBOX', "(UNSEEN)")
        logger.debug("rc="+str(status))
        unreadcount = int(response[0].split()[2].strip(').,]'))
        if unreadcount > 0:
            logger.info("There are "+str(unreadcount)+" unread messages")
        logger.debug("Getting unread mail")
        status, email_ids = self.M.search(None, '(UNSEEN)')
        logger.debug("rc="+str(status))
        messages = []
        for e_id in email_ids[0].split():
            logger.info("Fetching message id="+str(e_id))
            rc, data = self.M.FETCH(e_id, '(RFC822)')
            logger.debug("Fetch complete, rc="+str(rc))
            mail = email.message_from_string(data[0][1])
            for part in mail.walk():
                if part.get_content_maintype() == 'multipart':
                    continue
                if part.get_content_subtype() != 'plain':
                    continue
                payload = part.get_payload()
                logger.info("message: "+str(payload))
                messages.append(payload)
        logger.debug("Mail fetch complete")
        return messages

class SMSSender:

    def __init__(self):
        logger.debug("SMS init")
        self.username = "dummygvoice@gmail.com" #edit this to be either your gvoice account or your dummy one if you have one
        self.password = "password" #edit this
        self.to = "your10digitphonenumber" #edit this
        self.voice = None

    def login(self):
        logger.info("SMS Login")
        self.voice = Voice()
        self.voice.login(self.username, self.password)
        logger.info("SMS Login complete")

    def logout(self):
        logger.info("SMS Logout")
        self.voice.logout()
        logger.info("SMS Logout complete")

    def send_sms(self, message):
        logger.info("Sending message: "+str(message))
        self.voice.send_sms(self.to, message)
        logger.info("Message sent")

class SMSDaemon():

    def __init__(self):
        self.stdin_path = '/dev/null'
        self.stdout_path = '/dev/tty'
        self.stderr_path = '/dev/tty'
        self.pidfile_path =  '/var/run/smsdaemon.pid'
        self.pidfile_timeout = 5

    def run(self):
        while True:
            logger.info("Daemon looping")
            g = EmailReceiver()
            g.login()
            messages = g.get_messages()
            if len(messages) > 0:
                sms = SMSSender()
                sms.login()
                for message in messages:
                    sms.send_sms(message)
                sms.logout()
            g.logout()
            logger.debug("Daemon Sleeping")
            time.sleep(60)

daemon = SMSDaemon()
daemon_runner = runner.DaemonRunner(daemon)
daemon_runner.daemon_context.files_preserve=[handler.stream]
daemon_runner.do_action()

I saved that file in /root/smsdaemon/SMSDaemon.py

I then tested it using:

python SMSDaemon.py start

and sent an email to my dummy gmail account and ensured it arrived as a text message on my phone. The program will log to /var/log/SMSDaemon.log, so you can look there to ensure it is working. Once that works, time to write the init script so it loads on boot.

First, ensure the daemon is stopped:

python SMSDaemon.py stop

Then, add the following to /etc/init.d/smsdaemon

#!/bin/bash
#
# /etc/init.d/smsdaemon
#
### BEGIN INIT INFO
# Provides: smsdaemon
# Required-Start:
# Should-Start:
# Required-Stop:
# Should-Stop:
# Default-Start:  3 5
# Default-Stop:   0 1 2 6
# Short-Description: SMSDaemon process
# Description:    Runs up the SMSDaemon process
### END INIT INFO

# modified from http://www.gavinj.net/2012/06/building-python-daemon-process.html

# uncomment and edit the following line if needed to activate the python virtual environment
# . /path_to_virtualenv/activate

case "$1" in
  start)
    echo "Starting"
    python /root/smsdaemon/SMSDaemon.py start
    ;;
  stop)
    echo "Stopping"
    python /root/smsdaemon/SMSDaemon.py stop
    ;;
  restart)
    echo "Restarting"
    python /root/smsdaemon/SMSDaemon.py restart
    ;;
  *)
    echo "Usage: /etc/init.d/smsdaemon {start|stop|restart}"
    exit 1
    ;;
esac

exit 0

Now:

sudo chmod +x /etc/init.d/smsdaemon
sudo update-rc.d smsdaemon defaults
sudo service smsdaemon start

There you go, all done!

Let me know if this works for you or if you have any comments, I might be looking to port this solution to a compute cloud like the Google App Engine or similar in the future.

ymmv

I am assuming you followed the instructions in the previous post and have created the following symlinks:

lrwxrwxrwx 1 chuck chuck   10 Dec  4 23:24 NUM0 -> tivoircode
lrwxrwxrwx 1 chuck chuck   10 Dec  4 23:24 NUM1 -> tivoircode
lrwxrwxrwx 1 chuck chuck   10 Dec  4 23:24 NUM2 -> tivoircode
lrwxrwxrwx 1 chuck chuck   10 Dec  4 23:24 NUM3 -> tivoircode
lrwxrwxrwx 1 chuck chuck   10 Dec  4 23:24 NUM4 -> tivoircode
lrwxrwxrwx 1 chuck chuck   10 Dec  4 23:24 NUM5 -> tivoircode
lrwxrwxrwx 1 chuck chuck   10 Dec  4 23:24 NUM6 -> tivoircode
lrwxrwxrwx 1 chuck chuck   10 Dec  4 23:24 NUM7 -> tivoircode
lrwxrwxrwx 1 chuck chuck   10 Dec  4 23:25 NUM8 -> tivoircode
lrwxrwxrwx 1 chuck chuck   10 Dec  4 23:25 NUM9 -> tivoircode
lrwxrwxrwx 1 chuck chuck   10 Dec  4 23:32 ENTER -> tivoircode

Now, the goal here is that simply entering the command such as “1695″ will send the sequence NUM1;NUM6;NUM9;NUM5 to the TiVo. This can be accomplished using the same facility that Ubuntu uses to suggest packages to install when you issue a command from a package that is not currently installed. To do this, add the following to your ~/.bashrc:

function is_integer() {
    s=$(echo $1 | tr -d 0-9)
    if [ -z "$s" ]; then
        return 0
    else
        return 1
    fi
}

command_not_found_handle() {
        if is_integer $1; then
                for NUM in `echo $1 | fold -w1`
                do
                        NUM$NUM
                done
#               ENTER
        else
                if [ -x /usr/lib/command-not-found -o -x /usr/share/command-not-found/command-not-found ]; then
                if [ -x /usr/lib/command-not-found ]; then
                   /usr/bin/python /usr/lib/command-not-found -- "$1"
                   return $?
                elif [ -x /usr/share/command-not-found/command-not-found ]; then
                   /usr/bin/python /usr/share/command-not-found/command-not-found -- "$1"
                   return $?
                else
                   printf "%s: command not found\n" "$1" >&2
                   return 127
                fi
                fi

        fi
}

Now, when you enter an numeric integer value on your bash session, it will send it to your TiVo as a series of IR codes for each digit in the number. You can uncomment the final ENTER command if you wish for the enter button to be pressed when a number is finished being entered on the TiVo, but that is up to you. This function copies the body of the command_not_found_handle default function from /etc/bash.bashrc that ships with Ubuntu, so that non-integer commands are sent through the old mechanism and no functionality is lost.

Happy TiVo’ing

This is the solution that I came up with:

Assume that ~/bin is on your PATH

Create ~/bin/tivoircode with the following contents:

#!/usr/bin/env python

#simple python script to send remote IR commands to a TiVo DVR
#this script should never be called directly, but rather via
#symbolic links to it
#
#Written by Charlie Meyer <charlie@charliemeyer.net>
#December 2012

import socket
import sys
import time
import os.path

#set this to the ip address of the tivo to control
tivo_address = "192.168.1.101"

sock = None

def connect():
    global sock
    global tivo_address
    try:
        sock = socket.socket()
        sock.settimeout(5)
        sock.connect((tivo_address, 31339))
        sock.settimeout(None)
    except Exception, msg:
        print msg

def disconnect():
    global sock
    sock.close()

def send_code(code):
    if not sock:
        connect()
    try:
        sock.sendall("IRCODE "+code+"\r")
        time.sleep(0.1)
    except Exception, msg:
        print msg

times = 1;
if(len(sys.argv) > 1):
    times = int(sys.argv[1])

for i in range(0,times):
    send_code(os.path.basename(sys.argv[0]))

disconnect()

This is the base script from which all others will inherit. Obviously you will need to change the variable at the top of the file to point to the IP address of the TiVo which you want to control.

Now, here comes the fun part. There are a series of symbolic links that need to be made. The name of the link is the raw IR code that is sent to the TiVo, and they all link back to the master script we just created. I have not added all of the remote functions to my environment, but rather only the ones that I regularly use:

lrwxrwxrwx 1 chuck chuck   10 Dec  3 21:48 CLEAR -> tivoircode
lrwxrwxrwx 1 chuck chuck   10 Dec  3 21:50 PAUSE -> tivoircode
lrwxrwxrwx 1 chuck chuck   10 Dec  3 21:51 REPLAY -> tivoircode
lrwxrwxrwx 1 chuck chuck   10 Dec  3 21:51 RIGHT -> tivoircode
lrwxrwxrwx 1 chuck chuck   10 Dec  3 21:52 LEFT -> tivoircode
lrwxrwxrwx 1 chuck chuck   10 Dec  3 21:52 UP -> tivoircode
lrwxrwxrwx 1 chuck chuck   10 Dec  3 21:52 DOWN -> tivoircode
lrwxrwxrwx 1 chuck chuck   10 Dec  3 21:54 PLAY -> tivoircode
lrwxrwxrwx 1 chuck chuck   10 Dec  3 21:54 INFO -> tivoircode
lrwxrwxrwx 1 chuck chuck   10 Dec  3 21:55 SELECT -> tivoircode
lrwxrwxrwx 1 chuck chuck   10 Dec  3 21:56 ADVANCE -> tivoircode
lrwxrwxrwx 1 chuck chuck   10 Dec  3 22:02 TIVO -> tivoircode
lrwxrwxrwx 1 chuck chuck   10 Dec  3 22:03 WINDOW -> tivoircode
lrwxrwxrwx 1 chuck chuck   10 Dec  3 22:04 CHANNELUP -> tivoircode
lrwxrwxrwx 1 chuck chuck   10 Dec  3 22:04 CHANNELDOWN -> tivoircode
lrwxrwxrwx 1 chuck chuck   10 Dec  3 22:04 THUMBSDOWN -> tivoircode
lrwxrwxrwx 1 chuck chuck   10 Dec  3 22:04 THUMBSUP -> tivoircode
lrwxrwxrwx 1 chuck chuck   10 Dec  4 18:04 GUIDE -> tivoircode

To create each one of these, use the ln command, such as:

ln -s tivoircode PLAY

to link PLAY to tivoircode

You should now be able to use the command PLAY in your terminal to cause the TiVo to emulate a regular infrared remote control pressing the play button.

Based on research done online, the following IRCODE commands can be symlinked to my tivoricode script and work properly (should be self-explanatory):

UP
DOWN
LEFT
RIGHT
SELECT
TIVO
LIVETV
THUMBSUP
THUMBSDOWN
CHANNELUP
CHANNELDOWN
RECORD
DISPLAY
DIRECTV
NUM0
NUM1
NUM2
NUM3
NUM4
NUM5
NUM6
NUM7
NUM8
NUM9
ENTER
CLEAR
PLAY
PAUSE
SLOW
FORWARD
REVERSE
STANDBY
NOWSHOWING
REPLAY
ADVANCE
DELIMITER
GUIDE

I wanted to make it a little easier for me, since typing PLAY is probably harder than actually just pressing the play button on the physical remote. To solve this, I created a set of bash aliases that map shorthand commands to the symbolic links we just created. Here is what I added to my ~/.bashrc at the bottom:

#TiVO commands
alias info="INFO"
alias cl="CLEAR"
alias pa="PAUSE"
alias pu="PAUSE"
alias replay="REPLAY"
alias rw="REPLAY"
alias re="REPLAY"
alias down="DOWN"
alias d="DOWN"
alias up="UP"
alias u="UP"
alias left="LEFT"
alias l="LEFT"
alias right="RIGHT"
alias r="RIGHT"
alias play="PLAY"
alias pl="PLAY"
alias select="SELECT"
alias sel="SELECT"
alias ff="ADVANCE"
alias skip="ADVANCE"
alias tivo="TIVO"
alias zoom="WINDOW"
alias zm="WINDOW"
alias chup="CHANNELUP"
alias chu="CHANNELUP"
alias pgu="CHANNELUP"
alias pgup="CHANNELUP"
alias chdn="CHANNELDOWN"
alias chd="CHANNELDOWN"
alias pgdn="CHANNELDOWN"
alias pgd="CHANNELDOWN"
alias thumbsup="THUMBSUP"
alias thup="THUMBSUP"
alias thu="THUMBSUP"
alias thumbsdown="THUMBSDOWN"
alias thdn="THUMBSDOWN"
alias thd="THUMBSDOWN"
alias guide="GUIDE"
alias gu="GUIDE"

Now, i can use my TiVo from the konsole (via yakuake) that I always have running using commands such as `ff 6` to fast forward 6×30 seconds, `rw 3` to rewind 3×8 seconds, `pu` to pause, `pl` to play, etc etc etc

shoutout to Alex Lambert for his help pointing out some of the obvious to me

1 large sweet onion, finely chopped
2 carrots, peeled and shredded
1/2-1 lb porcini mushrooms, cleaned and sliced
3/4 lb pancetta, chopped (i get 4 slices at the largest thickness at the deli)
1 wedge fresh parm cheese (the canned stuff is no good here)
1 lb italian sausage
1 large can of crushed tomatoes
1 large can of tomato sauce
2 tiny cans of tomato paste
3-4 roasted red bell peppers in water, drained and pureed in food processor
fresh basil
italian seasoning
salt
sugar
crushed red pepper
olive oil
1 lb bucatini pasta

Carmelize onion in sautee pan olver med-low heat with a bit of olive oil. Set aside. Sautee mushrooms and carrots until soft in olive oil. Set aside. Cook pancetta and italian sausage until pancetta is crispy and sausage is cooked through. Be sure sausage is well broken up into very small pieces. Drain excess fat from pan. In large stock pot, combine combine onions, mushrooms, carrots, meat, tomato sauce, crushed tomatoes, red peppers, tomato paste. Stir to combine. Cut off rind from parm wedge and add to pot. Season with seasonings to taste. I go easy with the sugar until it tastes just right. Simmer over low heat for 3-4 hours to reduce. With 30 mins to go in cooking, add basil. When done, cool and store in fridge.

To serve, cook bucatini for 1 minute less than box suggests. Reserve 1 cup of pasta water. Drain pasta and return to pot it was cooked in. Add 1-2 large scoops of sauce per person that is eating (depending on how saucey you like it). Reheat sauce together with pasta over med heat until sauce is hot and bubbly. The extra time with the sauce will finish cooking the pasta. Serve in bowls. Finely grate top with fresh parm cheese, a drizzle of olive oil, and some chopped basil.

“Pasta is not a castle, therefore it should not be floating in a moat of sauce” -Guy Fieri

Coca-Cola Slow Cooker Pot Roast

Ingredients:

•  1 3-4 lb beef roast
• 1 can cola (350 ml if pouring into measuring cup)
• 1 can cream of mushroom soup
• 1 packet of dry onion soup mix
• (Optional) 4-6 red potatoes
• 2 large carrots, chopped
• 1 package either white button or baby portabello mushrooms, sliced
• 2 stalks celery, chopped
• 1 packet brown gravy mix
• 2 tbsp corn starch

Steps:

1. Trim roast of all excess fat
2. Place roast in slow cooker
3. If desired, quarter potatoes and place around roast
4. Place carrots and celery around roast
5. Place mushrooms around and on top of roast
6. In a large bowl, mix cola, mushroom soup, and onion soup mix until homogeneous
7. Pour liquid mixture on veggies
8. Cook on low setting for 8-9 hours
9. When cooking is complete, place a colander in large sauté pan and pour contents of slow cooker into it
10. Strain all drippings into sauté pan
11. In small bowl or coffee cup, mix cornstarch with 3 tbsp water
12. Heat juices to boiling, add brown gravy mix and cornstarch slurry
13. Wisk continually until gravy thickens

Serve beef with veggies and gravy. I added homemade mashed potatoes along with it, recipe for those follows.

Serves 5-6

Charlie’s/Emily’s Party Potatoes

Ingredients:

• 3-5 large russet potatoes, usually about 1 potato per serving
• Kosher salt to taste
• Black pepper to taste
• Cayenne pepper to taste
• 1 small container low fat/fat free cream cheese
• 1 small container light sour cream
• 1/2 stick margarine/butter (Optional) (i used orville reddenbocker fat free butter flavored popcorn topping seasoning instead)
• 1 packet ranch dressing mix
• (Optional) Paprika

Steps:

1. (Optional) Peel skins from potatoes
2. Cut potatoes into approximately 1 inch cubes and place into large stock pot
3. Cover potatoes with cold water
4. Salt water until the salt is noticeable when tasting
5. Heat pot to boiling
6. Reduce heat and boil until potatoes are fork tender, roughly 45 minutes depending on potato size
7. Drain water and return potatoes to pot
8. Add cream cheese, sour cream, margarine, salt, pepper, cayenne pepper, and ranch dressing packet
9. Beat with hand mixer until smooth and creamy
10. (Optional) Put mashed potatoes in baking dish, top with pads of butter/margarine, sprinkle with paprika or cayenne, and bake for 20-30 minutes

This was an amazing dinner(s) for me, so maybe someone else will find it worthwhile too!

-cem

I hope that this work will only allow my work to be continued in the future and allow for further adoption of my method.

In addition to the week I will be spending in Israel, I will be making a side trip after to Istanbul, Turkey to meet with Professor Barış Aktemur at Özyeğin University there as he is replicating our course. This is the second ever installment worldwide of our programming studio concept, and we are excited to meet with him to discuss how his first semester of the course was as well as share our tips for success and learn from him what we can do to improve our course as well.

I’m looking forward to the trip to Asia very much, but not so much to the 20 hours of travel that it will take to get to Israel as well as the 8 hours of time difference that I will need to adjust to once I arrive. Wish me luck!

class GradientBackground{
  color[] colors;
  int c_alpha;
  
  GradientBackground(color[] t_colors, int t_alpha){
    colors = t_colors;
    c_alpha = t_alpha;
    float w = width;
    int colorWidth = (int)((w / (colors.length-1)));
    int colorHeight = height;
    for(int colorIndex = 0; colorIndex < (colors.length-1); colorIndex++){
      setGradient(colorIndex*colorWidth, 0, colorWidth, colorHeight, colors[colorIndex], colors[colorIndex+1]);    
    }
  }

  void setGradient(int x, int y, float w, float h, color c1, color c2 ){
    float deltaR = red(c2)-red(c1);
    float deltaG = green(c2)-green(c1);
    float deltaB = blue(c2)-blue(c1);
    
    for (int i=y; i<=(y+h); i++){
        for (int j = 1; j<=w; j++){
          color c = color(
            (red(c1)+(j)*(deltaR/w)),
            (green(c1)+(j)*(deltaG/w)),
            (blue(c1)+(j)*(deltaB/w)),
            c_alpha
          );
          stroke(c);
          fill(c);
          //point(j+x, i); //this line is buggy, doesnt work properly with most recent version of processing
          rect(j+x, i,1,1);
      }
    }
  }
}

sudo /etc/init.d/pulseaudio restart

This did not work at all, so I resigned myself to just restart the machine when it happened. With a solid state disk, rebooting takes 30 seconds, so it was not a major pain. But the sound went out again today after only about 2 days, so I decided to see if I could fix things. I decided to run VLC on an audio file from the terminal to induce some error messages. After playing the song for a few seconds, the terminal began to be flooded with messages like:

[0xdf11a0] pulse audio output error: overflow

Aha, it was in fact a pulseaudio problem. So, the following steps fixed my problem.

In a terminal:

sudo killall pulseaudio

Then, Alt+F2, enter pulseaudio in the box, click Run, and boom sound was back in action.

Hope this helps someone.

Here are the slides from the talk I gave this past Monday:

Keep an eye out, more ITiCSE-related posts soon to come.

• Intel Core i7-2820QM Processor (2.30GHz, 8MB L3)
• Dual boot Ubuntu 11.04 64/Windows 7 Professional 64
• 15.6″ FHD (1920 x 1080) LED Backlit Anti-Glare Display
• NVIDIA Quadro 2000M Graphics with 2GB DDR3 Memory
• 16 GB PC3-10600 DDR3 SDRAM 1333MHz SODIMM Memory
• UltraNav with TrackPoint & touchpad plus Fingerprint reader
• 720p Camera
• 750 GB Primary Hard Disk Drive, 7200rpm
• 1 TB Secondary Hard Disk Drive, 5400rpm
• DVD recordable multiburner
• Express Card Slot & 4 in 1 Card Reader
• 9 cell Li-Ion Battery – 55++
• Bluetooth 3.0
• Intel Centrino Ultimate-N 6300 (3×3 AGN)
• 2 USB 3.0 ports
• 1 USB/eSATA
• 1 Powered USB
• Dual digital microphone
• ThinkPad Mini Dock Plus Series 3

I’ve had a blast with this thing so far, and can’t wait to dig into it more. It boots up quicker than you can believe and runs several virtual machines simultaneously with no issues at all. I plan on putting in an Intel 310 Soda Creek PCI-E SSD as soon as they get in stock on Newegg to even juice the performance a bit further. There are only two things I dislike about it thus far: 1. the size of the power adapter, its literally 3x the size of the 90W adapter that came with my T500, but that’s understandable I guess for a 170W adapter 2. The speakers are unusually quiet at full volume, even headphones are quieter than I would have thought them to be.

I dug through the Seaside code a bit and found what I needed to patch. Note here, I only am patching the WAListenerAdaptor since that is the adaptor which supports Comet (which my application makes heavy use of).

Here is the original code:

WAListenerAdaptor>>listenLoop
	| socket |
	socket := Socket newTCP.
	socket 
		listenOn: port
		backlogSize: 50.
	socket isValid ifFalse: [ self error: 'Cannot listen on port ' , port greaseString ].
	
	[ 
	[ socket isValid ifFalse: [ ^ self listenLoop ].
	self waitForConnection: socket ] repeat ] ifCurtailed: 
		[ (Delay forMilliseconds: 10) wait.
		socket destroy ]

And the patched code:

WAListenerAdaptor>>listenLoop
	| socket |
	socket := Socket newTCP.
	socket 
		listenOn: port
		backlogSize: 50
		interface: NetNameResolver loopBackAddress.
	socket isValid ifFalse: [ self error: 'Cannot listen on port ' , port greaseString ].
	
	[ 
	[ socket isValid ifFalse: [ ^ self listenLoop ].
	self waitForConnection: socket ] repeat ] ifCurtailed: 
		[ (Delay forMilliseconds: 10) wait.
		socket destroy ]

Notice how I changed the socket initialization message to include the interface keyword, and supplied it with the loop back address. Now my application is only accessible via 127.0.0.1 or localhost, and not via its external IP.

The alternative would have been to leave the code unpatched and instead write some iptables firewall rules to block on the port the Seaside adaptor is listening on, but this seemed like a simpler solution and allows me to leave the rest of my system untouched. Also, this solution is the only possible way to do it if you do not have root access to the machine to add iptables rules.

Fortunately, our university provides its own kerberos-based authentication solution for applications called Bluestem. It provides the user first with a screen to enter their username, then a second screen to enter their university kerberos password. Upon successful authentication, the user is given access to the proper resources on the server. Bluestem is written in Perl and there exists an Apache module to integrate it with web applications. I previously set up the server I plan to deploy my Seaside application on for Bluestem authentication for other web applications that I host on it, but I did not know of a way that I could use this type of authentication with Seaside since I was planning on using mod_proxy to proxy requests from my external-facing Apache server to my headless Pharo VM.

While I was researching how to do this, I came across an Apache module that someone has posted on Github at https://github.com/aimxhaisse/mod-proxy-add-user which takes the authenticated user name set by Apache and forwards it on to servers being proxied. I was able to compile it (manually, the Makefile appeared to be broken) and get it up and running on my CentOS server within a few minutes. I configured my Apache configuration file with:

<Proxy *>
    Order deny,allow
    Allow from all
    ProxyAddUser On
    ProxyAddUserKey "HTTP_X_FORWARDED_USER"
</Proxy>

And low and behold, I was able to access the authenticated user name in my proxied Seaside application with:

username := self class decodeUserIdFrom: (self requestContext request headerAt: 'http_x_forwarded_user' ifAbsent: [username := 'cemeyer2']).

Let me explain a little bit. In most cases, just self requestContext request headerAt: ‘http_x_forwarded_user’ will give you the authenticated user name, but our university’s kerberos solution sets this variable to ‘username@uiuc.edu/kerberos’, so the decodeUserIdFrom message strips off everything but the user name. The above line also is useful for when accessing the application when not being proxied behind university authentication (such as during development), as it will default to return my user name if the header is not found.

I decided to use the smalltalk LDAPLayer package to allow me to do what I needed to do. First order of business was to set up a way to do encrypted connections to the LDAP server. The LDAPLayer package does not support SSL connections out of the box (as far as i could tell), so rather than try to modify the source to allow it, I decided to run a local stunnel instance on my machine to provide a SSL proxy to the directory:

sudo stunnel -c -d 389 -r ad.uiuc.edu:636

I then can connect to localhost on the regular LDAP port, 389, and it will be securely tunneled to our campus’ Active Directory cluster.

The next step was to write an authenticator that would do the actual authentication. Mine turned out to look something like:

LDAPAuthenticator>>#verifyPassword: aPassword forUser: aUsername
	| dn req tempConn |
	aPassword ifNil: [^false].
	aPassword ifNil: [^false].
	dn := self getDNForUsername: aUsername .
	tempConn := LDAPConnection
		to: self class hostname
		port: self class port.
	req := tempConn
		bindAs: dn
		credentials: aPassword.
	[req wait] on: LDAPException do: [ :exception | tempConn disconnect. ^false ].
	tempConn disconnect.
	^true

I also implemented LDAPAuthenticator>>#getDNForUsername which converts a username into a fully qualified distinguished name for binding to the directory with. In addition, LDAPAuthenticator class>>#hostname and LDAPAuthenticator class>>#port return localhost and 139 respectively. It is important to note that the message implemented has to exactly match #verifyPassword:forUsername: and the message also needs to respond with false if either are nil (it was a bug that threw me off for a bit). Then its simply a matter of tying it all together in the initialize method of the application’s root component:

initialize
	"self initialize"
	| app authFilter |
	app := (WAAdmin register: self asApplicationAt: 'mypath')
		addLibrary: PTDeploymentLibrary;
		addLibrary: SUDeploymentLibrary;
		addLibrary: CTLibrary;
		yourself.
	app preferenceAt: #sessionClass put: MyCustomSession.
	authFilter := WAAuthenticationFilter new.
	authFilter realm: 'Active Directory. Use your username and Active Directory Password'.
	authFilter authenticator: LDAPAuthenticator new.
	app addFilter: authFilter .

Once that is complete, authentication works like a charm. Of course I could modify the authenticator to only allow members of certain groups, etc, but for my needs, letting anyone with valid credentials is quite alright. I also wanted to tie a user object representing the logged in user to my custom session, so I did the following to get the username of the authenticated user in my overridden #initialrequest in my root component:

username := self requestContext request user.

That took care of the whole mess for me…

Issue #1: Page never appears to finish loading

I was able to get basic comet up and running rather quickly, but I noticed when I loaded the page, the browser would continue to appear as if the page was constantly loading. This was because of the way that the Seaside book instructs you to add the comet script to your page. The book example code looks like:

html script: (html comet
     pusher: self class pusher;
     connect)

Assuming:

MyComponent class>>#pusher
     ^pusher ifNil: [ pusher := CTPusher new ]

What this actually does is place a block of JavaScript code in the generated HTML that the browser immediately executes in the foreground when it encounters it. Due to the nature of the comet implementation that Seaside provides (streaming), the browser immediately opens up an asynchronous connection to the Seaside server and streams from it, stopping the browser from doing anything else. This is why it appears to constantly be loading. The proper way to add comet to a Seaside application is as follows:

html document
    addLoadScript: (html comet
    pusher: self class pusher;
    connect)

This causes the browser to start up the comet streaming connection when the page has finished loading, and in the background. Thus the page will appear to the end user as if it is completely loaded, even though the streaming comet connection is open.

Issue #2: Using comet with a custom session

I still haven’t solved this error yet, but hopefully I will soon, so while I wait to hear back from the Seaside mailing list, I’ll describe the kludge I put in to make it work right.

For my application, I needed a custom subclass of WASession to hold on to information about the logged in user. Unfortunately, when I used this session class with comet, things broke. On the first request of a new session, I would constantly get stacktraces like:

It appears as if the parent of my custom session was never being set to the WAApplication instance that it should have been. It only happened on the first request of the session, and all subsequent comet interactions worked as expected. I thought I could fix this problem by overriding initialize in my custom session, but that did not work:

initialize
    ^super initialize

So, I posted my question to the Seaside mailing list and am still awaiting a response. In the meantime, I have added a “patch” to CTHandler>>notifySession to change it from:

notifySession
    self session application cache
        notifyRetrieved: self session
        key: self session key

to:

notifySession
    [self session application cache
        notifyRetrieved: self session
        key: self session key]
    on: MessageNotUnderstood do: [:error | ]

This basically attempts to run the old notifySession code, but when the MessageNotUnderstood error is raised, it simply ignores it and continues on with execution. I know this is not the best practice, but it does make the application work as expected.

Issue #3: Duplicated JavaScript code sent to clients

I didn’t notice this bug until I used FireBug and took a look at the JS that Seaside was generating from my Smalltalk code and streaming to the clients. What I found out, much to my surprise, was that every single JavaScript action that I had coded once in SmallTalk was being sent over the wire twice, both identical. This took a bit to trace down, but again it had to do with inadequate examples from the Seaside book. The Seaside book makes use of jQuery for all of its work with comet (as do the comet examples that come with Seaside itself), and I had chosen to use Prototype/Scriptaculous for my application, so this is where the issue might have arisen.

Say you wanted to push some JavaScript that would set the contents of the div element with id=’peanut’ to be ‘butter’. The Seaside book and examples led me to believe that using Scriptaculous/Prototype, the code should look like:

pushToClient
    self class pusher
        javascript: [ :script |
            script <<  (script scriptaculous element
                id:'peanut';
                update: 'butter').
        ].

But this actually causes the div to be updated twice in rapid succession, both to the same thing. It was completely unnoticeable on the client side, but it was extra overhead being executed on the client browser as well as extra unnecessary data being sent over the wire.

Thanks to the fantastic debugger built into Pharo, I was able to trace down the problem and rewrite the above code as follows:

pushToClient
    self class pusher
        javascript: [ :script |
            script scriptaculous element
                id:'peanut';
                update: 'butter'.
        ].

The script variable is an instance of a JSScript object, and the #<< message means to append the argument onto its list of JavaScript statements. What I found was that when using the JSScript>>scriptaculous message, it was already appending the generated JavaScript statements onto the JSScript, so the #<< message was simply redundant. Eliminating all usages of #<< in my comet code fixed the error and everything works as expected now.

Issue #4: Conditionally pushing to clients

In my application, I have regular users and administrators. They are defined as such based on what type of object is attached to the custom session I wrote for the project. There are certain elements on my pages that only appear for regular users and certain elements that only appear for administrators, as well as a large number of elements that appear in both. I wanted to use a single comet pusher to be able to push to both regular users as well as administrators, to reduce connection overhead in the final deployed version of the application. Having a separate CTPusher for regular users and a separate one for administrators would have worked, but would have been painful. I wanted something a little cleaner. So I did some hacking on the comet source that comes with seaside and this is what I came up with (added):

javascript: aBlock forHandlers: handlerBlock
	"Evaluate aBlock with an JSScript instance and pushes the resulting script-string aString to
	handlers which when evaluated as the argument to handlerBlock causes it to return true."

	| script |
	script := (JSScript context: self renderContext)
		rendererClass: self rendererClass;
		yourself.
	aBlock value: script.
	self push: (String streamContents: [ :stream |
		stream
			nextPutAll: '<script type="text/javascript">parent.Comet.eval(';
			javascript: script asJavascript;
			nextPutAll: ')</script>' ])
		forHandlers: handlerBlock

And:

push: aString forHandlers: aBlock
	"Push aString to handlers which when passed as the argument to aBlock causes
	it to return true."
	| pushHandlers |
	pushHandlers := handlers select: aBlock.
	self mutex critical: [ pushHandlers do: [ :each | each push: aString ] ]

I do realize that this does not do exactly what the plain CTHandler>>#push message does. Namely, it does not prune down the handlers list to ensure that only the connected ones continue to receive updates from the server, but in my application I do mostly regular pushes with only a few requiring the handlers block, so I feel like I am pretty much safe for now. So now, using the code I added, if I want to update the div on the page with id ‘peanut’ to contain the text ‘butter’ for regular users, but to ‘jelly’ for administrators, its quite simple:

pushToClient
    self class pusher
        javascript: [ :script |
            script scriptaculous element
                id:'peanut';
                update: 'butter'.
        ] forHandlers: [ :handler | handler session user isRegularUser ].
    self class pusher
        javascript: [ :script |
            script scriptaculous element
                id:'peanut';
                update: 'jelly'.
        ] forHandlers: [ :handler | handler session user isAdministrator ].

So those are my notes on using comet with Seaside thus far. Overall its been a lot of fun watching something really complex come together in such a short period of time. Next, when I get time, I’ll post about how I was able to get custom basic authentication working using LDAP in Seaside.

credits to the tux factory

The main motivating factor was the new version of Mercurial became very irritating when pushing/pulling/cloning/etc from a remote https repository where the certificate was not able to be validated:

chuck@silverstone:~/Documents/cs433$ hg push --insecure https://charliemeyer.net/hg/cs433
warning: charliemeyer.net certificate with fingerprint b0:f2:09:06:87:32:b1:8d:cc:7f:51:09:07:28:44:45:8d:86:f8:fd not verified (check hostfingerprints or web.cacerts config setting)
http authorization required
realm: charliemeyer.net authentication
user: cemeyer2
password: 
warning: charliemeyer.net certificate with fingerprint b0:f2:09:06:87:32:b1:8d:cc:7f:51:09:07:28:44:45:8d:86:f8:fd not verified (check hostfingerprints or web.cacerts config setting)
pushing to https://charliemeyer.net/hg/cs433
warning: charliemeyer.net certificate with fingerprint b0:f2:09:06:87:32:b1:8d:cc:7f:51:09:07:28:44:45:8d:86:f8:fd not verified (check hostfingerprints or web.cacerts config setting)
warning: charliemeyer.net certificate with fingerprint b0:f2:09:06:87:32:b1:8d:cc:7f:51:09:07:28:44:45:8d:86:f8:fd not verified (check hostfingerprints or web.cacerts config setting)
searching for changes
warning: charliemeyer.net certificate with fingerprint b0:f2:09:06:87:32:b1:8d:cc:7f:51:09:07:28:44:45:8d:86:f8:fd not verified (check hostfingerprints or web.cacerts config setting)
bundling changes [ <=>                                                                                                                                                                                           ] 0
warning: charliemeyer.net certificate with fingerprint b0:f2:09:06:87:32:b1:8d:cc:7f:51:09:07:28:44:45:8d:86:f8:fd not verified (check hostfingerprints or web.cacerts config setting)
remote: adding changesets
remote: adding manifests
remote: adding file changes
remote: added 2 changesets with 3 changes to 3 files

As you can see from above, not only is the extra noise irritating, but I also have to append “–insecure” to all of my commands. I know I could have modified my hgrc and imported my self-signed certificate, but I already had my global hgrc set up to recognize properly signed repositories:

[web]
cacerts = /etc/ssl/certs/ca-certificates.crt

I do a lot of work with remote hg repositories that do have valid certificates, but also a lot of work with hg repositories on this server, enough work that I didn’t want to import the self-signed certificate for each hgrc file in each clone of a repository I have on every one of machines. Plus, when I go to other machines, it would take a lot of unnecessary configuration just to get it to work properly.

So, to ease the irritation that Mercurial was causing, this server can now be accessed using a “more secure” https than before:

chuck@silverstone:~/Documents/cs433$ hg incoming
comparing with https://cemeyer2:***@charliemeyer.net/hg/cs433
searching for changes
no changes found

component.setFont(DEFAULT_FONT);

called on it. I did some searching on the Internet and realized this could all be avoided with a simple routine run before initializing the entire GUI:

private static void setDefaultFont() {
        Enumeration keys = UIManager.getDefaults().keys();
        while (keys.hasMoreElements()) {
            Object key = keys.nextElement();
            Object value = UIManager.get(key);
            if (value instanceof javax.swing.plaf.FontUIResource) {
                UIManager.put(key, DEFAULT_FONT);
            }
        }
    }

This has worked extremely well and reduced our complexity cost for maintaining and enhancing the application.

To extract the first instance of a given piece of text between string start and string end in string content:

For example, start=”www.”, end=”.com”, content=”www.facebook.com links to www.google.com” and I want to select out “facebook”:

SUBSTRING( 
MAX( content ) , 
LOCATE(start,content)+LENGTH(start), 
LOCATE(end, content, LOCATE(start, content)+LENGTH(start)) - LOCATE(start, content) - LENGTH(start)
)

For example:

mysql> SELECT
    -> @content:="www.facebook.com links to www.google.com",
    -> @start:="www.",
    -> @finish:=".com",
    -> SUBSTRING( 
    -> @content , 
    -> LOCATE(@start, @content)+LENGTH(@start), 
    -> LOCATE(@finish, @content, LOCATE(@start, @content)+LENGTH(@start)) - LOCATE(@start, @content)- LENGTH(@start)
    -> ) AS extracted;
+------------------------------------------------------+----------------+-----------------+-----------+
| @content:="www.facebook.com links to www.google.com" | @start:="www." | @finish:=".com" | extracted |
+------------------------------------------------------+----------------+-----------------+-----------+
| www.facebook.com links to www.google.com             | www.           | .com            | facebook  | 
+------------------------------------------------------+----------------+-----------------+-----------+
1 row in set (0.00 sec)

And of course when creating a view, its always best to cast the columns to the proper types so they can be effectively queried, which is as easy as:

CAST( col AS type)

For example:

mysql> SELECT @text:="  0438t", CAST( @text AS DECIMAL);
+------------------+-------------------------+
| @text:="  0438t" | CAST( @text AS DECIMAL) |
+------------------+-------------------------+
|   0438t          |                     438 | 
+------------------+-------------------------+
1 row in set (0.00 sec)

I will be the first to admit this is not the most efficient use of the database, but it works (and I can cast the values) and it can easily be queried when used as a view.

ldap_auth.py:

import ldap

def authenticate(netid, password):
    server = "ldaps://ad.uiuc.edu:636"
    who = "CN="+netid+",OU=Campus Accounts,DC=ad,DC=uiuc,DC=edu"
    try:
        conn = ldap.initialize(server)
        ldap.set_option( ldap.OPT_X_TLS_DEMAND, True )
        ldap.set_option(ldap.OPT_X_TLS_REQUIRE_CERT,ldap.OPT_X_TLS_NEVER)
        result = conn.simple_bind_s(who,password)
    except ldap.LDAPError, e:
        return False
    conn.unbind()
    return True

print authenticate("cemeyer2", "password")

That’s it. As mentioned in my earlier post, I’m pretty sure that any application that authenticates this way would be looked down upon by CITES since the application in question would potentially be able to sniff user login information, so please only use this code in a personal testing environment, not for a deployed application unless approved by people much higher up than me.

LDAPAuth.java:

import java.util.Hashtable;

import javax.naming.NamingEnumeration;
import javax.naming.NamingException;
import javax.naming.directory.SearchControls;
import javax.naming.directory.SearchResult;
import javax.naming.ldap.InitialLdapContext;
import javax.naming.ldap.LdapContext;

public class LDAPAuth {

	public static void main(String[] args)
	{
		System.out.println(authenticate("cemeyer2","password"));
	}

	public static boolean authenticate(String netid, String password)
	{
		String userDN = findUserDN(netid);
		try
		{
			LdapContext ctx = createLDAPContext(userDN, password);
			ctx.close();
			return true;
		}
		catch(Exception e)
		{
			return false;
		}
	}

	private static String findUserDN(String netid)
	{
		return "CN="+netid+",OU=Campus Accounts,DC=ad,DC=uiuc,DC=edu";
	}

	private static LdapContext createLDAPContext(String bindDN, String bindPassword) throws NamingException
	{
		Hashtable env = new Hashtable();
		env.put("java.naming.factory.initial", "com.sun.jndi.ldap.LdapCtxFactory");
		env.put("java.naming.provider.url", "ldaps://ad.uiuc.edu/");
		env.put("java.naming.ldap.factory.socket", "TrustAllSSLSocketFactory");
		env.put("java.naming.security.protocol", "ssl");
		env.put("java.naming.security.principal", bindDN);
		env.put("java.naming.security.credentials", bindPassword);
		env.put("java.naming.security.authentication", "simple");
		env.put("com.sun.jndi.ldap.connect.pool", "true");
		LdapContext context = new InitialLdapContext(env, null);
		return context;
	}
}

And in the same package (default package in this example), TrustAllSSLSocketFactory.java:

import java.io.IOException;
import java.net.InetAddress;
import java.net.Socket;
import java.security.SecureRandom;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;

import javax.net.SocketFactory;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSocketFactory;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;

public class TrustAllSSLSocketFactory extends SSLSocketFactory
{
    private static class TrustAllTrustManager
        implements X509TrustManager
    {

        public void checkClientTrusted(X509Certificate ax509certificate[], String s1)
            throws CertificateException
        {
        }

        public void checkServerTrusted(X509Certificate ax509certificate[], String s1)
            throws CertificateException
        {
        }

        public X509Certificate[] getAcceptedIssuers()
        {
            return new X509Certificate[0];
        }

        private TrustAllTrustManager()
        {
        }

    }

    public TrustAllSSLSocketFactory()
    {
        try
        {
            SSLContext sslcontent = SSLContext.getInstance("TLS");
            sslcontent.init(null, new TrustManager[] {
                new TrustAllTrustManager()
            }, new SecureRandom());
            _factory = sslcontent.getSocketFactory();
        }
        catch(Throwable t)
        {
        	//do nothing
        }
    }

    public static SocketFactory getDefault()
    {
        return new TrustAllSSLSocketFactory();
    }

    public Socket createSocket(Socket socket, String s, int i, boolean flag)
        throws IOException
    {
        return _factory.createSocket(socket, s, i, flag);
    }

    public Socket createSocket(InetAddress inaddr, int i, InetAddress inaddr2, int j)
        throws IOException
    {
        return _factory.createSocket(inaddr, i, inaddr2, j);
    }

    public Socket createSocket(InetAddress inaddr, int i)
        throws IOException
    {
        return _factory.createSocket(inaddr, i);
    }

    public Socket createSocket(String s, int i, InetAddress inaddr, int j)
        throws IOException
    {
        return _factory.createSocket(s, i, inaddr, j);
    }

    public Socket createSocket(String s, int i)
        throws IOException
    {
        return _factory.createSocket(s, i);
    }

    public String[] getDefaultCipherSuites()
    {
        return _factory.getSupportedCipherSuites();
    }

    public String[] getSupportedCipherSuites()
    {
        return _factory.getSupportedCipherSuites();
    }

    private SSLSocketFactory _factory;

}

Once that’s done, using the static LDAPAuth.authenticate() method will allow you to authenticate users against UIUC Active Directory over LDAPS without the need for an AD service account. But I’m pretty sure that any application that authenticates this way would be looked down upon by CITES since the application in question would potentially be able to sniff user login information, so please only use this code in a personal testing environment, not for a deployed application unless approved by people much higher up than me.

Good Luck!

Without going into too much detail, I worked on a test automation team. Through the course of the summer, I designed and built a test suite composed of approximately 90 different functional test cases using Rational tools. While there was some learning curve, my previous experience with IBM POWER hardware from my previous co-op with IBM and my experience with the Eclipse Framework was invaluable. All in all, it was a great experience.

I’m sure though that if you talk to most graduate students in Computer Science, almost none of them will say they want a career path that is pure coding like I did this summer and I would tend to agree with that statement. For me at least, that is part of the reason that I am pursuing graduate school, because I want something more than just writing code for the next however many years. But in the future, I would love to come back to Austin in some capacity, hopefully for IBM again.

Long story short, Java projects in Eclipse have a source location and a binary location. The binary location is where source files are compiled to so that they can be executed. One of the common actions in Eclipse is to “clean” a project, which erases all of the compiled files and recompiles everything from scratch. This is particularly useful to improve the performance of binaries due to penalties incurred by incremental compilation. The problem I ran into was that my destination folder for compilation was the same as my source folder, which seems innocent enough to me. Why not store compiled files alongside their source counterparts? But when I went to clean the project, Eclipse decided to erase everything in the binary folders, including all of my source files. It would seem to me that the proper behavior would be to only delete files deemed to be generated by the build engine. Luckily, I had most of my work backed up in source control and on network shares, so not much was lost, but it was still very irritating.

RFT is based on Eclipse 3.3 or 3.4, I don’t remember which, but not a recent version, so I’m not sure if this is present in the current release (Helios). But I plan to investigate later when I have some time to burn…

DNS might take a little bit to propagate through the system, but the AAAA records are in place.

So far, I have only restored basic services on this machine such as the basic LAMP stack for WordPress and such, but I’ll get SVN, Mercurial, Git, Tomcat, NX, SFTP, my Pylons applications, and such back up later this week. Stay tuned.

I previously wrote about how to install the AT&T network client on Ubuntu 10.04 x64. If you are an IBM employee, the next logical step is to install lotus sametime for instant messaging. Luckily, at one point in time IBM produced deb files for debian-like distributions that can still be used on 10.04. For this, i will assume that you have already followed the instructions to install the global network client, including installing getlibs.

First, download sametime 7.51 blue from http://pokgsa.ibm.com/projects/l/lud/pool/stable/s/sametime-blue/sametime-blue_7.5.1.20070416-4_i386.deb

Then run `sudo apt-get install libmotif3` and then `sudo getlibs -p libmotif3`

The next dependency is lib32stdc++5, so to install it you first have to add a ppa to your apt repositories using the command `sudo apt-add-repository ppa:jason-scheunemann/ppa`

You can then `sudo apt-get update` and then `sudo apt-get install lib32stdc++5`

Next you have to install the 64 bit version, so `wget http://mirrors.kernel.org/ubuntu/pool/universe/g/gcc-3.3/libstdc++5_3.3.6-17ubuntu1_amd64.deb` then `sudo dpkg -i libstdc++5_3.3.6-17ubuntu1_amd64.deb`

Lastly, `sudo dpkg -i –force-architecture sametime-blue_7.5.1.20070416-4_i386.deb`

Sametime should now show up in the applications menu under the other category. You can sign in using your IBM intranet id and password, although due to some library problems that I have not yet solved, certain preferences (such as password saving and location setting) do not work. Ill update this post if I end up solving these issues.

As always, YMMV. Good luck!

I’ve been working on this project now for a couple of years and have seen some of the lengths that students will go to to cheat. Being involved in this arena has led me to become very interested in how students cheat, why students cheat, and ways to detecting it. I came across this article today on slashdot that piqued my attention. Although this article has nothing to do with plagiarizing programming assignments, it nonetheless reminded me of what some will do to slide by in school. If you take a few minutes to peruse http://www.vworker.com, I am positive that you will be able to find some cleverly disguised homework assignments that programmers from around the world are bidding on to complete, even when their terms of service disallow these types of projects.

These hired-out homework assignments, at least in the computer science world, are in my opinion the toughest kind of plagiarism to detect automatically. Sure a manual inspection will bring it to light pretty quick, but in some of the classes we do analysis on there are 200-300 students, so a manual inspection of each assignment is just not feasible. At least for now, it appears that given the right circumstances, if students are willing to pay the cash anything is possible.

Here are the steps that I came up with that worked for me:

• make sure you have the 32 bit compatibility package installed, `sudo apt-get install ia32-libs` will do the trick
• Install getlibs from http://frozenfox.freehostia.com/cappy/getlibs-all.deb
• Download the client from agnclient-2.0.1-ubuntu
• Unzip the file
• from the command line, install all three packages using `sudo dpkg –force-all -i <package.deb>` – I installed agnclient_1.0.1-1_i386.deb first, then the gtk package, then the dev package
• Use getlibs to install the necessary libraries. I only needed libssl, so I did `sudo getlibs -p libssl0.9.8`
• I then had to create some symbolic links so that the client would work properly, so in /lib32, i ran `sudo ln -s libssl.so.0.9.8 libssl.so.4` and `sudo ln -s libcrypto.so.0.9.8 libcrypto.so.4`
• To verify that everything works properly, I checked the linking of the various programs to ensure that they were linking against the proper libraries, here is what I got
• chuck@silverstone:/opt/agns/bin$ ldd NetVPN
  linux-gate.so.1 =>  (0xf7727000)
  libpthread.so.0 => /lib32/libpthread.so.0 (0xf76e5000)
  libssl.so.4 => /lib32/libssl.so.4 (0xf769f000)
  libcrypto.so.4 => /lib32/libcrypto.so.4 (0xf754b000)
  libdl.so.2 => /lib32/libdl.so.2 (0xf7547000)
  libc.so.6 => /lib32/libc.so.6 (0xf73ed000)
  /lib/ld-linux.so.2 (0xf7728000)
  libz.so.1 => /usr/lib32/libz.so.1 (0xf73d8000)
• chuck@silverstone:/opt/agns/bin$ ldd agnclient
  linux-gate.so.1 =>  (0xf773b000)
  libagnLogc.so.1 => /opt/agns/lib/libagnLogc.so.1 (0xf7736000)
  libagnc.so.1 => /opt/agns/lib/libagnc.so.1 (0xf772c000)
  libpthread.so.0 => /lib32/libpthread.so.0 (0xf76ec000)
  libm.so.6 => /lib32/libm.so.6 (0xf76c6000)
  libdl.so.2 => /lib32/libdl.so.2 (0xf76c2000)
  libgtk-x11-2.0.so.0 => /usr/lib32/libgtk-x11-2.0.so.0 (0xf72ed000)
  libgdk-x11-2.0.so.0 => /usr/lib32/libgdk-x11-2.0.so.0 (0xf7257000)
  libatk-1.0.so.0 => /usr/lib32/libatk-1.0.so.0 (0xf723a000)
  libgdk_pixbuf-2.0.so.0 => /usr/lib32/libgdk_pixbuf-2.0.so.0 (0xf7220000)
  libpangoxft-1.0.so.0 => /usr/lib32/libpangoxft-1.0.so.0 (0xf7218000)
  libpangox-1.0.so.0 => /usr/lib32/libpangox-1.0.so.0 (0xf720b000)
  libpango-1.0.so.0 => /usr/lib32/libpango-1.0.so.0 (0xf71c8000)
  libgobject-2.0.so.0 => /usr/lib32/libgobject-2.0.so.0 (0xf7188000)
  libgmodule-2.0.so.0 => /usr/lib32/libgmodule-2.0.so.0 (0xf7183000)
  libgthread-2.0.so.0 => /usr/lib32/libgthread-2.0.so.0 (0xf717d000)
  libglib-2.0.so.0 => /lib32/libglib-2.0.so.0 (0xf70b3000)
  libxml2.so.2 => /usr/lib32/libxml2.so.2 (0xf6f89000)
  libc.so.6 => /lib32/libc.so.6 (0xf6e2e000)
  /lib/ld-linux.so.2 (0xf773c000)
  libpangocairo-1.0.so.0 => /usr/lib32/libpangocairo-1.0.so.0 (0xf6e22000)
  libX11.so.6 => /usr/lib32/libX11.so.6 (0xf6d05000)
  libXcomposite.so.1 => /usr/lib32/libXcomposite.so.1 (0xf6d01000)
  libXdamage.so.1 => /usr/lib32/libXdamage.so.1 (0xf6cfd000)
  libXfixes.so.3 => /usr/lib32/libXfixes.so.3 (0xf6cf6000)
  libcairo.so.2 => /usr/lib32/libcairo.so.2 (0xf6c7c000)
  libgio-2.0.so.0 => /usr/lib32/libgio-2.0.so.0 (0xf6bde000)
  libpangoft2-1.0.so.0 => /usr/lib32/libpangoft2-1.0.so.0 (0xf6bb7000)
  libfreetype.so.6 => /usr/lib32/libfreetype.so.6 (0xf6b41000)
  libfontconfig.so.1 => /usr/lib32/libfontconfig.so.1 (0xf6b10000)
  librt.so.1 => /lib32/librt.so.1 (0xf6b07000)
  libXext.so.6 => /usr/lib32/libXext.so.6 (0xf6af7000)
  libXrender.so.1 => /usr/lib32/libXrender.so.1 (0xf6aed000)
  libXinerama.so.1 => /usr/lib32/libXinerama.so.1 (0xf6ae9000)
  libXi.so.6 => /usr/lib32/libXi.so.6 (0xf6ada000)
  libXrandr.so.2 => /usr/lib32/libXrandr.so.2 (0xf6ad2000)
  libXcursor.so.1 => /usr/lib32/libXcursor.so.1 (0xf6ac8000)
  libXft.so.2 => /usr/lib32/libXft.so.2 (0xf6ab4000)
  libz.so.1 => /usr/lib32/libz.so.1 (0xf6a9f000)
  libpcre.so.3 => /lib32/libpcre.so.3 (0xf6a6d000)
  libxcb.so.1 => /usr/lib32/libxcb.so.1 (0xf6a53000)
  libpixman-1.so.0 => /usr/lib32/libpixman-1.so.0 (0xf69f9000)
  libdirectfb-1.2.so.0 => /usr/lib32/libdirectfb-1.2.so.0 (0xf6982000)
  libfusion-1.2.so.0 => /usr/lib32/libfusion-1.2.so.0 (0xf6978000)
  libdirect-1.2.so.0 => /usr/lib32/libdirect-1.2.so.0 (0xf6961000)
  libpng12.so.0 => /lib32/libpng12.so.0 (0xf693c000)
  libxcb-render-util.so.0 => /usr/lib32/libxcb-render-util.so.0 (0xf6937000)
  libxcb-render.so.0 => /usr/lib32/libxcb-render.so.0 (0xf692f000)
  libresolv.so.2 => /lib32/libresolv.so.2 (0xf691b000)
  libselinux.so.1 => /lib32/libselinux.so.1 (0xf68ff000)
  libexpat.so.1 => /lib32/libexpat.so.1 (0xf68d8000)
  libXau.so.6 => /usr/lib32/libXau.so.6 (0xf68d4000)
  libXdmcp.so.6 => /usr/lib32/libXdmcp.so.6 (0xf68ce000)
• you might need to install additional libraries, use getlibs to do it as shown above (my system had some libraries on it before I started the install that yours might not have)
• restart the daemon with `sudo /etc/init.d/agnclientd restart`
• try opening the client from the applications menu under the internet category and connecting
• If something goes wrong, check the logs in /var/log/agns

Good Luck!

Bug #1 in Ubuntu: “Microsoft has a majority market share”

Above is the welcome screen, which is innocent enough. Nothing major here to report that personally makes my life difficult. I just felt that it would be too one-sided if all I did was complain. Now, lets get on to the stuff that makes you wonder why was this done?

What we have here is my first example of non-standard widgets that cause me problems. If you look at the screenshot carefully, you might notice two places that seem perfectly normal at first but at closer inspection are just not quite right. Were you thinking about the check box in the table and the drop down combo box in the upper right corner? These widgets are actually images that are manipulated with fancy Javascript to appear as normal as possible. The tools we are using support standard widgets, things built with input tags, fancy JS is just a pain to test. Plus, imho, it makes the interface feel much more sluggish. Every time one of these widgets is manipulated there is a definite delay before any feedback is presented to the user.

Now, let’s get on to another example. In the images below, there is another example of a drop down combo box that is implemented purely with image tags and Javascript. What is worse about this particular example, is that upon changing the value of the combo box, the entire page reloads to fill in the new value. This is because the combo box options are implemented by hyperlinks that when clicked, redirect the browser to a new page that has the previously clicked link as the selected option.

Now its not that I am angry with the way this was designed or that I am overly critical of it, but it raises the question, are the standard widgets that we are provided by our programming APIs sufficient for most uses? On the internet, I would say that overwhelmingly the widgets that are built into the browser are fantastic for 95% of whats out there. I mean, realistically, how often do you see someone reinventing a textbox with some Javascript ninja magic. The answer: never. Why? Because the ones built into the browser are already good enough at what they do. Alright alright, some things just cannot be done with standard widgets in a web browser, things like date pickers and sliders, but why reinvent the wheel when it is not necessary? The only thing that I could think of for this particular case was that using homegrown widgets improved cross-browser compatibility in some way that I couldn’t imagine. If I find out the answer to this question, I’ll try to remember to put it up here.

But back to my basic question, are when are standard widgets not enough? I guess there are lots of times the more I think about it, but lots of times in a sea the size of an ocean is still a limited amount. Then that also raises the question, what does it take to consider a widget to be “standard”? All the major web browsers implement the widgets slightly differently, especially between different platforms. And take Java for instance, built into the language are two widget libraries, AWT and Swing, which I would argue are Java’s “standard” widgets. But there exists a popular add on library confusingly named the Standard Widget Toolkit (SWT), so what is a newcomer to think? I think Ill come back to this question later.

My one overwhelming gripe about all the Rational software is that it is all based on Eclipse. Yes I know, IBM originally wrote Eclipse and donated it as open source, but Eclipse is a resource hog that tends to quickly run out of control. Rational Functional Tester, Rational Performance Tester, Rational Team Concert Client, Rational Software Modeler, and more are all Eclipsed based. Oh, and as if that wasn’t enough, so is the installer for each of them (add that to the Eclipsed-based Lotus Symphony that IBM has us use for office documents and Eclipse-based Lotus Notes for email and collaboration, and my laptop is out of memory before I can even start coding). Whats worse in my opinion, is that as you incrementally install each Rational Tool, they build on each other into some mega Eclipse monstrosity rather than stay separate as their own installs. This beast then takes forever to load, oh yeah, and a lot more memory to run.

Rational Functional Tester: All I can say is, it does the job, but makes it painful. Ever since I started writing software, user interfaces were always the most challenging aspects to test. Simulating clicking on something, checking the appearance of a window, etc is no small task, which is why I have seen several project groups that I have mentored at school resort to manual testing for this kind of thing. RFT allows a developer to write functional “test scripts” in Java or VB.net which guide RFT to interact with another application. One great aspect of RFT is that, well only on Windows, it has a recorder feature which allows the developer to interact with the software and have RFT record what was done. The developer can also insert checkpoints into the recording where he can instruct RFT to compare various attributes of objects in the application to baseline readings to judge if a test passed or not. Another handy feature I wish I had back when I was working on AS400s is the ability to test command line applications and terminal applications both on System Z mainframes and IBM i 5250 green screens. But enough of the good stuff, heres what I’m not so fond of…..First off, let me say that I use RFT purely for testing web applications, so this experience is only based on RFT’s ability to work with the webapps that I am trying to test. So, my biggest gripe with RFT is a lack of consistency. Often times when I’m writing up a test script, I have code that I am positive will work, but it just plain wont. So ill restart the browser under test, sometimes that will fix it, or Ill restart RFT, sometimes that works, but most often I end up rebooting my entire machine to fix some stupid error. Oh yeah, Im working on windows testing using IE6, so that may have a lot to do with it, but RFT should be better. Second problem, RFT doesnt support many browsers. Hence why we are using IE6 at work (because the webapp under test doesnt behave well with firefox, sigh). Next, although the recorder is great for simple tests, it just isnt powerful enough to do many of the tests that we want to do, so we code every test script by hand, which leads me to my final gripe….Horrible API. I won’t even sugarcoat it, its not fun at all to deal with. In my opinion, it is far to generalized and leave the burden on the developer to do most of the work. There is even an internal IBM project which has developed a layer that sits on top of the RFT API and exposes a simpler API for webapp testers, but this layer doesnt cover everything. It can take 30-40 lines of code just to find a hyperlink on a webpage and click on it. Not cool. So overall, RFT is alright, it does the job, but can be a pain to work with. Ill try to update here more over the next few weeks with my impressions of the other Rational tools I’m using.