Proven Corporation » Free Software

One-line shell script server for testing your AJAX and HTTP code

Jason — Wed, 01 Apr 2009 13:07:57 +0000

Here is how to make a very simple web server with a very simple shell script on a GNU or Unix system such as OS X. I have found it to be ideal for quick tests and debugging sessions with AJAX code and tools like Python’s urllib2.

The idea is to run an infinite loop which calls socat to return static files to the browser.

Preparation

Install Bash and socat on your OS. Your operating system probably has packages named bash and socat.
Create a new directory, for exmple responses/ to hold your static response files.
Place one or more files in this directory. The format should be:
1. HTTP response code
2. HTTP Headers
3. Blank line

Content such as HTML, Javascript, or whatever you need

Example response file.

Here is what I put in my responses/simple-html.txt file. I got it from a from a tcpdump capture, but you could use Firebug or HTTPFox.
```
HTTP/1.1 200 OK
Connection: close
Date: Tue, 31 Mar 2009 15:13:29 GMT
Server: Microsoft-IIS/6.0
X-Powered-By: ASP.NET
X-AspNet-Version: 2.0.50727
Set-Cookie: ASP.NET_SessionId=Z3X0u4H5iDieUuZL3KbAuaS7; path=/; HttpOnly
Cache-Control: no-cache
Pragma: no-cache
Expires: -1
Content-Type: text/html; charset=utf-8



    
        Example Page
    
    
        Isn't this cool?
    
```
Running the server

Running the server is pretty straightforward. It’s mostly a one-liner (split here for space), but you could format it and put it in a script. The idea is for the server to randomly choose a file from the directory. If there is only one, then you get a consistent response (and you can edit that file between trials of course). If there are more, then you can see how your app responds to different data.
```
while true; do socat TCP4-LISTEN:8080,reuseaddr \
  SYSTEM:'cat `/bin/ls -1 responses/* | sort --random-sort | head -1`'; done
```
Now, going to http://localhost:8080/ will show that page!

Storyboarded response sequences

You can extend this script to return a series of HTTP responses (with HTML, JSON, whatever) in them, like a storyboard. First, give the files names such that they are in the correct order when alphabetized (e.g. 01-first, 02-second, etc.). Then use a script like this:
```
while true; do for f in responses/*; do socat TCP4-LISTEN:8080,reuseaddr \
  SYSTEM:"cat $f"; done; done
```
Here, every time you query the server, it will return the next response in the queue. When the queue is empty, it will start over; and you can make changes to the storyboard between restarts.

Concluding Notes
- You can control the HTTP and HTML! So you can test 404s and 301s and anything else!

This works for any URL you try since it completely ignores the client request and headers

To make the “server” easier to kill, before the first “done” keyword, add: [ $? -ne 0 ] && break 2;

You could substitute Netcat for socat if you don’t have access to the latter

I haven’t tested this on OS, but I would love to hear from people about successes or bugs with the script.

Risk-free introduction to CouchDB on Amazon EC2

Jason — Thu, 19 Mar 2009 06:57:45 +0000

I love using EC2 for experimenting with software, which has included CouchDB recently. Slowly, I established a good procedure for running the Subversion HEAD on an EC2 Ubuntu 8.10 instance. So, I went ahead and posted it to the project’s wiki. If you have a spare $0.10 and want to take CouchDB for a spin without any hassle, check it out:

CouchDB: Getting started on Amazon EC2.

How to run a quick throwaway Ubuntu EC2 instance

Jason — Wed, 04 Mar 2009 05:20:51 +0000

Time was, when you wanted to experiment or test something on Ubuntu, you needed a fresh install (best-case—a snapshotted virtual system). Nowadays, I myself prefer the convenience and negligible cost of simply firing up an Alestic community machine images. Once I’ve completed my work (perhaps pushing changes to a remote Git repository), I simply terminate the instance and call it a day.

Here is a comprehensive procedure detailing exactly the steps required to get an Ubuntu desktop running in a few minutes’ time. The tools used are Elasticfox to manage EC2, NoMachine’s NX client for remote login, and command-line SSH for odds and ends.

Objectives
Preparation (One-Time Only)
Booting Ubuntu Intrepid
Initial Setup
Connect to the instance desktop
Reminders

Objectives

Be able to start up any number of Ubuntu 8.10 Intrepid desktop at a moment’s notice.

Preparation (One-Time Only)

These steps will get you up and running with Amazon’s AWS infrastructure. Do this only once, during your first run through this procedure. Afterwards, skip to the next section.

Install the NX client

Install the NX client (which is similar to the rdesktop VNC client) onto your local system:

Go to the NX download page.
Click on the link for the architecture and package type of your local system
Install the client and node packages (server is not needed)

Set up NX client for EC2

Set up an NX session which is configured to connect to EC2 and establish a GNOME session.

On your local GNOME system, Applications -> Internet -> NX Client for Linux -> NX Connection Wizard
Name the session (e.g. EC2)
Enter any random hostname (it will be changed later) for the host field and hit Next
In the dropdowns, select a Unix system, GNOME desktop and hit Next
Disable the “Create shortcut” option and click finish

Install Elasticfox

Run Firefox and go to the Elasticfox page
Click the “Download” button and install the extension
Restart Firefox

Input account credentials in Elasticfox

First, get your AWS account credentials:
1. Go to the AWS site
2. Mouse over “Your account” and click on “Access Identifiers”
3. (Possibly sign in to Amazon)
4. The access key is displayed; and you can click on the “Show” link to view your secret key
Back in Elasticfox, click the “Credentials” button at the top
Specify an account name (e.g. “Me” or “Business” or whatever)
Copy and paste the access key and secret key into the form and click the “Add” button

Set up an SSH keypair

In Elasticfox, click the “KeyPairs” tab
Click the green “Create” button
Specify a name for the pair (e.g. “EC2”) and hit OK
A file download will initiate (e.g. named “id-EC2”). Save the file in ~/.ssh/
Edit (or create) the file ~/.ssh/config
Add the line:
```
IdentityFile ~/.ssh/id-EC2
```

Set up firewall rules

In Elasticfox, click the “Security Groups” tab
Click green ”+” button to add a group
Set a group name and description (both are required)
Select “I will authorize protocols for this group as needed” and hit “Create Group”
An “Add New Permission” window will pop up automatically
Select “SSH” for the protocol
Select “Network” and set the value to 0.0.0.0/0 and click “Add”
Allow ICMP ping
1. Select the new group and click the green check button to add another rule
2. Protocol Details = “Other”
3. Protocol = ICMP
4. ICMP type = 8
5. ICMP Code = 0
6. Select “Network” and set it to 0.0.0.0/0 and click “Add”
For any other TCP port you may need
1. Select the new group and click the green check button to add another rule
2. Protocol Details = “Other”
3. Protocol = TCP/IP
4. Port range = (lower port number) to (higher port number)—or enter the same port twice to have no range
5. Select “Network” and set it to 0.0.0.0/0 and click “Add”

Booting Ubuntu Intrepid

This step is where you actually boot Ubuntu as an Amazon instance.

In Elasticfox, go to “AMIs and Instances” tab
Click the blue “refresh” button and wait for it to load
Enter the Alestic Ubuntu Intrepid image id:
- For 32-bit: ami-7dfd1a14
- For 64-bit: ami-bdfe19d4
Select the AMI and click the green power button to launch
Select the instance type. The cheapest types are as follows:
- For 32-bit: m1.small
- For 64-bit: m1.large
Select or confirm the correct key pair (e.g. “EC2”)
Click the right/left arrow buttons to have your desired firewall group as the only one in the right side
Click Launch
Click the blue refresh button under “Your Instances” until the instance is in a green running state

Initial Setup

Once the instance is running, right click the it and select “Copy public DNS name to clipboard”
In a terminal, type “ssh root@”, and then paste the DNS name, hit enter, and type yes to accept the server’s key. Login should happen automatically using the keypair
Run:
```
apt-get update && apt-get -y upgrade
```
Run
```
user-setup
```
Enter a username and password (I use simple ones since the instance will be terminated shortly) and take the default to whatever other prompts come up

Connect to the instance desktop

In your GNOME, Applications -> Internet -> NX Client for Linux -> NX Client for Linux
Select the session (e.g. “EC2”) and click the “Configure” button
Delete the old hostname and paste in the new instance’s public DNS name
Possibly set the display size to something manageable like 1024×768, otherwise it will run maximized
Click Save, then click OK
Enter the username and password for the instance’s user created in the previous step
Click Login. NX will SSH in and the remote GNOME desktop will come up shortly.
Enjoy!

Reminders

Remember to terminate the instance in Elasticfox when you are finished. Since termination will permanently delete all filesystem data, make sure you copy any important work off the system before terminating.

App Engine Console 1.0beta3 Released

Jason — Fri, 23 Jan 2009 07:55:51 +0000

I am pleased to announce the release of App Engine Console version 1.0beta3. Please see http://con.appspot.com/ for demos, documentation, and downloads.

App Engine Console is an interactive Python session running in the server, which you use from a web browser. Designed to be embedded within App Engine projects, the console assists developers with testing and debugging their code and data in both development and production settings.

New changes to App Engine Console:

Support the SDK version 1.1.8

Full support for Firefox, Chrome, Safari, and Internet Explorer browsers

Several bug fixes and unit tests

Thanks very much to everybody who has emailed me with bug reports, comments, and other feedback. Future plans for App Engine Console include persistent sessions, simultaneous sessions (i.e. “copiloting”), and autocompletion; and I am eager to hear ideas from other App Engine developers.

New Software: Tomboy Wordcount Plugin

Jason — Sat, 26 Jul 2008 15:57:34 +0000

We have a new addition to the software section: Tomboy-Wordcount.

This is a plugin for the excellent Tomboy note taking application. This plugin allows you to quickly determine the number of lines, words, and characters in your note, much like the Unix wc command. Like Tomboy, this plugin is written in C# and runs on Mono.

Screenshot

Sphinx Templates

Jason — Thu, 27 Mar 2008 06:26:47 +0000

This document explains HTML templating with the Sphinx documentation system. Sphinx is a tool for converting restructured text documentation into presentation formats like HTML or LaTeX.

Sphinx is used for Python documentation (compare old vs. new), but it is great for for any project in any language. Integrated wikis (like Trac) are nice; but I prefer to keep the documentation together with the source code. Sphinx is perfect for that. It also looks like a million bucks.

This document was tested on Fedora 8; however it is likely to work on all platforms that Python supports. Please contact me if you have questions or comments.

Getting Started

First, see the Sphinx documentation and get familiar with installing it (easy_install), initializing a project (sphinx-quickstart), and building your standalone HTML docs (make html).

Notice how (as of right now), the templating documentation is suspiciously missing? That is what this document covers. I spoke with Georg Brandi briefly over email and he said that the document is forthcoming. Therefore I will try to make this page here have a how-to style so that it will hopefully complement the official Sphinx docs when they come out.

The Basics

First, read up on the Django-like Jinja templating system, to get a basic feel for how things work. Just scan through it because you can learn more quickly by experimenting with your own templates.

Your Sphinx templates go in a special subdirectory of your documentation source. By default, this is .templates, so we will use that. (It is set in the templates_path directory in conf.py.) Therefore, all of your template files will go in source/.templates.

Templating with Jinja is all about extending (or inheriting) previously-made templates. So the procedure is to make your own template file and say “this file is mostly like such-and-such template, with these differences….”

Sphinx uses the following built-in template files to generate HTML pages:

genindex.html
index.html
layout.html (This is the main one you want to modify)
macros.html
modindex.html
page.html
search.html

Making a Template

To modify a template, choose a filename of the template you want to modify and create a file with the same name in .templates. Go ahead! Create .templates/layout.html with some simple content:

{# Filename: .templates/layout.html #}
This is the new layout!

Now run make html to rebuild the HTML. (Note, for Sphinx versions before 0.1.61945, you must run make clean.) Your documentation is gone, but at least you successfully overrode the old layout template!

Extending a Template

We see that you can make a new layout.html to completely override the old layout.html, but how do you merely modify one small part of it? To change just one part of the original Sphinx template, make a new template that extends the old one, and then put a block in your new file. (If you don’t know about extending and blocks, see the Jinja web page.)

Warning: You may try to make a new layout.html that extends the old layout.html. That is wrong:

{# XXX This is wrong! XXX #}
{# Filename: .templates/layout.html #}
{% extends ‘layout.html’ }

If you don’t believe me, try it! It will cause an infinite loop when layout.html tries to extend itself. Instead, you must use a Sphinx-specific extension to Jinja by prepending the ! character to the template filename:

{# This is just fine #}
{# Filename: .templates/layout.html #}
{ extends ’!layout.html’ }

That’s it! Now you can go crazy making your own blocks that override the old layout template. For example:

{# Filename: .templates/layout.html #}
{ extends ’!layout.html’ }

{ block afterfooter }
Hi!  I am beneath the footer.
{ endblock }

Useful Blocks to Create

Here are some blocks (all in layout.html) that you should start extending. As of this writing, all of these blocks are completely empty in the original layout, so you are not replacing anything, only adding your own content. Therefore they are a good place to experiment.

extrahead
beforerelbar, afterrelbar
beforesidebar1, sidebar1, aftersidebar1
beforedocument, afterdocument
beforesidebar2, aftersidebar2
beforefooter, afterfooter

How To: Add Your Own CSS Stylesheet

To add your own CSS stylesheet, for example, mystyle.css, first create the file in the .static directory. Next, you have a choice depending on what you want to do:

To use your styles in addition to the defaults, add an “extrahead” block in your own layout.html template, like so:
```
{# Filename: .templates/layout.html #}
{ extends ’!layout.html’ }

{ block extrahead }

{ endblock }
```

To completely replace the old styles, replace the html_style variable in conf.py and set it to “mystyle.css”. Of course, you can use @import other styles or do anything else that CSS supports.

How To: Change the “root” page name

I don’t like the default text in the upper-left side of the page. It just says “ProjectName vX.Y documentation” which is pretty boring. To replace it, override the “rootrellink” block in your own template. Here is what I use:

{# Filename: .templates/layout.html #}
{ extends ’!layout.html’ }

{ block rootrellink }

  FooProject (v{{ release }})
  »
  


{ endblock }

How To: Show the current page name in the top navigation bar

I like to show the current page name in the top part of the page, because it provides a kind of “you are here” feel. For example: FooProject » Getting Started » Compiling and Installing

Well, Sphinx builds this for you automatically, except it takes the liberty of deleting the current page from the end of the list! I have no idea why they don’t make it optional, but they just mercilessly chop off the last page from the ancestry list. Here is how you can add it back using templates:

{# Filename: .templates/layout.html #}
{ extends ’!layout.html’ }

{ block relbaritems }
  { if current_page_name != ‘index’ }
{{ title }}

  { endif }
{ endblock }

How To: Extra Sidebar Content

I like to put extra stuff in the sidebar for every page, however maintaining the html_sidebars variable is tedious. To ensure that every page loads your custom HTML in the sidebar, first create .static/mysidebarcontent.html page with something in it. (Note this file goes in .static, not .templates.)

Next, put this in your layout.html:

{# Filename: .templates/layout.html #}
{ extends ’!layout.html’ }

{ set customsidebar = ‘mysidebarcontent.html’ %}

I know it’s kludgy but it works. You may also want to consider doing this in page.html if you don’t want the custom sidebar stuff on the special index, module index, etc. pages.

Final Comments

Here are some final notes that I have accumulated in no particular order:

Searching seems to work only if you include the document source. So make sure you set html_copy_source to True in conf.py.
html_index is not quite intuitive. It does not simply set the Jinja template to use for the index, but rather it activates special handling for the index page. Without it, the index page will build normally using page.html (which extends layout.html). But if you set html_index = “foo.html” for example, then the prefab index.html will run which loads your foo.html inside it in the body (as the indextemplate variable). So remember, index.html is not used unless you set html_index; and if you do set html_index, then your template will merely be rendered as part of the document body. In summary:
- If you want the index page to render using the same template as all the other pages, then you must not set html_index.
- If you want to activate the special template for the index page, you must set html_index in conf.py. The file that you specify will be included in the template.
- If you want to activate the special template and you want to completely override index.html, you must set html_index in conf.py and also create your own index.html in .templates. You will probably want to “extends ‘layout.html’” too. The “indextemplate” variable will be set to whatever you specified in conf.py. To actually render the contents of that file, you must
```
{{ rendertemplate(indextemplate) }}
```
  somewhere in your index.html template.

MonoDevelop 1.0 on CentOS 5 and Fedora: Compiling and Installing

Jason — Mon, 24 Mar 2008 07:40:38 +0000

Recently, I had to get MonoDevelop working on CentOS 5 for a project. Here is my blow-by-blow summary of how to get it working. The procedure is designed for CentOS 5, and it works on my Fedora 8 system as well. Since most of the activity is just compiling stuff from source, it should be pretty easy to follow on a different distribution. It’s just a matter of getting the correct packages installed in the preparation phase.

Objectives
Preparation
Enabling the Environment
Mono 1.9
Libgdiplus
GTK#
Mono.Addins
Monodoc
Mono Tools
Gtksourceview
MonoDevelop
Nant
Finish

Objectives

MonoDevelop platform ready to use on CentOS 5 or Fedora 8

For minimal maintenance headache, use the base operating system to provide as much sofware as possible, with the obvious exception of Mono 1.9 and MonoDevelop 1.0

The install is isolated from the rest of the system. MonoDevelop and its dependencies should have no overlap or interference with the base operating system.

Preparation

Note: In this document, all source code will go in /usr/src/monodevelop-install. All installed packages will go in /usr/local/software.

```
mkdir -p /usr/local/software/mono-1.9
```

sudo chown -R `whoami` /usr/local/software # (Be careful if you already have software here)

```
mkdir -p /usr/src/monodevelop-install
```

yum install glib2-devel pango-devel gtk2-devel glade2-devel libgnome-devel 
            gnome-desktop-devel gnome-panel-devel libgnomeprintui22-devel  
            gtksourceview-devel ruby ruby-rdoc gtkhtml38-devel wget        
            # (maybe openssl-devel also)

echo 'PATH="/usr/local/software/mono-1.9/bin:$PATH"' 
     > /usr/local/software/mono-1.9/env.sh

echo 'export PKG_CONFIG_PATH=/usr/local/software/mono-1.9/lib/pkgconfig' 
     >> /usr/local/software/mono-1.9/env.sh

echo 'export LD_LIBRARY_PATH=/usr/local/software/mono-1.9/lib' 
     >> /usr/local/software/mono-1.9/env.sh

Enabling the Environment

Important: You must always run this command before using Monodevelop, and also before continuing on with this procedure.

source /usr/local/software/mono-1.9/env.sh

In this document, Monodevelop is not completely integrated into the GUI, menus, etc. for a couple of reasons:

Getting Monodevelop to show up in the menus is somewhat distro-specific. For RPM-based distros, look into setting the $XDG_DATA_DIRS variable in /etc/X11/xinit/xinitrc.d/, but you will also have to get the path working. For Debian-based distros, look into doing the same thing in /etc/X11/Xsession.d. And if you happen to be trying this on Solaris, look into /usr/dt/config/Xsession.d. Oh and by the way, the .desktop file that ships with Monodevelop is invalid for my Fedora 8 system! So you will have to manually edit it and (IIRC) remove the TryExec line.
As you can see, this requires a bit of mucking with “standard” package-maintained config files, which I am hesitant to do because it violates the objective of isolation.

All this means you will always have to first source the small shell script which sets up the correct environment variables whenever you want to run Monodevelop.

Mono 1.9

```
cd /usr/src/monodevelop-install
```

wget http://go-mono.com/sources/mono/mono-1.9.tar.bz2

```
tar xjf mono-1.9.tar.bz2
```
```
cd mono-1.9
```

./configure—prefix=/usr/local/software/mono-1.9

Optionally,

—with-ikvm-native=no—with-moonlight=no

Optionally,
```
—with-xen_opt=yes
```

```
make && make install
```

Libgdiplus:

```
cd /usr/src/monodevelop-install
```

wget http://go-mono.com/sources/libgdiplus/libgdiplus-1.9.tar.bz2

```
tar xjf libgdiplus-1.9.tar.bz2
```

```
cd libgdiplus-1.9
```

./configure—prefix=/usr/local/software/mono-1.9

```
make && make install
```

GTK#

```
cd /usr/src/monodevelop-install
```

wget http://go-mono.com/sources/gtk-sharp-2.0/gtk-sharp-2.8.4.tar.bz2

```
tar xjf gtk-sharp-2.8.4.tar.bz2
```

```
cd gtk-sharp-2.8.4
```

./configure—prefix=/usr/local/software/mono-1.9

```
make && make install
```

Mono.Addins:

```
cd /usr/src/monodevelop-install
```

wget http://go-mono.com/sources/mono-addins/mono-addins-0.3.1.tar.bz2

```
tar xjf mono-addins-0.3.1.tar.bz2
```

```
cd mono-addins-0.3.1
```

./configure—prefix=/usr/local/software/mono-1.9

```
make && make install
```

Monodoc

```
cd /usr/src/monodevelop-install
```

wget http://go-mono.com/sources/monodoc/monodoc-1.9.zip

```
unzip monodoc-1.9.zip
```

```
cd monodoc-1.9
```

./configure—prefix=/usr/local/software/mono-1.9

```
make && make install
```

Mono Tools:

```
cd /usr/src/monodevelop-install
```

wget http://go-mono.com/sources/mono-tools/mono-tools-1.9.tar.bz2

```
tar xjf mono-tools-1.9.tar.bz2
```

```
cd mono-tools-1.9
```

./configure—prefix=/usr/local/software/mono-1.9

```
make && make install
```

Gtksourceview:

```
cd /usr/src/monodevelop-install
```

wget http://go-mono.com/sources/gtksourceview-sharp-2.0/gtksourceview-sharp-2.0-0.10.tar.gz

tar xzf gtksourceview-sharp-2.0-0.10.tar.gz

```
cd gtksourceview-sharp-2.0-0.10
```

./configure—prefix=/usr/local/software/mono-1.9

```
make && make install
```

Monodevelop:

```
cd /usr/src/monodevelop-install
```

wget http://go-mono.com/sources/monodevelop/monodevelop-1.0.tar.bz2

```
tar xjf monodevelop-1.0.tar.bz2
```

```
cd monodevelop-1.0
```

./configure—prefix=/usr/local/software/mono-1.9

```
make && make install
```

NAnt

This is optional, but many .NET applications build with it, so it might be worth throwing in there.

```
cd /usr/src/monodevelop-install
```

wget http://downloads.sourceforge.net/nant/nant-0.85-bin.tar.gz

tar xzf nant-0.85-bin.tar.gz -C /usr/local/software/mono-1.9

echo ’#!/bin/bash’ > /usr/local/software/mono-1.9/bin/nant

echo ‘mono /usr/local/software/mono-1.9/nant-0.85/bin/NAnt.exe ”$@”’ >> /usr/local/software/mono-1.9/bin/nant

chmod +x /usr/local/software/mono-1.9/bin/nant

Finished!

You’re done! Run it!

monodevelop

Feel free to contact me if you have any input to add. I will try to add another post for Debian/Ubuntu and possibly Solaris in the future.

New Software: Bzr Notification Plugin

Jason — Thu, 07 Feb 2008 15:06:14 +0000

We have a new addition to the software section: Bzr Notification.

This is a plugin for the Bazaar source code control system. It will pop up a small window when pushes and pulls have completed. This way, you do not need to wait around watching (slow) transactions over the network. Here is a screenshot of bzr_notification in action:

Making Magic with SSH

Jason — Tue, 29 Jan 2008 14:11:29 +0000

I posted my slides from my talk at BarCamp Bangkok on January 26th. The talk mostly covers advanced usage of OpenSSH to do port forwarding, web proxying, and control of remote systems.

View the slides in HTML format: Making Magic with SSH

You can also get the text source file, or download everything in zip format.

New Software: Strangle DNS parsing

Jason — Thu, 24 Jan 2008 12:33:19 +0000

We are happy to release Strangle, an open source DNS message parsing library. You can read all about it from our Strangle summary. Strangle provides a convenient Python interface which leverages the enterprise-grade BIND technology from the Internet Software Consortium. If your Python application needs to understand the meaning in cryptic DNS packets, give it a try!

Proven Corporation » Free Software

One-line shell script server for testing your AJAX and HTTP code

Preparation

Example response file.

Isn't this cool?

Running the server

Storyboarded response sequences

Concluding Notes

Risk-free introduction to CouchDB on Amazon EC2

How to run a quick throwaway Ubuntu EC2 instance

Contents

Objectives

Preparation (One-Time Only)

Install the NX client

Set up NX client for EC2

Install Elasticfox

Input account credentials in Elasticfox

Set up an SSH keypair

Set up firewall rules

Booting Ubuntu Intrepid

Initial Setup

Connect to the instance desktop

Reminders

App Engine Console 1.0beta3 Released

New Software: Tomboy Wordcount Plugin

Screenshot

Sphinx Templates

Getting Started

The Basics

Making a Template

Extending a Template

Useful Blocks to Create

How To: Add Your Own CSS Stylesheet

How To: Change the “root” page name

How To: Show the current page name in the top navigation bar

How To: Extra Sidebar Content

Final Comments

MonoDevelop 1.0 on CentOS 5 and Fedora: Compiling and Installing

Contents

Objectives

Preparation

Enabling the Environment

Mono 1.9

Libgdiplus:

GTK#

Mono.Addins:

Monodoc

Mono Tools:

Gtksourceview:

Monodevelop:

NAnt

Finished!

New Software: Bzr Notification Plugin

Making Magic with SSH

New Software: Strangle DNS parsing