Thanks to all who showed up to help on the bug day on
Friday, your efforts are greatly appreciated.

We started with just over 70 bugs and left the *obby
session available over the weekend.  By the end of the
weekend, we had reviewed 14 bugs (9 of which we closed).

These were all Critical and Major bugs listed for openSUSE
11.1.

I will be closing the *obby session this afternoon at about
1700 CDT.

Thanks again!
–
Christopher M. Hobbs [chobbs@siloamsprings.com]
Network Administrator, City of Siloam Springs

Please join us for the openSUSE-GNOME BugDay code named “Community Effort” tomorrow
(Friday 14 MAY 2009) at 1100EDT/1500UTC.

We’ll be squashing blocker, critical, and major bugs in 11.1 related to GNOME.

More information can be found on the wiki:
http://en.opensuse.org/GNOME/BugDays/20090514

A Gobby session will be announced at the beginning of the meeting to assign/close
bugs. Should you have any questions, feel free to ask in #openSUSE-GNOME on Freenode,
or email me directly.

We hope to see you there!
–
Christopher M. Hobbs [chobbs@siloamsprings.com]
Network Administrator, City of Siloam Springs

During Community Week (http://en.opensuse.org/CommunityWeek), I’ll be hosting another openSUSE-GNOME BugDay on Fri, 15 MAY 2009. We’ll start promptly at 1000 CDT and will continue until 1600 CDT. I will be around very early in the day to start prep for the meeting should you have any questions.

We’ll conduct business in #opensuse-gnome on Freenode (irc.freenode.net). I will establish a Gobby session as I’ve done in the past, and we’ll work off of that.

Can’t wait to see you there!

The UM175AL card from Alltel attempts to identify itself as a USB storage device/cdrom when it’s first inserted. This is a huge mess as it needs to be recognized as a serial device. After some searching, I came across Mark A. Ziesemer’s post on using this same card under Ubuntu. He recommends using USB_ModeSwitch to change the device’s mode.

First, I downloaded the USB_ModeSwitch source, extracted it, and deleted the binary. Next, you’ll want to download libusb and libusb-devel from the OBS. If you don’t have OneClick-Install enabled on your SLED install, simply download the libusb RPMs and issue the following commands:

rpm -Uv libusb-*.rpm

rpm -ivh libusb-devel*.rpm

Once those are installed, go ahead and issue ‘make’ in the USB_ModeSwitch directory. This should execute rather quickly and you should have a new usb_modeswitch binary. Copy ‘usb_modeswitch’ to /usr/sbin.

Next you’ll need to create a config for USB_ModeSwitch. As root, edit /etc/usb_modeswitch.conf with the following information (all the gory details can be found at Mark’s site if you’re up for a read):

# /etc/usb_modeswitch.conf

# alltel evdo hax
DefaultVendor = 0×106c
DefaultProduct = 0×3b03

MessageEndpoint = 0×05
MessageContent = “55534243904ed68a24000000800008ff024445564348470000000000000000″

Note that the above only works for this particular card. You can likely ignore that if your EVDO card is already supported.

Now we should be able to access the modem and use ‘wvdial’ (which conveniently ships with SLED) to get connected. First we’ll need to edit our /etc/wvdial.conf. This example is for Alltel only:

[Dialer Defaults]
Stupid Mode = On
Modem = /dev/ttyACM0
Baud = 921600
Init = ATZ
Init2 = ATQ0 V1 E1 S0=0 &C1 &D2 +FCLASS=0
Phone = #777
Username = XXXXXXXXXX@alltel.net
Password = alltel
Init1 = ATZ
ISDN = 0
Modem Type = Analog Modem
Auto Reconnect = on
Carrier Check = no
[Dialer shh]
Init3 = ATM0
[Dialer Pulse]
Dial Command = ATDP

Replace XXXXXXXXXX with your 10 digit phone number. I gleaned this information from two sources: Linux.com’s EVDO tutorial for VoIP and Linux * Screw’s EVDO with Linux article.

Now that everything is all configured, plug in your EVDO stick and use usb_switchmode to switch it to the proper mode for serial access:

/usr/sbin/usb_modeswitch -c /etc/usb_modeswitch.conf

Which should spit out some “everything OK” messages. If it didn’t, you’ll need to go back and check your configuration.

Once you’ve switched the card to the proper setting, go ahead and use ifconfig to bring your wireless and wired network interfaces down (ifconfig eth0 down, etc.). This step is optional, but I like to do it for good measure.

Now you should be ready to dial your wireless carrier. To do so, simply execute ‘wvdial’ and wait for the connection to finish. You should be online at this point!

So there you have it. I want to give a HUGE thanks to Mark Ziesemer for doing so much research on this card, that helped progress a TON!

Enjoy!

Well…  It’s not been so great for a lot of people.  It seems that HP simply put this laptop together, half-assed a SLED load and sent it out into the wild.  I’ve had a ton of problems with it, the two major ones being that I couldn’t register the machine with the Novell Customer Center (not even with my site license) it ships with a non-working wireless card.

My wifi fix was simple, buy a new usb wifi dongle…  Registration, however, was a little easier to fix (after some wailing, gnashing of teeth, and chat in #opensuse-GNOME… thanks captiain_magnus!).

If you attempt to use YaST to register you copy of SLED on the 2133, you’ll be re-directed to a “special” Novell Customer Center login.  It’s a little different than the normal one in that it wants an HP license, not any other SLED license you may have.  The biggest difference, however, is that it’s broke.  It simply refreshes the page when you click submit and sends nothing to Novell.

They’re pretty sneaky about hiding your license number as well.  It happens to be on your restore DVD.  It’s located on the right hand side below the HP logo and the “2133″ text.  It’s in a series something like NNNNNN-XNN, where N’s are numbers and X is some letter.

To get around the registration bug, have your license number handy and fire up your terminal.  Use ’sudo’ or just ’su to root and issue the following command:

suse_register -n -a serial-hp=NNNNNN-XNN

Where “NNNNNN-XNN” is your registration code.  Sit back and wait, it took almost 20 minutes for this command to finish for me and you’ll receive absolutely no indication that it’s functioning.  Once it’s done, you’ll simply be returned to your prompt.  Fire up YaST or your favorite terminal emulator and check your repositories.  You should now have a Novell repository added.

Enjoy!

The current agenda can be found here:
http://en.opensuse.org/GNOME/Meetings/20090205

For time conversions, please see:
http://www.timeanddate.com/worldclock/fixedtime.html?day=22&month=1&year=2009&hour=22&min=0&sec=0&p1=0

Thanks!

Getting started with Rails on openSUSE is a breeze.  In this particular article, I’ll quickly outline installation and startup of Rails on openSUSE 11.1.  You’ll need to install Ruby, ruby-sqlite, and ruby gems.  I’ve detailed these in my previous articles on ruby.

This is far easier than you might expect, so lets get started…

Use ruby gems to install Rails:

sudo gem install rails

That’s it!  After some work, Rails should be all installed and ready to go.  You can test it out by creating a new project:

rails foobar

And running the server script, then visit http://localhost:3000 in your web browser to verify that all is well:

cd foobar && ruby script/server

Note that this installation will use sqlite3 as it’s database by default if you’ve been following my other tutorials.  There’s information about getting Rails to work with MySQL (and other databases/platforms) over at the Rails Wiki:  http://wiki.rubyonrails.org/rails/pages/HowtosInstallation

Read on to learn more about Teaming and SLES…

Documentation

Most of the Teaming documentation can be found here:  http://www.novell.com/documentation/team_plus_conf/

Prerequisites

• SLES (our server platform)
• OES2 (not entirely important, but it knocks out a lot of the pre-reqs and gives you LDAP support if you have eDirectory running)
• Teaming Licenses (a “starter pack” of 20 free licenses is available, contact your Novell vendor for more information)
• I’m assuming you’re running the setup from a Linux box, but this isn’t 100% necessary

Preparing your installation

There are a few things you need to do before getting started.  First being to install mysql:

# zypper in mysql mysql-client mysql-shared perl-DBD-mysql perl-DBI perl-Data-ShowTable libmysqlclient-devel

# chkconfig –add mysql

# /etc/init.d/mysql start

# mysql_secure_installation

Next, you’ll need to edit your /etc/my.cnf to change the default character set support.  Add the following lines to /etcmy.cnf:

[mysqld]
character_set_server = utf8
[client]
default_character_set = utf8

Additionally, you’ll need to increase your open file limits in /etc/security/limits.conf:

• hard nofile 65535
• soft nofile 4096

Installation

I like to run everything from a single location, so to kick things off, I created the directory ‘/incoming’.  Once there, you’ll need to download your copy of Teaming and extract it into this directory.

Once you’ve gotten everything extracted, download your license file and copy it to the same directory, but make sure that you rename it to “license-key.xml”.  The Teaming installer will complain to no end if it’s unable to find this exact file in the install root.

Next, you’ll need to make the installer executable:

# cd /incoming && chmod 755 installer-liferay.linux

Now it’s time to run the installer.  The installer comes as a GUI package, but can be run via a text interface as well.  If you’re ssh’ing into your server to set up Teaming, you’ll want to forward X to allow the GUI to open (ssh -X -C user@server.com).  Otherwise, use the ‘-console’ knob to initiate the text based installer.

# ./installer-liferay.linux

-or-

# ./installer-liferay.linux -console

I recommend choosing advanced options for install as it allows for greater flexibility in options.  Once you’ve followed through the installation steps (note, I installed mine copy into /opt/icecore), liferay/Teaming should be successfully installed.  Now you’ll need to start the server:

# /opt/icecore/liferay-portal-tomcat-5.5-jdk5-4.3.0/bin/icecore start

To ensure that Teaming starts on boot, issue the following commands:

# cp /opt/icecore/liferay-portal-tomcat-5.5-jdk5-4.3.0/bin/icecore /etc/init.d

# chkconfig –add icecore

After that, you should be able to start, stop, and restart ‘icecore’  using the /etc/init.d/icecore script.

At this point, Teaming should be up and running.  To access it and get started, open your browser and navigate to http://yourserver.com:8080 and log in as user admin with the password ‘admin’ (no quotes).

Once logged in, you’ll need to pull the administrative modules down to your view by selecting the ‘Add Content’ option in the upper right hand corner.  I like to use the shotgun method and add all of the administrative modules for my admin user.

So there you have it, a fresh Teaming install.  Enjoy!

A while back, I put together a presentation for the local Ruby user’s group.  The presentation covers a very brief intro to Capistrano for simple system automation.  You can download it here.  I’m aware of at least one typo (a missing single quote) in the slides, there may be others.

Rather than repeat myself here, I’ll let the PDF do the talking.  For the official documentation, see http://capify.org/getting-started

Super-quick intro to Ruby syntax

So first and foremost, I suppose we should start with some basic Ruby syntax.  I’m going to keep this brief, so for a more proper introduction, see http://ruby-lang.org.

To get your feet wet, lets fire up ‘irb’, the Ruby interpreter and get the standard Hello World program out of the way:

irb(main):001:0> puts “Hello, World!”
Hello, World!
=> nil

Here we see the method ‘puts’ displaying our string followed by the result of the expression.  This is pretty straightforward stuff.  So lets move on to some more useful stuff: variables, modules, methods (we’ll leave classes out for now), and iteration:

Variables are extremely straightforward, just use your ‘=’ operator to create a variable.  Ruby is dynamically typed so we don’t have to declare our variables prior to creating them.  For more on this, check out “Duck Typing”.  Lets assign a variable and print it out:

irb(main):002:0> n = 42
=> 42
irb(main):003:0> puts n
42
=> nil

Easy, right?  Lets keep this whirlwind intro moving, then.  On to Modules, Ruby comes with tons of modules that are available right at your fingertips.  You can find documentation for Ruby modules at http://ruby-doc.org or pick up a reference book (my personal favorite is the “pickaxe book“).

Modules are called simply by Modulename.method(args).  Here’s a quick example using our previously defined variable:

irb(main):004:0> Math.sqrt(n)
=> 6.48074069840786

Here, we called the sqrt method of the Math module on our variable.  Also note that it automatically converted the type for us.  We’ve gone from an integer to a floating point number without any voodoo on our part.

I don’t have time in this article to cover Classes (see your favorite reference/tutorial for more info on classes), but methods are relatively simple to define.  Lets put our ‘Hello, World’ code into a method.  Just to mix things up, lets toss a variable in as well:

irb(main):005:0> def howdy(name = “World”)
irb(main):006:1>   print “Hello, #{name}!\n”
irb(main):007:1> end

Now we can simply call our method ‘howdy’ with or without arguments:

irb(main):008:0> howdy
Hello, World!
=> nil
irb(main):009:0> howdy “Geeko”
Hello, Geeko!
=> nil

Yet another useful thing we may be interested in is iteration.  While iteration looks a little different in Ruby, it’s relatively simple.  You may be used to the simple ‘for i in foo; do bar; done’ syntax of most languages.  Ruby mixes that up a little…

Here I’ll define an array and iterate over each element.  Watch closely:

irb(main):015:0> pals = %w{Tux Geeko Linus}
=> ["Tux", "Geeko", "Linus"]
irb(main):016:0> pals.each do |i|
irb(main):017:1*   puts “#{i} is my homeboy!”
irb(main):018:1> end
Tux is my homeboy!
Geeko is my homeboy!
Linus is my homeboy!
=> ["Tux", "Geeko", "Linus"]

Here you can see we stepped through each element of the array ‘pals’ and displayed said element with a message.  It may look wacky now, but the more you use it, the more natural it becomes.

So you want to automate some tasks?

When using Ruby with openSUSE, the sky is the limit with system automation.  To call system commands, simply use backticks (`) just as you would in bash or your favorite shell.  The simple syntax encourages rapid development, so Ruby is a great language for working with your servers.
One thing I do frequently is check for updates across my servers and mail them back to myself.  This requires that we install the ruby gem ‘mailfactory’ (’sudo gem install –remote mailfactory’) so that we can spawn an SMTP server.

We probably all use zypper to search for updates, so here’s a simple script that will check for all updates on a box and mail it right to you.  Note that this is a very simplified version of part of a larger collection of scripts that I use daily to monitor my servers…

#!/usr/bin/env ruby
# be sure to include all necessary modules

require ‘rubygems’ # necessary to use mailfactory
require ‘net/smtp’ # another mailfactory requirement
require ‘mailfactory’

# this method has zypper search for updates and save them to a variable
# note that we could alternatively search for zypper’s path and store it in
# a variable as well

def zypper (option)
zypper_output = `”/usr/bin/zypper” #{option}`
return zypper_output
end

# call the zypper method. note that ‘lu’ lists updates in zypper

zypper_msg = zypper(”lu”)

# call Net::SMTP to fire up a server
smtp = Net::SMTP.new(’localhost’, 25)
smpt.start(’yourserver.com’)

# craft our message
report = MailFactory.new()
report.to = “admin@yourserver.com”
report.from = “admin@yourserver.com”
report.subject = “server updates”
report text = “#{zypper_msg}”

# send our message
smtp.send_message report.construct, ‘admin@yourserver.com’, ‘admin@yourserver.com’
smtp.finish

While the last portion of that (MailFactory) got kind of messy, the script is relatively simple to step through.  First we add all the necessary gems/modules to help send our message, then we define a method that calls zypper.  After we’ve established that, we simply pass our options (in this case, list updates) to the zypper method and mail it out.

The same can be done to interact with system utilities to perform maintenance, parse logs, or gather more information.  Take a look at the File module and browse through some gems, you’ll very likely find plenty of useful utilities.  Use your imagination and by all means, enjoy yourself!

Stay tuned for my next post in which I’ll cover remote automation with Capistrano.