Combine rcrowley/home and rcrowley/rcrowley.

.gitignore

@@ -1,3 +1,16 @@
 *
+!.bash_profile
+!.gemrc
+!.gitconfig
+!.gitignore
+!.profile
+!.profile.d
+!.ssh/config
+!.tmux.conf
 !.vimrc
 !.vim
+!LICENSE
+!README.md
+!bin
+!share
+!var

.profile.d/path.sh

@@ -1,7 +1,7 @@
 # Extra search pathnames.
-for BINDIR in "$HOME/bin" "/opt/local/bin" /var/lib/gems/*/bin
+for BINDIR in "$HOME/local/bin" "$HOME/bin" "/opt/local/bin" /var/lib/gems/*/bin
 do
 	[ -d "$BINDIR" ] || continue
-	expr "$PATH" : ".*$BINDIR" >/dev/null && continue
+	expr "$PATH" : ".*$BINDIR" >"/dev/null" && continue
 	export PATH="$BINDIR:$PATH"
 done

README.md

@@ -0,0 +1,12 @@
+rcrowley's home
+===============
+
+This repository is meant to **be** my home directory, which, if you're not provisioning systems with Puppet code that does this for you, is a slightly awkward thing to accomplish.  I do roughly the following with new boxen:
+
+```sh
+cd
+git init
+git remote add "origin" "git://github.com/rcrowley/home.git"
+git remote update "origin"
+git pull "origin" "master"
+```

bin/build

@@ -0,0 +1,169 @@
+#!/usr/bin/env python
+
+from datetime import datetime
+from django import template
+from django.conf import settings
+from django.template import Context, Template
+from django.template import defaultfilters
+from django.template import loader
+import os
+import os.path
+from xml.etree import ElementTree
+
+# A puppy dies every time Fredrik Lundh serializes XML.
+NS = 'http://www.w3.org/2005/Atom'
+ElementTree._namespace_map[NS] = 'atom'
+
+settings.configure(DEBUG=True,
+                   TEMPLATE_DEBUG=True,
+                   TEMPLATE_LOADERS=(
+                       'django.template.loaders.filesystem.Loader',
+                   ),
+                   TEMPLATE_DIRS=(
+                       os.path.normpath(os.path.join(os.path.dirname(__file__),
+                                                     '..',
+                                                     'share',
+                                                     'templates')),
+                   ))
+
+def qname(name):
+    """
+    Return a node name qualified with the Atom namespace.
+    """
+    return unicode(ElementTree.QName(NS, name))
+
+class Atom(object):
+
+    def __init__(self, title, alternate, id, author):
+        """
+        Create an empty Atom feed.
+        """
+        self.title = title
+        self.alternate = alternate
+        self.author = author
+        feed = ElementTree.Element(qname('feed'))
+        ElementTree.SubElement(feed,
+                               qname('title'),
+                               {'type': 'html'}).text = self.title
+        ElementTree.SubElement(feed,
+                               qname('link'),
+                               {'href': id,
+                                'rel': 'self'})
+        ElementTree.SubElement(feed,
+                               qname('link'),
+                               {'href': alternate,
+                                'rel': 'alternate'})
+        ElementTree.SubElement(feed, 'id').text = id
+        ElementTree.SubElement(feed, qname('updated'))
+        ElementTree.SubElement(
+            ElementTree.SubElement(feed,
+                                   qname('author')),
+            qname('name')).text = self.author
+        self.etree = ElementTree.ElementTree(feed)
+
+    def entry(self,
+              title=None,
+              alternate=None,
+              id=None,
+              author=None,
+              content=''):
+        """
+        Create a new <entry> at the end of the Atom feed.  Fill the new
+        <entry> with the parameters or sensible defaults.
+        """
+
+        # Find sensible defaults for omitted arguments.
+        if title is None:
+            title = self.title
+        if alternate is None:
+            alternate = self.alternate
+        if author is None:
+            author = self.author
+
+        # Setup the new <entry>.
+        entry = ElementTree.SubElement(self.etree.getroot(), qname('entry'))
+
+        # Place the article in the <entry>.
+        ElementTree.SubElement(entry,
+                               qname('title'),
+                               {'type': 'html'}).text = title
+        ElementTree.SubElement(entry,
+                               qname('link'),
+                               {'href': alternate,
+                                'rel': 'alternate'})
+        ElementTree.SubElement(entry, qname('id')).text = id
+        ElementTree.SubElement(entry, qname('published')).text \
+            = datetime.today().strftime('%Y-%m-%dT%H:%M:%SZ')
+        ElementTree.SubElement(entry, qname('updated')).text \
+            = datetime.today().strftime('%Y-%m-%dT%H:%M:%SZ')
+        ElementTree.SubElement(
+            ElementTree.SubElement(entry,
+                                   qname('author')),
+            qname('name')).text = author
+        ElementTree.SubElement(entry,
+                               qname('content'),
+                               {'type': 'html'}).text = content
+
+    def __str__(self):
+        """
+        Serialize the Atom feed.
+        """
+        self.etree.find(qname('updated')).text \
+            = datetime.today().strftime('%Y-%m-%dT%H:%M:%SZ')
+        return ElementTree.tostring(self.etree.getroot())
+
+def feed(pathnames):
+
+    document_root = os.path.join(os.path.dirname(__file__), 'public')
+    server_name = 'rcrowley.org'
+    author = 'Richard Crowley'
+    feed_title = 'Richard Crowley&#8217;s blog'
+
+    a = Atom(title=feed_title,
+             alternate='http://{0}/'.format(server_name),
+             id='http://{0}/index.xml'.format(server_name),
+             author=author)
+
+    if 0 == len(pathnames):
+        return str(a)
+    if isinstance(pathnames, str):
+        pathnames = pathnames.rstrip().split('\n')
+    sys.stderr.write('{0}\n'.format(repr(pathnames)))
+    for pathname in pathnames:
+        pathname = pathname.rstrip()
+        url = 'http://{0}/{1}'.format(server_name, pathname)
+        try:
+            source = open(os.path.join('templates', pathname)).read()
+            a.entry(title=title(source),
+                    alternate=url,
+                    id=url,
+                    author=author,
+                    content=content(source))
+        except IOError:
+            a.entry(title=pathname,
+                    alternate=url,
+                    id=url,
+                    author=author,
+                    content='<a href="{0}">{0}</a>'.format(url))
+    return str(a)
+
+# Various ways to render the same Django template.
+def content(source):
+    t = Template('\n'.join(['{% extends "content.html" %}', source]))
+    return t.render(Context())
+def page(source):
+    t = Template('\n'.join(['{% extends "page.html" %}', source]))
+    return t.render(Context())
+def title(source):
+    t = Template('\n'.join(['{% extends "title.html" %}', source]))
+    return defaultfilters.striptags(t.render(Context()))
+
+if '__main__' == __name__:
+    import sys
+    import __main__
+    if 2 == len(sys.argv) and hasattr(__main__, sys.argv[1]):
+        print(getattr(__main__, sys.argv[1])(sys.stdin.read()))
+    else:
+        sys.stderr.write('Usage: {0} feed|page|title\n'.format(
+            os.path.basename(sys.argv[0])))
+        sys.exit(1)

bin/www

@@ -0,0 +1,15 @@
+#!/bin/sh
+
+set -e
+
+mkdir -p "$HOME/src/github.com/rcrowley"
+cd "$HOME/src/github.com/rcrowley"
+if [ ! -d "go-metrics" ]
+then git clone "git@github.com:rcrowley/go-metrics.git"
+fi
+if [ ! -d "go-tigertonic" ]
+then git clone "git@github.com:rcrowley/go-tigertonic.git"
+fi
+cd "-" >"/dev/null"
+
+exec go run "$(dirname "$0")/www.go" "$@"

bin/www.go

@@ -0,0 +1,130 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+	"github.com/rcrowley/go-metrics"
+	"github.com/rcrowley/go-tigertonic"
+	"io"
+	"log"
+	"net/http"
+	"net/url"
+	"os"
+	"path"
+)
+
+var (
+	cert   = flag.String("cert", "", "certificate pathname")
+	key    = flag.String("key", "", "private key pathname")
+	listen = flag.String("listen", ":80", "listen address")
+
+	mux  *tigertonic.TrieServeMux
+	hMux tigertonic.HostServeMux
+)
+
+func init() {
+	flag.Usage = usage
+	log.SetFlags(log.Ltime | log.Lmicroseconds | log.Lshortfile)
+	mux = tigertonic.NewTrieServeMux()
+	mux.HandleNamespace(
+		"",
+		tigertonic.Timed(
+			tigertonic.First(
+				http.HandlerFunc(tryHTML),
+				http.FileServer(http.Dir("var/www")),
+			),
+			"rcrowley.org",
+			nil,
+		),
+	)
+	mux.Handle(
+		"GET",
+		"/metrics",
+		tigertonic.Timed(
+			tigertonic.Marshaled(metricsJSON),
+			"GET-metrics",
+			nil,
+		),
+	)
+	mux.Handle(
+		"GET",
+		"/pinboard.xml",
+		tigertonic.Timed(
+			http.HandlerFunc(pinboardXML),
+			"GET-pinboard-xml",
+			nil,
+		),
+	)
+	hMux = tigertonic.NewHostServeMux()
+	hMux.Handle(
+		"packages.devstructure.com",
+		tigertonic.Timed(
+			http.FileServer(http.Dir("var/cache/freight")),
+			"packages.devstructure.com",
+			nil,
+		),
+	)
+	hMux.Handle(
+		"packages.rcrowley.org",
+		tigertonic.Timed(
+			http.FileServer(http.Dir("var/cache/freight")),
+			"packages.rcrowley.org",
+			nil,
+		),
+	)
+	hMux.Handle("rcrowley.org", mux)
+	hMux.Handle("127.0.0.1:48879", mux) // For development convenience.
+}
+
+func main() {
+	flag.Parse()
+	server := tigertonic.NewServer(*listen, tigertonic.ApacheLogged(hMux))
+	var err error
+	if "" != *cert && "" != *key {
+		err = server.ListenAndServeTLS(*cert, *key)
+	} else {
+		err = server.ListenAndServe()
+	}
+	if nil != err {
+		log.Fatalln(err)
+	}
+}
+
+func metricsJSON(*url.URL, http.Header, interface{}) (int, http.Header, *metrics.StandardRegistry, error) {
+	return http.StatusOK, nil, metrics.DefaultRegistry, nil
+}
+
+func pinboardXML(w http.ResponseWriter, r *http.Request) {
+	res, err := http.Get("http://feeds.pinboard.in/rss/u:rcrowley")
+	if nil != err {
+		goto Error
+	}
+	defer res.Body.Close()
+	if _, err := io.Copy(w, res.Body); nil != err {
+		goto Error
+	}
+	return
+Error:
+	w.Header().Set("Content-Type", "text/xml; charset=utf-8")
+	w.WriteHeader(http.StatusInternalServerError)
+	w.Write([]byte("<?xml version=\"1.0\"?>\n<xml/>\n"))
+}
+
+func tryHTML(w http.ResponseWriter, r *http.Request) {
+	pathname := path.Clean(path.Join(
+		"var/www",
+		fmt.Sprintf("%s.html", r.URL.Path),
+	))
+	if _, err := os.Stat(pathname); nil != err {
+		return
+	}
+	http.ServeFile(w, r, pathname)
+}
+
+func usage() {
+	fmt.Fprintln(
+		os.Stderr,
+		"Usage: www [-cert=<cert>] [-key=<key>] [-listen=<listen>]",
+	)
+	flag.PrintDefaults()
+}

share/.gitignore

@@ -0,0 +1 @@
+!*