Being able to add some sort of client/server model to your programs is pretty essential these days, and Ruby does a fine job making your life easier.

For this article, I’ll show you a quick, down-and-dirty way of getting a very simple server up and running and a client that will say “Hello Server World” and disconnect. You will, of course, need Ruby installed, for Ubuntu users

sudo apt-get install ruby

and for Fedora users

sudo yum install ruby

Now, the first plan of action for a client/server assignment is to map out what exactly you want to occur. Setting those expectations in comments before you even think about code a good practice and will make your life a whole lot easier. That being said, let’s start with the server, by adding the following to a file we’ll name server.rb:

#establish server
#setup to listen and accept connections
#start new thread conversation
#reply with goodbye
#end loop

Now let’s do the same thing for the client script but name it client.rb

#establish connection
#send a quick message
#wait for messages from the server
#if one of the messages contains 'Goodbye' we'll disconnect
#end loop

Okay, now, lets get coding. There is only one requirement for writing these scripts, you will need to add:

require 'socket'

to the top of your script so that you have access to the TCPServer class. The TCPServer constructor needs at least port number, so I’ll set it up with port 2008. Also, we want to be able to have the server allow many clients to connect so we will need some sort of Thread structure built in to handle multiple requests. We will then accept any incoming TCP connections on port, 2008 say “Welcome” to the client, and wait for any response.” To keep this tutorial short, the server will be implemented in a forever loop that constantly listens for connections. Edit your server.rb file to follow what I’ve outlined above (I’ve used ## to denote comments further explaining what is going on) :

#!/usr/bin/ruby
require 'socket'

puts "Starting up server..."

# establish the server
## Server established to listen for connections on port 2008
server = TCPServer.new(2008)

# setup to listen and accept connections
while (session = server.accept)

 #start new thread conversation
 ## Here we will establish a new thread for a connection client
 Thread.start do

   ## I want to be sure to output something on the server side
   ## to show that there has been a connection
   puts "log: Connection from #{session.peeraddr[2]} at
          #{session.peeraddr[3]}"
   puts "log: got input from client"

   ## lets see what the client has to say by grabbing the input
   ## then display it. Please note that the session.gets will look
   ## for an end of line character "\n" before moving forward.
   input = session.gets
   puts input

   ## Lets respond with a nice warm welcome message
   session.puts "Server: Welcome #{session.peeraddr[2]}\n"

   # reply with goodbye
   ## now lets end the session since all we wanted to do is
   ## acknowledge the client
   puts "log: sending goodbye"
   session.puts "Server: Goodbye\n"

 end  #end thread conversation
end   #end loop

Cool, the server is written. If you run this script, it won’t look like much so lets just let it go for now. The client is pretty simple, we just want to say Hello, wait for any messages back from our super sophisticated server, and disconnect if the server says ‘Goodbye’.

Modify your client.rb file to look something like this:

#!/usr/bin/ruby
require 'socket'

# establish connection
## We need to tell the client where to connect
## Conveniently it is on localhost at port 2008!
clientSession = TCPSocket.new( "localhost", 2008 )

puts "log: starting connection"

#send a quick message
## Note that this has a carriage return. Remember our server
## uses the method gets() to get input back from the server.
puts "log: saying hello"
clientSession.puts "Client: Hello Server World!\n"

#wait for messages from the server
## You've sent your message, now we need to make sure
## the session isn't closed, spit out any messages the server
## has to say, and check to see if any of those messages
## contain 'Goodbye'. If they do we can close the connection
 while !(clientSession.closed?) &&
          (serverMessage = clientSession.gets)
  ## lets output our server messages
  puts serverMessage

  #if one of the messages contains 'Goodbye' we'll disconnect
  ## we disconnect by 'closing' the session.
  if serverMessage.include?("Goodbye")
   puts "log: closing connection"
   clientSession.close
  end
 end #end loop

Now open up two terminal sessions, and, from the directory you were editing your client and server scripts from, run them.

Localhost Terminal Session 1

~$ ruby server.rb
Starting up server...
log: Connection from localhost at ::1
log: got input from client
Client: Hello Server World!
log: sending goodbye

Localhost Terminal Session 2

~$ ruby client.rb
log: starting connection
log: saying hello
Server: Welcome localhost
Server: Goodbye
log: closing connection
~$

Of course the server running in terminal session 1 will continue running until you hit Control-C to stop it. If you have port 2008 open, you should now be able to run the client script from a remote computer if you change ‘localhost’ to the ipaddress of your server. My server resides at “192.168.0.127″ and my client resides at “192.168.0.141″. I modified the ‘clientSession” line to look like this:

clientSession = TCPSocket.new( "192.168.0.127", 2008 )

Then, I ran this across my small network and saw:

on Server Side terminal:

macbook:~ presenter$ ruby server.rb
Starting up server...
log: Connection from sparta at 192.168.0.141
log: got input from client
Client: Hello Server World!
log: sending goodbye

on Client side terminal:

codenomad@sparta:~$ ruby client.rb
log: starting connection
log: saying hello
Server: Welcome sparta
Server: Goodbye
log: closing connection
codenomad@sparta:~$

Now, if you really wanted to add some more features, try adding the ability to respond to messages sent by the client in the server script or try to raise or rescue exceptions when a connection is lost. You can see the types of exceptions that TCPServer raises here under either Unix-based Exceptions or Windows Exceptions. Good luck with creating your client/server app, and happy coding!

For those whose music is encoded in ogg or FLAC, well, Floola can also convert these formats so that they are playable on the iPod. You can even manage the notes on your iPod. The greatest part is that the software is cross platform and runs on Windows, Mac OS X, and Linux. If you are running Ubuntu you will need either libxine or gstreamer and libstdc++5 (for notifications you’ll need libnotify as well). These can all be installed pretty easy by running:

sudo apt-get install libstdc++5 libxine1 libnotify-bin

After that completes you can grab the Floola download here

You will then need to unzip the archive and copy to your /usr/bin. Assuming you downloaded it to the desktop you can issue these commands:

~/Desktop$ tar -xvzf Floola-linux.tar.gz
~/Desktop$ cd Floola-linux/
~/Desktop/Floola-linux$ sudo cp Floola /usr/bin/

Be sure your ipod is plugged in and now you can run it:

~$ Floola

The first time you run Floola you will need to go through a simple setup:

Select your iPod version:

And now you are good to go:

You like Floola? Let us know what you think!

AjaXplorer is quite a unique tool, and if you haven’t heard of it you might want to check out the latest 2.3.8 version. Essentially, AjaXplorer creates a web-based file manager using, you guessed it, Ajax. You can upload and view files, edit text files, create folders, and move or rename files and folders. Standard stuff maybe, but the beauty is that it can all be done from within your web browser at home, at work, or on the road. The setup is pretty easy, all you need is a working Apache server with PHP support. From Ubuntu you can enter:

~$ sudo apt-get install php5 apache2 libapache2-mod-php5

Then, go grab the latest version. Then you will need to unzip the contents of the file and put it into the Apache web folder.

~$ unzip ajaxplorer-core-2.3.8-dist.zip
~$ sudo mv AjaXplorer-2.3.8/ /var/www/explorer

We need to change some permissions on the files folder and on the server folder. These folders need to be writable, and we’ll restart apache to make sure everything is in place.

~$ sudo chmod -R 777 /var/www/explorer/files
~$ sudo chmod -R 777 /var/www/explorer/server
~$ sudo /etc/init.d/apache2 restart

Now you can check to make sure it is here by clicking http://localhost/explorer. As soon as the AjaXplorer loads you should be prompted to change your default admin password from ‘admin’. After doing that you can start to setup your repositories and users. Now this setup might be good enough for an internal trusted network, but I would recommend that anything done over the open web should be encrypted. Luckily AjaXplorer also kept this in mind and has a bit of documentation on how to set that up in section 8.7 of their F.A.Q. You will also need to be sure to restrict access to

/var/www/explorer/server/conf

and

/var/www/explorer/server/users

as soon as you have completed your configuration. According to the website, AjaXplorer uses .htaccess files to protect these directories. The interface is pretty easy to navigate, though there are still a few interface bugs.  You can see some screenshots below of my tests using Firefox 3, Camino 1.6.5, and Safari 3.2.

One of the coolest features is the ability to use a MySQL database as your ‘repository’.

If you are creative there are a lot of great things you can do with this, like manage a dynamic photo album’s pictures or even use the explorer as a type of collaboration tool. Check it out and let us know what you think!

ClamTk just released the latest version of their frontend to Clam AntiVirus which “brings back the Debian builds.”

If you’ve never heard of Clam AntiVirus (aka ClamAV) before it is an Open Source antivirus solution for Linux. Over the years ClamAV has gained much popularity, and has been used by many companies small and big alike to scan incoming email. With ClamTk you can harness this power on the desktop, and with the new 4.04 release you are only a dpk -i away from trying it out, sort of…

As the homepage states ClamTk 4.04 is the first 4.x release to have a Debian package. That being said the latest version hasn’t hit the repositories. If you are running Ubuntu or Debian you can still try out the latest version of ClamTk by grabbing a copy here.

Be sure to install gtk2-perl to satisfy dependencies by running

sudo apt-get install libgtk2-perl

Then you can install the .deb package by running

sudo dpkg -i clamtk_4.04-1_all.deb

Check it out, and let us know what you think!

So, after thousands of lines of code you’ve managed to build an awesome, feature rich program, and you are really to label it 1.0. You want to bring in more developers because it is doing so great… What do you do? Well, regardless of whether you have hit 1.0, version control is something that should be considered from a project’s inception. It will allow you to collaborate and share code with a team, or the world. That being said, how does one set up control versioning? Enter Subversion, this article will show you how-to setup a subversion server and Eclipse for sharing? Read on!

If you are running Ubuntu, the install is fast and easy.

codenomad@sparta:~$ sudo apt-get install subversion

If you are running Fedora, you have a simple one line command as well:

codenomad@sparta:~$ sudo yum install subversion

(Note: There is also a good graphical front-end to subversion for KDE called kdesvn that allows you to create and manage subversion repositories. For now, lets do this the command line way, it’s pretty easy.)

We are now ready to start. You must first create a repository to store all of your configuration files for subversion, and, of course, your code. I like keeping server information in my /var directory so lets create a subdirectory for subversion:

codenomad@sparta:~$ sudo mkdir -p /var/subversion/

Now lets add the repository (Note: Standard security practices should be considered here. I’m creating a directory that I can have access to without requiring admin privileges):

codenomad@sparta:~$ sudo chown codenomad subversion
codenomad@sparta:~$ chmod 755 subversion
codenomad@sparta:~$ svnadmin create /var/subversion/my_project

This should setup everything you need to get started. Go into the /var/subversion/my_project/conf folder and you should see some files:

codenomad@sparta:/var/subversion/my_project$ cd conf
codenomad@sparta:/var/subversion/my_project/conf$ ls
authz  passwd  svnserve.conf
codenomad@sparta:/var/subversion/my_project/conf$

You will need to modify the passwd and svnserve.conf file with the usernames and passwords of those who need to have access to the repository. First, lets modify the passwd file. Since the ‘#’ are comment lines, lets remove those and add a user name (I will use codenomad as my username and supersecret as my password) :

### This file is an example password file for svnserve.
### Its format is similar to that of svnserve.conf. As shown in the
### example below it contains one section labelled [users].
### The name and password for each user follow, one account per line.

[users]
# harry = harryssecret
# sally = sallyssecret

should now look something like this:

### This file is an example password file for svnserve.
### Its format is similar to that of svnserve.conf. As shown in the
### example below it contains one section labelled [users].
### The name and password for each user follow, one account per line.

[users]
codenomad = supersecret

Now we need to modify the svnserve.conf file. This file allows you to edit all the server specifics. For this situation we will need to give authorization to codenomad and tell subversion to look for the user information (the user password) in the passwd file. Looking at this file, you will note there is a [general] section. This is where you need to give authorization to your users.

My section looks like:

[general]
### These options control access to the repository for unauthenticated
### and authenticated users.  Valid values are "write", "read",
### and "none".  The sample settings below are the defaults.
codenomad = write
# anon-access = read
# auth-access = write

Just below the access section, uncomment this line:

password-db = passwd

NOTE: Be sure when you make these modifcations, there should be NO spaces at the beginning of the lines. In other words, the c in codenomad lines up with the very first space of the file. This will cause problems later on if you don’t take care

Now we can start the svn server in daemon mode giving it the root directory of our project:

 svnserve -d -r /var/subversion/my_project/

Everything is now setup from the subversion side!

Since I use Eclipse for a good majority of my work I’ll use this new repository to house “My_Project”. If you don’t already have the Subversive plugin installed in Eclipse, go to Help > Software Updates. Then from there, select the Available software tab, Click on Ganymede, and then expand Collaboration Tools. Select all the Subversive packages

Then, on the right, you’ll need to click “Add site” and enter the plugin connectors information from Polarion’s website:

http://www.polarion.org/projects/subversive/download/eclipse/2.0/update-site

This is needed to be able to connect to your subversion repository in Eclipse. Hit okay, then select all the packages in that list:

Next, hit install, accept the agreements, and then say okay to restart Eclipse. Eclipse should then be ready to go and will be able to share your files. Right click on your Project, select Team, and then select Share Project.

Give the repository information (for this case it will be localhost since I am developing on the same box I am serving from).

Enter your username and password that you stored in the passwd file in the next window. Then, to promote good practice, enter in a detailed message about the code you are about to commit.

If you tweak your router settings or your firewall, you should be able to give access to others outside of your network and not just on this box. For that you should open up or forward external 3690 to your box. When all is said and done, you should have your project stored in a repository available to share with others! Happy Coding!

While configuring a firewall is by far the best way to secure your system, there are times when you need a way to access a remote server that doesn’t compromise security.

A quick fix for boxes that need to be in the De Militarized Zone (DMZ) for a short period of time is to modify your hosts.deny and hosts.allow files, normally located in the /etc directory. Simply, and as you can probably gather from the filenames, the files will either deny or allow access to servers running on your box. The hosts.deny allows you to specify hostnames, IP addresses, or domains you wish to deny access and the hosts.allow will let you allow access.

For a quick, down and dirty configuration denying all access to your box make sure your /etc/hosts.deny has the following:

ALL: ALL

With this simple addition your /etc/hosts.deny should look similar to this:

# /etc/hosts.deny: list of hosts that are _not_ allowed to access the system.
#                  See the manual pages hosts_access(5) and hosts_options(5).
#
# Example:    ALL: some.host.name, .some.domain
#             ALL EXCEPT in.fingerd: other.host.name, .other.domain
#
# If you're going to protect the portmapper use the name "portmap" for the
# daemon name. Remember that you can only use the keyword "ALL" and IP
# addresses (NOT host or domain names) for the portmapper, as well as for
# rpc.mountd (the NFS mount daemon). See portmap(8) and rpc.mountd(8)
# for further information.
#
# The PARANOID wildcard matches any host whose name does not match its
# address.

# You may wish to enable this to ensure any programs that don't
# validate looked up hostnames still leave understandable logs. In past
# versions of Debian this has been the default.
# ALL: PARANOID
ALL:ALL

Note: Similar to shell scripts the “#” is a comment line.  Also be sure to add an extra blank line at the bottom of the file.

Moving on, the hosts.allow has a lot more power with the default configuration because it will override anything that is listed in the hosts.deny file. Please take care to note the previous statement because the more information you know about which networks or IP’s you want to have access to your box the better. For now, lets say I want to connect to my computer at home when I am at work.  Before we can start, you’ll have to make sure your home server is placed in the DMZ area of your network.  Most routers have this feature built in so please check your manual for the specifics.

Let’s get started. At work I have the IP address 65.0.12.4. Since I only need SSH access from this location I can add

SSHD : 65.0.12.4

Of course, I use my laptop at work and there are a pool of IP addresses that I can potentially get, in other words, I might not always get the same address ‘65.0.12.4′. So what can we do? Well, the hosts.allow file also gives you the ability to specify a complete domain. I can give access to systems at mycompany.com by adding the following:

SSHD : .mycompany.com

Lets modify the /etc/hosts.allow file. Yours should look similar to this:

# /etc/hosts.allow: list of hosts that are allowed to access the system.
#                   See the manual pages hosts_access(5) and hosts_options(5).
#
# Example:    ALL: LOCAL @some_netgroup
#             ALL: .foobar.edu EXCEPT terminalserver.foobar.edu
#
# If you're going to protect the portmapper use the name "portmap" for the
# daemon name. Remember that you can only use the keyword "ALL" and IP
# addresses (NOT host or domain names) for the portmapper, as well as for
# rpc.mountd (the NFS mount daemon). See portmap(8) and rpc.mountd(8)
# for further information.
#
SSHD : 65.0.12.4, .mycompany.com

Now I have access from any of the IP addresses that are from my company’s domain. This should give you the basic idea of how to restrict services on a remote server with these files. With a little more Google searching you should be able to find that you can restrict access to different types of servers as long as they are ‘wrapped’ by TCP. In other words, pretty much any service compiled with the libwrap.a library can be restricted using this method.

You can read more about the hosts.allow and hosts.deny by looking at their manpages by entering the following in a terminal:

~$ man hosts.allow

or

~$ man hosts.deny

Of course this is not meant as a full time solution, but it does offer a quick fix for boxes that are on the open net for a limited time. Try it out, and let us know how it goes!

If you have ever wanted to have access to your personal music collection from anywhere on the road Sockso Personal Music Server just might be the answer you were looking for. All that is required for the installation is Java and a Windows, Linux, or Mac box to run the server on. The software has both a GUI for controlling the server, and a web interface for accessing your music remotely.  The software seems pretty robust, and is incredibly easy to set up.  Inside the zip file there is a batch file for double-clickability in Windows, a shell script that needs to be made executable for Linux or Unix, and an executable Jar for double-clickability in Mac OS X.

Both the web and server gui interfaces are pretty straight forward, and have quite a few features.  The server gui allows you to add Collections of music, create playlists, restricting access to users or to features like uploading music, and it even gives you the ability to specify an encoder for re-encoding your music for slower connections or for compatibility.

The web interface can be seen below with the Sockso flash player along with a view of the Sockso server gui in Linux, and a custom playlist.

If you’ve ever wanted a quick, easy way to setup a music server, or to just be able to have access to your personal music collection while on the road, Sockso might be a solution worth looking into.  It is lightweight, multi platform, and easy to use.  Just be sure to forward port 4444 from your router to your Sockso server, start up Sockso and you are good to go.  I haven’t seen an easier Open Source and multiplatform solution yet!

Check it out and let us know what you think!

If you have ever been involved in setting up a small to mid size network that requires full access to roadwarriors, the ability to detect intrusions, and the need for a firewall, then you will know that it is no easy task. The commercial cost of this alone is enough to consume your entire budget for the network, and quite possibly, eat into the budget you need to buy the computers to run on the network. Try asking for that from a startup that can barely afford the computers! Of course, there are many opensource solutions that can give you all of what you need for free, but with a one man IT shop expect many long nights and truck loads of hot pockets.

There is a quick and very cheap alternative: Untangle. Offering quite possibly the best free network solutions I have seen thus far, Untangle is the one stop shop for any networking requirement. From VPN to intrusion detection, Untangle offers the best of the open source community and rolls it up into a very nice package that is easy to manage. The interface is clean, and each open source offering is presented as a rack mount server.

Below you can see a wide variety of offerings (taken straight from their site) that are available for free, and some commercial offerings that help make the most of your Untangle server.

Don’t have a server to spare?  Not a problem, virtualization is the key.  Not only did the Untangle team spend countless hours creating such a seamless, feature rich product that encompasses some of the best of the open source world (and a few pay for goodies), they went the extra mile and wrote an amazing tutorial on how to get Untangle up and running in a virtual environment here.

Check it out, and let us know what you think!!

Dealing with exceptions is a big part of any object oriented programmer’s job. We need to be able to recover from things like connect failures or syntax errors, and do so gracefully. Thankfully, raising and “rescuing” exceptions in Ruby is a fairly easy task. Let’s start with a basic example. We all know that dividing by zero is a very bad thing, so lets tackle that scenario.

For fun let’s test this scenario out in irb. If you didn’t know already, irb is a ruby shell that allows you to execute ruby code on a line-per-line basis and is a great way of checking those one-liners. Lets fire it up and give you a very brief exposure to it.

Note: Ubuntu/Debian users, if you don’t have irb you can install it simply by running:

sudo apt-get install irb

On to the goods… Open up your favorite terminal session and type in the following into an irb session:

i=1
i/0

Your output should look like this:

codenomad@sparta:~$ irb
irb(main):001:0> i=1
=> 1
irb(main):002:0> i/0
ZeroDivisionError: divided by 0
  from (irb):2:in `/'
  from (irb):2

As you can see you can assign values to a variable, and perform a quick operation on it in irb. You can go ahead and quit irb by typing in “quit”, and we’ll start writing a script to catch this troublemaking scenario.

Handing exceptions in Ruby is referred to as “Rescuing”. In Ruby to rescue exceptions we need to surround our trouble code with a begin/end statement. Below you’ll find that I’ve surrounded our divide by zero scenario by this begin/end structure, and rescued the exception by putting a rescue clause right before the ‘end’. Add the following to a file called rescue.rb:

#!/usr/bin/ruby
begin
  i = 1
  i/0
  rescue ZeroDivisionError
    puts "you divided by zero putts"
end

Make the file executable and let’s run it:

~$ chmod +x rescue.rb
~$ ./rescue.rb
you divided by zero putts
~$

What if you just wanted to rescue any type of standard error? Well, lets modify our script again to rescue a file open error using StandardError:

#!/usr/bin/ruby
begin
  i = 1
  File.open("ABSsdt.xyz")
  i/0
  rescue ZeroDivisionError
    puts "you divided by zero putz"
  rescue StandardError
    puts "you had an error of some sort"
end

Run it, and you should get something like this:

~$ ./rescue.rb
you had an error of some sort

Be sure to check the Ruby documentation when writing your code, and you can see what exceptions can be through by different method calls. (ie look at the Array.fetch() method call. )

Now that you know how to rescue exceptions and where to look for the types of exceptions a method call can make, what about raising exceptions? Well, thats just as easy lets make a new script named raise.rb and add the following:

#!/usr/bin/ruby
begin
 if (File.exist? "file_1.rb")
  puts "file found"
 else
  raise "File not found"
 end
end

If you don’t have file_1.rb in your running directory, this code will raise an exception! It’s as easy as that! For a quick list of exceptions check out Zenspider’s QuickRef site. At this point you have a basic idea of how to handle exceptions, whether you raise them or rescue them, in Ruby. Get out there and get scripting, and be sure to let us know how it goes!

$ sudo apt-get install sun-java6-jdk

I really like to have full control over my development environments, so I’m not going to grab Tomcat using apt (besides, I said the latest version). Go ahead and grab a zipped copy of the core distribution from the Tomcat website. Now that you have the latest and greatest lets unzip the contents of your .zip into a /usr/local/tomcat folder.

~$ unzip apache-tomcat-6.0.18.zip
~$ sudo mv apache-tomcat-6.0.18 /usr/local/tomcat

Now, before we can start the Tomcat server, we’ll need to make some of the script files executable (note: if you downloaded the tar.gz archive instead, these scripts might already have the executable bit on. To avoid any potential snags, I’d issue these regardless of which compressed file you downloaded).

~$ cd /usr/local/tomcat/bin
~$ sudo chmod +x *.sh

Since I’d like to check out the neat framework demo ZK has, I need to be able to deploy their WAR in my webapps.  To make deploying point and click, I’ll be using the Tomcat Manager. If you want to use the Tomcat Manager you’ll need to modify the users and roles specified in the tomcat-users.xml file located in the /usr/local/tomcat/conf folder. Modify this xml file to have something similar to what is below.  Be sure to change username to something more creative and change the password (I don’t suggest using your real password considering this is a flat file). The file should contains something like this;

<tomcat-users>
  <role rolename="manager"/>
  <role rolename="tomcat"/>
  <role rolename="admin"/>
  <user username="codenomad" password="supersecret" roles="tomcat,admin,manager"/>
  <user username="admin" password="secret" roles="manager,admin"/>
</tomcat-users>

That should just about do it. Let’s start up the server by running:

~$ sudo /usr/local/tomcat/bin/startup.sh

You can test your install by clicking here. You should see something like this:

If you need to shutdown the server you can issue a similar command:

~$ sudo /usr/local/tomcat/bin/shutdown.sh

Now that we have Tomcat installed, lets check out that ZK demo I was talking about. First, you’ll need a couple things. You’ll need the ZK binary and the ZK demo. Download both of those here.

Unzip those files and copy the .jar’s over to your Tomcat library (this will allow you to include all of the greatness that is ZK in your future webapps).

~$ unzip zk-bin-prof-3.5.1.zip
~$ unzip zk-demo-3.5.1.zip
~$ cd zk-bin-prof-3.5.1/dist/lib
~$ sudo cp *.jar /usr/local/tomcat/lib/
~$ sudo cp ext/*.jar /usr/local/tomcat/lib
~$ sudo cp zkforge/*.jar /usr/local/tomcat/lib

Next, you’ll have to restart your Tomcat server:

~$ sudo /usr/local/tomcat/bin/shutdown.sh
~$ sudo /usr/local/tomcat/bin/startup.sh

Head back to the Tomcat page here, and click on the Tomcat Manager link in the top left. Enter in the username and password you modified in the XML file above, and scroll to the very bottom where it says “WAR file to deploy”. Click browse, and find the zkdemo.war file in the unzipped zk-demo-3.5.1 folder that was unzipped earlier.

Next, click on the Deploy button. You should see that the zkdemo is now in the Applications list, and if you click on the link that Tomcat provides you’ll get a welcome screen:

Thats it! You have a fully functional Tomcat Server, and you can start developing with the ZK platform! Check out ZK’s site for more development information. Good luck, and happy coding!

A savvy scripter could get similar features using these tools, but space for maintain backups can really become an issue. From my experience, there are 3 main gui driving projects out there: Timevault, Flyback, and Back-In-Time.

TimeVault, an integrated, and advanced backup utility that is currently in launchpad for Ubuntu, offers features comparable to Time Machine. It includes pop up notifications and a snapshot browser that allows you to filter search results.  On top of that you are even given a graphical representation of a file change at the very top of the snapshot browser.

For those wishing everything to be maintained by the Operating System, this seems like a pretty solid choice and doesn’t skimp on the details when needed.  It is probably the best bet when looking for a solution that is system integrated, and for those looking to come as close to Apple’s Time Machine as possible (minus the eyecandy).

Above you can see a screenshot of TimeVault’s snapshot browser, including the aforementioned representation of file changes.  The next couple of solutions feel a bit more hands on, that’s probably because they don’t have the tight system integration that TimeVault does.

Flyback and Back-In-Time are the two other frontends I spoke of.  Using rsync and cron to maintain backups, they both maintain pretty similar features.

Both applications have snapshot capabilities, and have the basic usermode backup where a filesystems/folder with write permission can be backed up and restored. Their main windows are pretty straight forward and give you the standard views of timestamped snapshots for a given folder structure.

Each application can schedule when a backup is to take place and when backups are deleted. Of course you don’t want all those /tmp files so each application gives you the ability to enter exclude parameters for backups.

It all comes down to preference, and with multiple products out we have the best thing possible: choice.

While TimeVault offers features comparable to Time Machine and system integration, Flyback and Back-In-Time might be easier to dive into for some homebrew modifications.  You can check out TimeVault here, Back-In-Time here, or Flyback here.

Over the past couple of weeks I’ve dabbled with the idea to add a webcam to my personal site that monitored a couple of pet furballs. The task was not too straight forward. I ran into many hiccups with alpha software and missing libraries. Most of the software related to setting up a webcam server was severely outdated, and hadn’t received an update in many months. I tried camE and webcam (the two most standard daemon webcam servers), but they required far more thought in the security realm than I would have liked to invest in the project.

Minutes from assuming all was lost, I ran into a nice little piece of software named Palantir (yes, after that crystal ball thing in Lord of the Rings). The program was built with performance in mind, and can handle a fair load with old hardware. Offering streaming pix, sound, and even the ability to control (assuming you have the hardware) the motion of a camera, my search was finally at an end.

Adding a stream to my website was as easy as embedding an image in my webserver index.html file, and starting up the Palantir server. All you need is the address of the box running the server, and modifying the following line (replacing the 192.168.0.20 ip with your server’s address):

<img border="1" src="http://192.168.0.20:3000/" alt="[Live stream]">

You instantly have a live feed that will stay alive for the default 120 seconds. The project also gives you the ability to use a stand alone client instead of a browser to stream your shots (choose from a native QT linux app, a Java app, or even a Windows app).

You can see a demo stream where the above snapshot was taken at the Palantir site here. Check it out, and let us know what you think!

polishlinux.org has put together a great sneak-peak at the current incarnation of what will become KDE 4.2 directly from the SVN repo.

Overall 4.2 is looking to be a natural evolution to 4.1, which was a surprising leap over 4.0 from a user’s perspective given how disappointingly 4.0 was received from the end-user community (4.0 laid all the technical groundwork for the infrastructure, but still had a lot of UI rough edges that were all ironed out in 4.1).

Dolphin has gotten some minor tweaks and enhancements to make it a better everyday file manager like GNOME has or Finder, leaving Konqueror to be the browser (or advanced file manager for folks that liked that more complex interface).

Improvements to Konqueror include back-ported SVG support from WebKit along with KJS (KDE JavaScript Engine) and KHTML (KDE HTML Rendering Engine) seeing improvements inline with the WebKit work as well to improve rendering speed.

Okular has replaced KPDF as the default viewer for PDF, CHM, DJVU and graphic files.

Improvements to the Plasma manager and it’s embeddable components, Plasmoids, has been done but there are still instabilities there. Kickoff4 can be integrated as a Plasmoid and has some additional searching enhancements (that are a little wonky right now).

The author, Piotr, recommends people wait for the 4.2.1 release of KDE if they are planning on switching. This author cannot help but appreciate the irony of that statement given he has read that, and adhered to it, since he first got into Linux almost 10 years ago… “XYZ is looking awesome, but wait for the patch release ABC…”

As far as I can tell, Linux has been almost great on the desktop for 10 years, but continues to loose the battle against Audio, Video and Gaming which keeps it out of the mainstream every single time.

I also fully expect 100 people to tell me why I’m wrong… I was one of you from 1998 until about 2005 when I finally realized that Linux would never really be dominant on the desktop because it cannot deliver what the majority of people want.

That’s not saying it doesn’t deliver a great experience to some people… those people will post here rabidl about why it’s superior, but it still cannot deliver the experience that most people want.

I’d suggest waiting for the patch release

First, lets explain what a namespace is. In my previous article, I described a namespace as a tool shed that can house many tools. If you exist in the too shed you have the ability to use a hammer object or a saw object that exist in the same shed. You can have multiple sheds, and even sheds within sheds. Now that you understand the concept here is the basic example:

using System;
class MyCoolApp
{
    public class System { }

    public static void Main()
    {
		System.Console.WriteLine("Write me!");
    }
}

You should notice that the namespace you are using is System. You will also notice that the class name is System as well. If you were to compile this you would get an error:

MyCoolApp.cs(8,24): error CS0117: `MyCoolApp.System' does not contain a definition for `Console'
MyCoolApp.cs(4,18): (Location of the symbol related to previous error)
Compilation failed: 1 error(s), 0 warnings

{smartads}

You can see that the class System inside of MyCoolApp is found before the System namespace or, as Microsoft puts it, “hidden by the class” MyCoolApp.System.

There is a quick feature to get around this issue, and is usually refered to as the global:: operator. This gives a programmer access to specify the global namespace. In other words, this will give us access to C# System namespace instead of trying to overriding the System call with our own System class.

To use the global:: operator change the above example to:

using System;
class MyCoolApp
{
    public class System { }

    public static void Main()
    {
		global::System.Console.WriteLine("Write me!");
    }
}

This modified example should now be able to compile run. There is also another feature of namespaces that could help with avoiding this issue and improve the readability of your code. That feature is called aliasing, and, like the global:: operator, you can refer to classes inside the namespace using the double colon notation.

Say you want to create an alias of the default C# System namespace and give it the name SysAlias. You could rewrite the example above to look like this:

using SysAlias = System;
class MyCoolApp
{
    public class System { }

    public static void Main()
    {
		SysAlias::Console.WriteLine("Write me!");
    }
}

Notice that the global System.Console can be reached properly using this method. This may not look very helpful at first glance, but it can really help if you have many levels of namespaces. For example, you can improve code readability by aliasing the following class structure:

Transportation.Vehicles.Automobiles.FourDoor.ManualTransmission

to be referenced by an alias like “FourDoorManual” if you use the following:

using FourDoorManual = Transportation.Vehicles.Automobiles.FourDoor.ManualTransmission;

In the end, namespaces will allow you to eliminate the need to fully qualify classes such as System.Console or Transportation.Vehicles.Automobiles.FourDoor.ManualTransmission, and they offer a nice way of organizing code. I can see this being a very useful coding technique for keeping your code understandable, without sacrificing. I can even see it being a great feature to use when you want to debug or unit test your code (think modifying your namespace to use a simulator framework…). Try it out and let us know if you find some more interesting uses!

We have two basic ways of installing the log4r library. We can either install directly by grabbing the source or we can install using ruby-gems.

To install using the source head on over to the Sourceforge download page.

Extract the .zip or .tar.gz, enter the directory, and issue the install command

~$unzip log4r-1.0.5.zip
~$ cd log4r-1.0.5/
~/log4r-1.0.5$ sudo ruby install.rb

To install using ruby-gems, first make sure you have gems installed:

~$ sudo apt-get install rubygems

Then install the library:

~$ sudo gem install Log4jr

This should get you everything you need to get started. Now, lets look at the previously written
script:

#!/usr/bin/ruby
require 'time'

puts "starting fibonacci"

def fib(num)
 if(num < 2)
   return 1
 else
   return fib(num-1) + fib(num-2)
 end
end

if ARGV[0] != nil
 if (ARGV[0].to_i >= 35)
  puts "This might take a bit...."
 end
 start = Time.now
 puts fib(ARGV[0].to_i)
 stop = Time.now - start
 puts "Finding the fib of #{ARGV[0]} took:"
 puts stop
 puts "seconds"
end

We will need to add:

require 'log4r'
include Log4r

to the top to get access to the Log4r library.

Then we will need to create a logger. We’ll do this by adding another method to setup the global
logger. You can do this by adding:

def setupLogger()
  # create a logger
  @logger = Logger.new 'logger'
  @logger.outputters = Outputter.stdout
  @logger.debug "Logger is now setup"
end

{smartads}

to just before the fib() method call in your script.

Normally, I would set this up in an initialize method (for those unfamiliar with Ruby, this is like a
constructor method), but we’ll keep this simple for later examples.

I’m also going to replace all of the standard out (ie “puts”) messages, and
replace them to be logged with the DEBUG logger. Replace all ‘puts’ messages with “@logger.debug”.

For instance:

puts "Finding the fib of #{ARGV[0]} took: #{stop} seconds"

should now look like this:

@logger.debug "Finding the fib of #{ARGV[0]} took: #{stop} seconds"

Of course, we still want feedback from our program so let’s change the logger to output directly
to the console. You can actually see that this is already being done with this line:

  @logger.outputters = Outputter.stdout

After all of your edits, your script should now look like this:

#!/usr/bin/ruby
require 'time'
require 'log4r'
include Log4r

def setupLogger()
  # create a logger
  @logger = Logger.new 'logger'
  @logger.outputters = Outputter.stdout
  @logger.debug "Logger is now setup"
end

def fib(num)
 if(num < 2)
   return num
 else
   return fib(num-1) + fib(num-2)
 end
end

#start of main script
@logger.debug "starting fibonacci"

if ARGV[0] != nil
 if (ARGV[0].to_i >= 35)
  @logger.debug "This might take a bit...."
 end
 setupLogger()
 start = Time.now
 @logger.debug fib(ARGV[0].to_i)
 stop = Time.now - start
 @logger.debug "Finding the fib of #{ARGV[0]} took: "
 @logger.debug "#{stop}"
 @logger.debug "seconds"
end

If you try and run your script at this point you’ll notice an “undefined method `info’ for nil:NilClass (NoMethodError)” error. This is because you haven’t setup the logger before you started debugging. Lets move this log line to after the setupLogger() method call:

...
#start of main script

if ARGV[0] != nil
 if (ARGV[0].to_i >= 35)
  @logger.debug "This might take a bit...."
 end
 setupLogger()
 @logger.debug "starting fibonacci"
 start = Time.now
 @logger.debug fib(ARGV[0].to_i)
 stop = Time.now - start
 @logger.debug "Finding the fib of #{ARGV[0]} took: "
 @logger.debug "#{stop}"
 @logger.debug "seconds"
end

If you run your script now, it should work. Here is output from my run:

~$ ruby fib-log.rb 10
DEBUG logger: Logger is now setup
DEBUG logger: starting fibonacci
DEBUG logger: Fixnum: 55
DEBUG logger: Finding the fib of 10 took:
DEBUG logger: 0.000828
DEBUG logger: seconds

As you can see, adding a logger to your existing script is very easy, and you can get even more
fancy with the types of logs you wish to create. Since there are multiple
levels of logging (DEBUG< INFO < WARN < ERROR < FATAL), you can customize which level’s you use by changing the second qualifier (ie. @logger.debug could become @logger.info). Lets do that for
a couple of lines.

Change

@logger.debug "Logger is now setup"

to

@logger.info "Logger is now setup"

and change

@logger.debug "starting fibonacci"

to

@logger.info "starting fibonacci"

Your final script should look like this:

#!/usr/bin/ruby
require 'time'
require 'log4r'
include Log4r

def setupLogger()
  # create a logger named 'mylog' that logs to stdout
  @logger = Logger.new 'logger'
  @logger.outputters = Outputter.stdout
 @logger.info "Logger is now setup"
end

def fib(num)
 if(num < 2)
   return num
 else
   return fib(num-1) + fib(num-2)
 end
end

#start of main script

if ARGV[0] != nil
 if (ARGV[0].to_i >= 35)
  @logger.debug "This might take a bit...."
 end
 setupLogger()
 @logger.info "starting fibonacci"
 start = Time.now
 @logger.debug fib(ARGV[0].to_i)
 stop = Time.now - start
 @logger.debug "Finding the fib of #{ARGV[0]} took: "
 @logger.debug "#{stop}"
 @logger.debug "seconds"
end

Now let’s run the final script. You should have received output like this:

~$ ruby fib-log.rb 10
 INFO logger: Logger is now setup
 INFO logger: starting fibonacci
DEBUG logger: Fixnum: 55
DEBUG logger: Finding the fib of 10 took:
DEBUG logger: 0.000823
DEBUG logger: seconds

If you are looking for a quick way to add log messages to your ruby scripts, log4r might be a
very quick and easy to implement solution for you. Offering features comparable to Apache
Foundation’s log4j, you will find quite it quite capable of handing any of your current project’s
logging needs. Check it out, and let us know what you think.

Unlike most marketing ploys used to overstate the capabilities of a particular product, ZK seems to match enterprise needs and costs by giving the developer easy-to-use tools to create spectacular interfaces in a very short time. Of course it is easy for me to say this, but when you have a chance to check ZK out you’ll probably be left wondering why you weren’t using it before.

As mentioned before, ZK is marketed as a powerful Rich Internet Application (RIA) framework, and this framework is not limited to a particular language. In other words, ZK allows developers to code and deploy their website in a variety of programming languages like Java, Groovy, Ruby, Python, and JavaScript.

{smartads} On top of that, the technology is built on open standards and has over 170 “off-the-shelf state-of-art Ajax Components” that can be accessed by any one of the aforementioned languages with only a few lines a code. The previous statement doesn’t nearly do the justice this framework requires, so check out the quick flash movie on the learn page to get an idea; a quick example would be adding the <gmaps/> tag to embed a Google Maps component or or <fckeditor/> tag to embed the venerable FCKEditor WYSIWYG HTML Editor.

This particular release was a minor update but still managed to contain “over 6 new features” and “28 bugs were fixed.” The headliners are:

• Changing font size/family with system properties
• A New Tree Style (think Windows Explorer)
• Support for Session Fixation Protection
• Extendlet supports Filters
• Added support for bookmark-able and resumable downloads
• Components.addForward can now handle casecade $ name patterns.

If you would like to learn more, head on over to the ZK product page or to the release notes for 3.5.1 here.

There is also a NetBeans 6.1 plugin available that adds ZK Framework support for Web Projects with an enhanced design palette that allows you to quickly drag and drop ZK components into your web page like CAPTCHA box, FCKEditor, Google Maps, File Upload and ZK Tree components… along with a lot of other FCK components.

There is a tutorial done by Ayman Elgharabawy here, that shows you how to get started with the NetBeans ZK plugin incase you wanted to try it out.

Check it out, and let us know what you think!