Anil Gulecha's Musings

GNU screen is an extremely useful utility when used on remote machines. If you have a flaky net connection that disconnects often, it can be a boon.

What do mean: “tabs”?

GNU screen emulates a terminal, using your default shell. You start it by simply running

$screen

You get a welcome message and to a working shell. This is your open “tab” or screen. To start a new tab, enter the keys Ctrl-a + c (control-a followed by c). This opens a new tab with an empty shell. the first shell is “0″, second is “1″ and so on.

To move to shell X, use Ctrl-a + X.. so to go back to the first shell, i hit Ctrl-a + 0.

To scroll up in the tab, when text has run through the screen, press Ctrl+[ , and you are now in scroll mode: you can use the arrow keys, home, end, pgup and pgdown, etc to scroll on the screen. Esc closes the scroll mode.

Screens are persistent

So your network was reset and you connection to the remote server lost. Worry not, screen is still running up there. Login to your account again, and run

screen -x

This will attach to your old screen session, and your wordspace and opened tabs are all present

You may always want to start off with screen -x initially. If no session exist, this will report an error and you can start a new session using screen. If one does you will attach to it. If more than one does they will all be listed and you can attach to any one of those.

Multiplayer mode

This feature of attaching to open screen sessions isn't restricted to you alone. Another user logged into the system can also enter screen -x, and join you. You can both now collaborate on the screen! This is extrememly useful when you need the help of another person to get something done.. and you get to see live as they do their thing.

So, hope I've sold you on screen. Use it. The official page is on GNU.org, but its probably alreayd a part of your system or available in your distributions package repository.

Screenshots should be listed at google's result.

Default key bindings for various tasks are here and the manpage is here.

[update: To get a bar at the bottom of the console to list all windows + other details, take a look at the guide at redhatmagazine.com]

The Nexenta hackathon session starts in about a day. If you’ve been thinking of participating, join in at #nexenta@freenode and request your account.

More on Nexenta development in earlier posts here and here.

So, I’ve finally picked up Python (been meaning to do this for quite some time), and find it to be beautifully intuitive. The ternary operator that goes

result = x if y else z

is an example of this intuitiveness.

Expect many more Pythonic posts in the future. For now, I’m considering the problems from Project Euler

In this part we will take a look at the steps followed to port an application from Ubuntu and build a package.

I decided to do this via a screencast. You may not be able to fastforward or rewind, so I’ve also listed out the steps you will need to follow below the screencast. Click below to open the screencast. Or download it for offline viewing here.

Getting started with Nexenta screencast

Getting Access

We have a build machine available at gnusolaris.org where you can login to do your nexenta development (and not have to hassle with installing locally). You will use ssh to login, and can get the details by asking on IRC (#nexenta@freenode), or on the development mailing list gnusol-devel@sonic.net.

Logging in

You can login using your favourite shell and terminal program. The screencast uses gnome-terminal. If you are on Windows you can use the Putty client. Use

ssh username@gnusolaris.org

and enter the password when prompted.

Entering the Devzone

One of the core features of opensolaris is Zones (zfs is currently stealing all the thunder). Since giving root access to everyone is not an option, and building without it is not one either, the Nexenta project has innovated and created the so called development zones. These provide a method to quickly create a developer environment and give you root access to it. When no longer required, this zone can be painlessly removed.

The commands sure would be complex.. right? As simple as

• devzone_create  — creates a development zone
• devzone_enter — enter a devzone
• devzone_free — remove the zone when no longer required

Simple as that.

Once you have entered a newly created zone, use the following commands to get it up to date

apt­-get update; APT_CLONE_ENV=1 apt-­get dist­-upgrade

Also, you will have to create/import your gpg key for signing packages. Further instructions at http://www.nexenta.org/os/CreatePublicGPGKey

Building a package

So now that we have our environment ready, lets build a package. In the screencast we take an example of libid3tag, which is a C library that is used to parse the headers in mp3 files.

First check if the package is available in the repository (Well libid3tag is not, but you would need to check if the package you are trying to port is already in or not)

#apt-cache search package

Searched for the expression package in the repository and lists the matches if present.

If it doesnt exist, you get it from Ubuntu’s repostiory mirror using the apt-upstream-tool

#apt-upstream-tool -e -p package

-e : extract the package

-p : the package name

Once we have the sources.. move into the directory, there would be 2 copies.. one original, and one for us to edit and use.

Move into this directory (this is referred to as the “package root”) and make sure the changelog reflects the distro as Nexenta. You can edit the changelog entry using

#debchange

in the package root.

Next satisfy all the build dependencies of the package.. this is required if the package has to built. Do this via running the following command in the package root.

#apt-satisfydepends

The above tool will lookup all dependencies and install them from the repository if available. (If not, you would also have to port that package)

Once the above completes successfully, create the package using

#dpkg-buildpackage -sa

-sa : Bundle the source code with the package

If the above completes successfully, you will be presented with a prompt to enter your GPG passphrase to sign the package.

Once this is done your package is built and present in the parent directory to the package root. Install all .deb files to verify that they install correctly. Do this using

#dpkg -i packagename.deb

You can also take a look at the contents of the deb using

#dpkg-deb -c *.deb

Once the install goes smoothly and all looks good, upload it to the repository using

#dput *.changes

This will upload the files to the repository, and send out mails to the nexenta-changes mailing list.

Further information is availabe on the Nexenta wiki documentation section and at http://www.nexenta.org/os/BuildingPackages

So I’ve been working on Nexenta for a fortnight now, and have picked up a lot of things. Below is a short introduction/guide on how you can join the project.

Introduction

First a little bit of background. The debian project was started in the early nineties to be a one-stop package repository for Linux applications. It has been a fairly popular distribution. However, it was the Ubuntu distribution that made the most use of these packages. Ubuntu is a debian derivative, with focus on the desktop. It makes use of the debian’s packages, on top of the linux kernel.

The solaris kernel is very well regarded for its rock solid stability. When solaris was open sourced as opensolaris in 2005, many possibilities emerged.. what if we could combine Solaris’s famed stability with Ubuntu’s famed user experience. And this is the aim of the Nexenta project.

So that is the backstory. Nexenta = Ubuntu – Linux kernel + Solaris kernel. Nexenta is currently focusing on the Nexenta Core Platform, which is a starting point for any type of focussed distribution; ncp will allow for easy addition of packages, and you are free to develop any distribution on top of it, by adding any packages you want. Which brings us to how you contribute to the Nexenta project: Packages.

Ubuntu/Debian currently have 20000 packages. We need help from the community to port these to Nexenta. A sizable portion has already been done. And a sizable portion remains.

Getting Started

To get started.. these are the documentation a newbie would have to to pursue:

Nexenta uses the Debian/Ubuntu packaging model. This is thoroughly explained in

• Debian policy manual
• Debian Maintainers/developers guide
• Debian developers reference
• Apt packaging system

A majority of the open source applications use the GNU autotools to compile and build programs. This autotools tutorial should help you get started.

Platform

Locally: As NCP is a command-line only environment, the ideal setup for developing would be running NCP VMWare server on Ubuntu Hardy 8.04. NCP 2.0, the upcoming release is based off this Ubuntu release. You can however install this on baremetal or on Windows/ OpenSolaris.

Remotely: Another option is to use the build machines at gnusolaris.org remotely. get onto IRC, and request for a login details. We’ll setup a development zone, and give you the login details. Further details on the hackathon page in the “How to get started” section

Machine requirements

• If you are going to work remotely on the gnusolaris.org development machine, all you need is an ssh client like putty on Windows or your garden variety ssh on your favourite *nix distro.
• If working on NCP locally, the recommended specs are:
  • Processor: Pentium 4 2.0 Ghz or equivalent
  • Memory: 1Gb minimum, 2Gb recommended.. you’ll be using a VM.
  • Space :10Gb for the virtual hard disk.

Installing Nexenta Core Platform

A step by step guide with screenshots is available at http://www.nexenta.org/os/Getting_Started

If you run into issues setting up VMware with bridged networking, you can take a look at my previous entry.

Getting help

The nexenta project has a very helpful community, that answers your queries quickly.

• Drop in on IRC at #nexenta on freenode, or use the web-based interface at nexenta.org/chat.
• Signup for the developer mailing lists
• Web-based forum

[The next part will take a look at the important commands used in porting packages]

I had a little trouble setting up VMware to share the host’s (Ubuntu) nic interface eth0 (with static ip) with the guest ncp2.

Follow the instrucions here to setup a VMware install: http://www.nexenta.org/os/Getting_Started

When you need to pass network settings, for a static IP configuration on the host, follow the below steps.

Lets say the guest is setup as

IP:192.168.1.2, with netmask 255.255.255.0 and router 192.168.1.1

Then host needs to be

IP: 192.168.1.3 (or 4 or 5..), with netmask 255.255.255.0 and router 192.168.1.1

I figured I’d write this guide for those who have certain needs to setup a blogging infrastructure for an organization.

I’ve joined the Nexenta project and one of my first tasks was to setup blogs and a planet. The requirements were thus:

• Ability to blog (yes!)
• A place to aggregate feeds (aka “Planet”)

My first choice was WordPress Mu, given that I already had experience with WP. Setting it up was easy.. below is a quick overview of what I did:

• Login to ssh.. and create a directory for blogs.nexenta.org.
• Setup the apache virtual host config for the above.
• Create a mysql database and a username/pass to access it.
• Get and extract the wpmu latest into this directory.
• Add a couple lines to /.htaccess
• Launch via the browser, and enter db and blog details.. and you’re done

Now to setup the planet.. install the following

• Plugin Commander (To easily manage plugins sitewide)
• FeedWordPress (For our planet feature)
• Did you pass math (To scare away the nasty spammers)

Set FeedWordPress to post feeds directly, and check for new content every 10-20 minutes. When you give it feed links of services like blogspot, be sure to pass RSS feeds rather than ATOM.

Add a few themes and your blogging platform is ready to serve.

In trying to figure out how to create packages for Nexenta, I felt the need at multiple times to view the entire tree of dependencies for a package. A little bit of googling and I found that it is pretty simple.

The apt-cache command can be used to view dependencies graphically.

You will need to have the graphviz package installed for this.

$apt-cache dotty packagename > /tmp/dotfile
$dot -Tgif -o packagename.gif /tmp/dotfile

The complete dependency tree for the package packagename will be displayed in the file generated.

From the apt-cache manpage:

“The resulting nodes will have several shapes; normal packages are boxes, pure provides are triangles, mixed provides are diamonds, missing packages are hexagons. Orange boxes mean recursion was stopped [leaf packages], blue lines are pre-depends, green lines are conflicts.”

An example for the hspell package:

Been some time since I last blogged. Here are a few quick updates:

* I’ve graduated (rather under-graduated).

* I’ve joined the Nexenta project fulltime.

* I intend to start blogging a bit more.

That about sums it up.

PS: Ow.. and Belenix 0.7.1 was released. Go try it!