Initial commit

Author: lox

.dockerignore

@@ -0,0 +1,2 @@
+.aptcache
+apt-proxy

.gitignore

@@ -0,0 +1,2 @@
+.aptcache
+apt-proxy

Dockerfile

@@ -0,0 +1,13 @@
+FROM ubuntu:14.10
+
+RUN apt-get update
+RUN apt-get install -y golang git
+
+ENV GOPATH /app
+ADD . /app/src/github.com/lox/apt-proxy
+
+WORKDIR /app/src/github.com/lox/apt-proxy
+RUN go get
+
+EXPOSE 8080
+CMD ["go", "run", "/app/src/github.com/lox/apt-proxy/apt-proxy.go"]

README.md

@@ -0,0 +1,12 @@
+# Apt Proxy
+
+A caching proxy specifically for apt package caching, also rewrites to the fastest local mirror.
+
+Built because [apt-cacher-ng](https://www.unix-ag.uni-kl.de/~bloch/acng/) is unreliable.
+
+## Running via Go
+
+```
+go install github.com/lox/apt-proxy
+$GOBIN/apt-proxy
+```

apt-proxy.go

@@ -0,0 +1,58 @@
+package main
+
+import (
+	"flag"
+	"log"
+	"net/http"
+	"time"
+
+	"github.com/lox/apt-proxy/proxy"
+	"github.com/lox/httpcache"
+)
+
+const (
+	defaultListen = "0.0.0.0:3142"
+	defaultDir    = "./.aptcache"
+)
+
+var cachePatterns = proxy.CachePatternSlice{
+	proxy.NewCachePattern(`deb$`, time.Hour*24*7),
+	proxy.NewCachePattern(`udeb$`, time.Hour*24*7),
+	proxy.NewCachePattern(`DiffIndex$`, time.Hour),
+	proxy.NewCachePattern(`PackagesIndex$`, time.Hour),
+	proxy.NewCachePattern(`Packages\.(bz2|gz|lzma)$`, time.Hour),
+	proxy.NewCachePattern(`SourcesIndex$`, time.Hour),
+	proxy.NewCachePattern(`Sources\.(bz2|gz|lzma)$`, time.Hour),
+	proxy.NewCachePattern(`Release(\.gpg)?$`, time.Hour),
+	proxy.NewCachePattern(`Translation-(en|fr)\.(gz|bz2|bzip2|lzma)$`, time.Hour),
+	proxy.NewCachePattern(`Sources\.lzma$`, time.Hour),
+}
+
+var (
+	version string
+	listen  string
+	dir     string
+)
+
+func init() {
+	flag.StringVar(&listen, "listen", defaultListen, "the host and port to bind to")
+	flag.StringVar(&dir, "cachedir", defaultDir, "the dir to store cache data in")
+	flag.Parse()
+}
+
+func main() {
+	log.Printf("running apt-proxy %s", version)
+
+	cache, err := httpcache.NewDiskCache(dir)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	ap := proxy.NewAptProxy()
+	ap.CachePatterns = cachePatterns
+
+	log.Printf("proxy listening on https://%s", listen)
+	log.Fatal(http.ListenAndServe(listen, &httpcache.Logger{
+		Handler: httpcache.NewHandler(cache, ap.Handler()),
+	}))
+}

http_test.go

@@ -0,0 +1,93 @@
+package main_test
+
+import (
+	"bytes"
+	"io/ioutil"
+	"net/http"
+	"net/http/httptest"
+	"net/url"
+	"testing"
+	"time"
+
+	"github.com/lox/apt-proxy/proxy"
+)
+
+type testFixture struct {
+	proxy, backend *httptest.Server
+}
+
+func newTestFixture(handler http.HandlerFunc, ap *proxy.AptProxy) *testFixture {
+	backend := httptest.NewServer(http.HandlerFunc(handler))
+	backendURL, err := url.Parse(backend.URL)
+	if err != nil {
+		panic(err)
+	}
+
+	ap.Rewriters = append(ap.Rewriters, proxy.RewriterFunc(func(req *http.Request) {
+		req.URL.Host = backendURL.Host
+	}))
+
+	return &testFixture{httptest.NewServer(ap.Handler()), backend}
+}
+
+// client returns an http client configured to use the provided proxy
+func (f *testFixture) client() *http.Client {
+	proxyURL, err := url.Parse(f.proxy.URL)
+	if err != nil {
+		panic(err)
+	}
+
+	return &http.Client{Transport: &http.Transport{Proxy: http.ProxyURL(proxyURL)}}
+}
+
+func (f *testFixture) close() {
+	f.proxy.Close()
+	f.backend.Close()
+}
+
+func assertHeader(t *testing.T, r *http.Response, header string, expected string) {
+	if r.Header.Get(header) != expected {
+		t.Fatalf("Expected header %s=%s, but got '%s'",
+			header, expected, r.Header.Get(header))
+	}
+}
+
+func TestProxyAddsCacheControlHeader(t *testing.T) {
+	handler := func(w http.ResponseWriter, r *http.Request) {
+		w.Write([]byte("Llamas rock"))
+	}
+	ap := proxy.NewAptProxy()
+	ap.CachePatterns = append(ap.CachePatterns, proxy.NewCachePattern(".", time.Hour*100))
+	fixture := newTestFixture(handler, ap)
+	defer fixture.close()
+
+	resp1, err := fixture.client().Get(fixture.backend.URL)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	assertHeader(t, resp1, "Cache-Control", "max-age=360000")
+}
+
+func TestRewritesApply(t *testing.T) {
+	handler := func(w http.ResponseWriter, r *http.Request) {
+		w.Write([]byte("Llamas rock"))
+	}
+	fixture := newTestFixture(handler, proxy.NewAptProxy())
+	defer fixture.close()
+
+	resp, err := fixture.client().Get(
+		"http://archive.ubuntu.com/ubuntu/pool/main/b/bind9/dnsutils_9.9.5.dfsg-3_amd64.deb")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	contents, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if bytes.Compare(contents, []byte("Llamas rock")) != 0 {
+		t.Fatalf("Response content was incorrect, rewrites not applying?")
+	}
+}

proxy/pattern.go

@@ -0,0 +1,45 @@
+package proxy
+
+import (
+	"fmt"
+	"net/http"
+	"regexp"
+	"time"
+)
+
+// New creates a new pattern, which is a regular expression and a duration to
+// override the Cache-Control max-age of any responses that match
+func NewCachePattern(pattern string, d time.Duration) *cachePattern {
+	return &cachePattern{Regexp: regexp.MustCompile(pattern), Duration: d}
+}
+
+type cachePattern struct {
+	*regexp.Regexp
+	Duration time.Duration
+}
+
+type CachePatternSlice []*cachePattern
+
+// MatchString tries to match a given string across all patterns
+func (r CachePatternSlice) MatchString(subject string) (bool, *cachePattern) {
+	for _, p := range r {
+		if p.MatchString(subject) {
+			return true, p
+		}
+	}
+
+	return false, nil
+}
+
+type cachePatternTransport struct {
+	patterns CachePatternSlice
+	upstream http.RoundTripper
+}
+
+func (t cachePatternTransport) RoundTrip(r *http.Request) (*http.Response, error) {
+	resp, err := t.upstream.RoundTrip(r)
+	if match, pattern := t.patterns.MatchString(r.URL.Path); match {
+		resp.Header.Add("Cache-Control", fmt.Sprintf("max-age=%.f", pattern.Duration.Seconds()))
+	}
+	return resp, err
+}

proxy/proxy.go

@@ -0,0 +1,40 @@
+package proxy
+
+import (
+	"net/http"
+	"net/http/httputil"
+
+	"github.com/lox/apt-proxy/ubuntu"
+)
+
+type AptProxy struct {
+	Transport     http.RoundTripper
+	Rewriters     []Rewriter
+	CachePatterns CachePatternSlice
+}
+
+func NewAptProxy() *AptProxy {
+	return &AptProxy{
+		Transport:     http.DefaultTransport,
+		Rewriters:     []Rewriter{ubuntu.NewRewriter()},
+		CachePatterns: CachePatternSlice{},
+	}
+}
+
+func (ap *AptProxy) Handler() http.Handler {
+	return &handler{ap: ap, Handler: &httputil.ReverseProxy{
+		Director: func(r *http.Request) {
+			for _, rewrite := range ap.Rewriters {
+				rewrite.Rewrite(r)
+			}
+
+			r.Host = r.URL.Host
+		},
+		Transport: &cachePatternTransport{ap.CachePatterns, ap.Transport},
+	}}
+}
+
+type handler struct {
+	http.Handler
+	ap *AptProxy
+}

proxy/rewriter.go

@@ -0,0 +1,14 @@
+package proxy
+
+import "net/http"
+
+type Rewriter interface {
+	Rewrite(req *http.Request)
+}
+
+type RewriterFunc func(req *http.Request)
+
+// Rewrite calls f(req).
+func (f RewriterFunc) Rewrite(req *http.Request) {
+	f(req)
+}