The Open Source U

I really, really enjoyed this lecture. This is a recorded talk from Google IO by Chris DiBona (Open Source Programs Manager for Google) While nothing ground breaking is presented — it’s more of an overview talk — the perspective of open source, where open source has come from and where it is going is all interesting.

Chris also touches on the next generation of open source developers or the lack there of. This is why Google introduced Google Summer of Code. Something I wish I could have participated in but I wasn’t a student when they came up with that. Nevertheless, it’s a great program.

Anyway, I encourage you to watch or listen to it.

I needed a method to backup my web & database servers; while there are a ton of great options out there such as rsync and unison, I found it difficult and time consuming to get the Linux server to sync to Windows*. My main problem was actually more ssh than anything else. Either I don’t know enough about it or the software available on Windows isn’t as developed. (I’d love others’ perspectives on this…)

Anyway, for the time being I decided that the easiest thing for me to do is to write my own little (python) program to handle the backup and automatic retrieval of said backup archives. I don’t push or pull a lot of data between the computers, so pulling full archives though the network (as opposed to the changed bits that rsync or unison would do) doesn’t matter so much to me. The most important part is that the backup is current.

The programs are by no means complicated or unique; in fact, they might be the simplest backup programs ever. I’ve posted the source code at BitBucket.org and can be viewed at: http://bitbucket.org/frankv01/vpsbackup

If you either end up using it or deriving a new backup solution from it, please drop me a line. I’d love to know that.

* You might wonder why someone who writes-on (lives and breaths) open source would use windows…  The of matter of fact is my professional work (as of this writing, at least) is done on Windows — SQL Server and the .Net to be specific. I’ve never said anything bad about Microsoft nor will I. I believe that Open Source and traditional closed-source has their place. A software developer  can run their coded bases as desired. I, for one, prefer open source to closed-source — paid or otherwise.

A bit ago now, I introduced the tOSU-WebServer which is a web server for educational purposes. As explained in my other writings that web server is simple and is not suitable for production use, though it could be modified and improved for that purpose.

I was flipping though Linux magazines and came across the Linux Journal’s article on Mongoose. Mongoose is an open source, self contained web server written in C and implemented in two files.

It is significantly more difficult to understand than tOSU-WebServer, but it has a lot more features. Also, the fact that it’s written in C (as is Apache 2) might be appealing to some.  I hope to explore it’s API a bit but I’m not sure I’ll do any formal articles on it. If you can follow the implementation details of tOSU-WebServer, you should be able to orientate yourself on Mongoose (assuming you are familiar with C).

The source code repository and project information are located on Google code: http://code.google.com/p/mongoose/

I’ve been using the Simple Tags plug-in on this web site for some time now. I’ve never had a problem or, at least, never noticed a problem. Recently I noticed that the collapsed boxes in the WordPress admin screen (screen shot below) would not expand (among other issues). The problem was isolated to the Add Post interface. I tracked the error down to bad JavaScript used by the simple tags plug in.

WordPress's Add Post page Collapsible / Expandable box where the error existed.

Once I disabled the plug in, the expand / collapse worked as it should.

I’m not trying to punish or shame the Simple Tags team and I’m not sure the error is universal — it may work fine on your site. I’m simply sharing to help others  as it took me some time to isolate the issue. It could have been a combination of plug ins too.

Update: I’ve found that the simple tags plug in is continuing to work properly on my other (more personal) blog http://villasenor.ws/ so the problem was obviously some combination of plug-ins on this site and not simple tags alone.

I have a lot of respect for Open Source; as you can see, my entire blog is centered around the exploration of open source software for educational purposes.

Despite my following of open source software and my affinity for it, I never knew until rather recently that there was a formal definition for what can be called open source or not.

This is laid out by the Open Source Initiative in a document named The Open Source Definition.

Open Source software is more than just receiving the source code. There is criteria that software or a license should meet to meet the Open Source Initiative ‘s definition.

I bring this up to share the fact that there is a driving definition that open source software generally follows.

http://opensource.org/docs/osd

I’ve just finished my Winter 2010 term for my graduate degree. I took two classes this term, SE-450 and CSC-435. Both classes were great, but taking them concurrently was not a great idea. Nevertheless, I have something to share which is ultimately a derivative of the two classes. One of the project assignments in CSC-435 – Distributed Systems I – was to create a web server. We were given the basics of how a web server and client works, but then left to our own devices to gather the HTTP response codes and other such information. My intention is to share a good portion of the basics here but then also my web server (slightly modified for this site).

Background

Web servers (and browsers) work on top of basic sockets. While this entry isn’t going to be a comprehensive introduction to the networking technologies involved, one area that is key to the web server is the idea of sockets. A socket is defined as a communication channel in which two programs can communicate. The communication takes place over ports.

Now, we need to understand how to use a Socket in Java which is the implementation language for the tOSU Web Server. Java (SE 6) has two implementations for a Socket. One is the ServerSocket and the other is a Socket. The former, waits for incoming socket connections. Essentially, it becomes the server. The socket, on the other hand, is a incoming connection; it becomes the communication channel between the client and the server.

The high level idea of creating a web server is to create a ServerSocket instances and wait for incoming connections. Assuming it receives a properly formatted request for a HTTP server, we handle the request and return data — web pages — to the client. The question is, what constitutes a valid HTTP request.

The HTTP Request

HTTP is nothing more than a protocol. We’ve all heard this, I’m not sure we all know what this means. A protocol is merely a set of rules. I don’t believe that a protocol is anything more or anything less.  The HTTP protocol is actually quite comprehensive but creating the tOSU-WebServer has taught me that we do not need to implement the entire protocol for a  pedagogical web server application. We simply need to provide the basics, perhaps a little more, and it’ll work. This is what my web server represents.

HttpFox results for Cat.html

I learned about the protocol in two ways, neither had to do with reading the actual published documentation. I utilized a Firefox Plug in called HttpFox to review the server/client communication between an existing web server (the Apache server for this site) serving a simple HTML page and I created (as an assignment) a “Listener” / echo program. The listener program is built-in (as a switch) to the tOSU-WebServer. I’ll cover utilizing this in the following sections. The screen capture on the right is my results for retrieving a HTML file called “cat.html (click on the image to zoom-in).

The top row is a single request; if you enable Httpfox for a request on this site, you’ll notice that several requests are made. Each resource (html, css, images) become a request. The left side is the request header (for the selected request) or what Firefox sent to the web server. The right side is what the web server responded to Firefox. Our web server implementation must accept and read in the request header, process it, and along with the html page / data return the response header to the client.

As I write that, it sounds like a lot but it really isn’t hard to do. There are only a few required items on each side. The important line in the request header (from the client) is the “(Request-Line)” and on the client side the “(Status-Line)”.  The request-line is what the browser is requesting — the file. The status line is the response. You can view is a list of common status codes on Wikipedia but again, only a small subset is pertinent to the implementation of a simple web server.

Headers as Implemented

The headers that tOSU-WebServer must read and generate is quite straight forward.

The line we must process from the client browser is the request line which looks like GET /overview-summary.html HTTP/1.1.  The GET indicates that the browser wants to get a file, the /overview-summary.html is the file we want and the HTTP/1.1 is the protocol the client is using — the format of the request. This single line is the only relevant line we are interested in. The client sends more but tOSU-WebServer ignores the remaining items.

The web server must respond with a few more lines but it still is not extensive. The first line, as previously mentioned, is the status line. This is formatted as HTTP/1.1 200 OK. The 200 and OK can be various numbers and statues, but the idea holds. The HTTP/1.1 is the response protocol.

The next two lines is Content-Length: 500 (where “500″ is the size in bytes) and Content-Type: text/html where text/html is the appropriate MIME type.

Each one of these must be terminated with a carriage-return and then newline. In Java, this is delimited by \r\n.  Finally, to indicate that headers are complete, we send \r\n\r\n. The browser would then expect the content.

tOSU WebServer

First, where is the code? I’ve placed the code on BitBucket. The BitBucket project path is: http://bitbucket.org/frankv01/tosu-webserver/overview BitBucket provides a software project with various services, one of which is a Mercurial based repository. The site also has the option to retrieve archived versions of the tip of the repository. This option currently exists on the page above on the far right called “get source“.

The command to clone the repository (full history) is:

This will give you a repository clone where you issued the command, called tOSU-WebServer; this is essentially the project’s name (for lack of a better one). Note: This article is being written against the tag “v0.5.x”. Once you clone the repository, run “hg update v0.5.1”

While I’d love to review everything, including the architecture, this inaugural post can only include so much information. I figure the first aspect is understanding the overall architecture enough to looking though the code. Then we’ll take a look at the specific code segments that process incoming requests.

Architecture

As I stated at the start of this post, this program was developed while I attended an object-orientated architecture course and a distributed computing course. This combination made this program take on an architecture that is likely more complex than it needed to be, but is strongly OO in nature. This design led to a large number of classes but each with a finite task to accomplish. I beleive that this will make it easier to understand… once you can follow the design.  Please feel free to ask questions. I learn by teaching and I can only improve articles like this by receiving questions.

Package Layout & Design

I’ve used packages to organize the program; understanding these should make it easier to find what you might be looking for.

• com.theOpenSourceU.webserver.arguments : A package to handle command-line argument/flag processing and parsing.
• com.theOpenSourceU.webserver.debugutil : A package to handle text based debug and error messages.
• com.theOpenSourceU.webserver.http : The core of the program, this contains the code that ultimately is the web server.
• com.theOpenSourceU.webserver.ui : Contains the main executing class; the program to launch and manage the various pieces of the web server.

What main does

Since the goal is to understand how the program works, lets review what the program actually does. The file we are reviewing is the MyWebServer.java (in the ui package), which contains a class called (surprise) MyWebServer.

What the program basically does is:

1. Process any given arguments, setting class level fields.
2. Get a new instances of ServerSocket. When we construct the new instances, we give it the port (_port) and the queue size. Both values will be covered later.
3. Next, we call servsock.accept() which is a blocking call; it will block the program until a connection is received.
4. Once a connection is received (via the port) the program will receive an instance of that and stash it in sock.
5. Depending on the server mode, either a new Server Worker will be created and started or a new listener. Each of these are different modes and are set via the arguments. Note that each one of these are a derivative of a Thread and hence we are starting new threads upon calling start()
6. Go back to 3 to wait for another connection.

This is the gist of the programs flow. The details of handling the request are handled in the http package. We’ll review this package in the next section.

Implementation

The http package contains various classes, only a small subset is actually public.  We’ll review a few classes in the next few paragraphs however, the best way to review all of the classes is to generate the javadoc files and review those.

In the earlier section, we saw the class WorkerFactory. This is a class to generate appropriate instances of the two works contained in the package. A worker is a class derived from Thread that performs some task, in our case handle http requests. The two concrete classes that can be generated are HttpWorker and MyListener.

The HttpWorker class is the class of interest here. This class becomes the worker thread that handles the request sent to the server. Another way to put this is that this is what the client-browser is actually talking to, and not the MyWebServer instances. This is how the web server can handle several requests at once.

Since we are on it, why don’t we continue on from the HttpWorker class. The class extends Thread and we are implementing the run method. Let’s not go in to detail, but this is the code that processes the request and ultimately provides the content to sends back to the client browser.  Inside this method, we reference another factory — HttpContentFactory. This factory can provide implementations of HttpContent for a variety of files types, including css, html and a made up dynamic page. (Images weren’t working Status)

The contrast to HttpContent is the HttpClientHeaders instance. This represents what becomes the server response headers. This web server only supports a few codes (recall, not all need to be supported). The class HttpClientHeadersImpl provides support a 404 error, 500 error (internal server error) and 200 success status. The implementation details are not relevant to this initial introduction but it is important to know that the HttpWorker class can’t complete it’s job without an instance of this to report status (success/error) to the client.

From here, HttpWorker renders these two instances and sends the contents back to the original request.

More to Come…

In the details, the program does a lot more than what I’ve outlines in the last few sections. However, I suspect that wrapping your hands around these first sections can make reviewing the source code less intimidating.

If you have any questions or feel that the article above can be improved, please let me know via the comments. I hope to post more educational articles on tOSU-WebServer and I would greatly appropriate direction. If you are interested in a particular section, please let me know (again, via the comments). Oh, and don’t forget to follow the project on BitBucket.

I use UML to do quick brain storming and when exploring software. While I’ve not posted many write ups here (grad-school!),  I generally don’t want to invest a lot of time in my UML diagrams and only sometimes do I even want to save them.

Often times, especially lately, I’ve been drawing on a whiteboard that I keep in my office.  I find this to be efficient (even over paper because I’d end up throwing it away).

In one of my current grad-school classes, we are using “Object-Oriented Design & Patterns” by Cay S. Horstmann as the class text book. I’ve enjoyed the book and it provides some decent examples. I bring the book up because apparently the author of the book created a UML package called Violet UML. I’ve found this to be the best software based UML brain-storming software I’ve ever found. Here are my reasons:

• It loads quickly
• I can efficiently draw diagrams without warnings or complex menus to navigate though.
• The lack of UML rules enforcement means that I can draw partial diagrams; diagrams that mean nothing out of context.
• It’s open source
• So far, its more stable / reliable to ArgoUML

If you are looking for a UML package, I must recommend this. I searched and searched for a UML package a while back and I never came up with this. I looked at everything, no matter what and still never found it. So, if you like it, please spread the word (via your own blog, twitter, facebook, etc). I think it is well done software and worth some attention.

http://violet.sourceforge.net/

As some readers will know, I’ve been working to study the architecture of FireFox. One thing I realize is that I’m not as familiar as I should be with some of the common open source tools, or what I consider to be the common open source tools.

Below is a list of tools that are worth learning (in my opinion). I’ve also included a short description of why it might be worth learning them. (The list is in no particular order)

If you have an interest in open source, it will not hurt to get a quick base understanding of each of these. I’m not saying you (nor am I trying to) become an expert in each of these tools. However, having a basic understanding of syntax and function should save time and headache while trying to understand a project.

1. Linux: The concepts in and around Linux are often used on other open source products. I think Open Source developers tend to stick with using open source software. So, there is a link there.
2. Bash: The de-facto standard shell for Linux (as far as I can tell). Knowing the basic usage of bash can save you time and confusion.  Certain scripts can depend on feature of your terminal interface. The Mac OS X ships with a version of bash, which is good to know…
3. GCC: This is the GNU Compiler Collection and is often a requirement to build open source packages.
4. Make: This is a part of the GCC but I want to make special mention of this because knowing how to read the script files and error messages can help diagnose an error.
5. C / C++: Low Level libraries are often written in C or C++, even for an otherwise Java or Python based program.
6. Python: Python is sometimes used in conjunction with Make to check for build dependencies, verify (build) requirements, or many other possible things.
7. Perl: Often used like Python, from what I understand but I’ve yet to learn much about it.
8. Subversion: This is the most common open source VCS software in use (based on my own observations)
9. Mercurial: One of the two popular DVCS systems. I’ve noticed more and more open source projects switching to DVCSs, so a basic working knowledge of Mercurial and Git is helpful.
10. git: The second of the two popular DVCS systems.

If you’d like to contribute to the list, please leave a comment below but please ensure you include a fair reason.

This is a follow up post to a series I’ve been posting. The previous post to this posting was “Firefox – Found time to Try again!”

I finally was able to get Firefox to build on my Vista machine. It has given me a lot of trouble and I’ve had to troubleshoot several times. Relative to my previous post, I was last held up on a “NSInstall” error. NSinstall.exe would report “Bad File Number”.

The solution was reducing the directory depth. I had my mercurial repository in a sub folder of my documents folder. Specifically C:\Users\Frank\Documents\hg-repos\mozilla-fv-expirement\. I moved the directory to C:\mozilla-fv-expirement\ and re-ran the build script. It did it’s thing and I was able to fire up good-’ol firefox.exe from the [...]\dist\bin folder. I even checked my gmail account on it.

Now where?

I felt that before I started hacking and understanding the source code, I should be able to build the program. That way, if I make a significant change I can see how the code base reacts to it. Though, my intentions are not to hack but to understand how it works. The ability to drop print statements in should help with this… maybe…

Additionally, I hope to contribute to the Mozilla Litmus QA system. I might as well — I did take the time to build the trunk.