Try a different project structure

deb/archive/archive.go

@@ -0,0 +1,82 @@
+package archive
+
+import (
+	"os"
+	"fmt"
+	"github.com/blakesmith/ar"
+	"bytes"
+	"io"
+	"strings"
+	"compress/gzip"
+	"archive/tar"
+	"log"
+)
+
+func InspectPackage(filename string) (string, error) {
+	f, err := os.Open(filename)
+
+	if err != nil {
+		return "", fmt.Errorf("error opening package file %s: %s", filename, err)
+	}
+
+	arReader := ar.NewReader(f)
+	defer f.Close()
+	var controlBuf bytes.Buffer
+
+	for {
+		header, err := arReader.Next()
+
+		if err == io.EOF {
+			break
+		}
+
+		if err != nil {
+			return "", fmt.Errorf("error in inspectPackage loop: %s", err)
+		}
+
+		if strings.Trim(header.Name, "/") == "control.tar.gz" {
+			io.Copy(&controlBuf, arReader)
+			return InspectPackageControl(controlBuf)
+		}
+	}
+	return "", nil
+}
+
+func InspectPackageControl(filename bytes.Buffer) (string, error) {
+	gzf, err := gzip.NewReader(bytes.NewReader(filename.Bytes()))
+	if err != nil {
+		return "", fmt.Errorf("error creating gzip reader: %s", err)
+	}
+
+	tarReader := tar.NewReader(gzf)
+	var controlBuf bytes.Buffer
+	for {
+		header, err := tarReader.Next()
+
+		if err == io.EOF {
+			break
+		}
+
+		if err != nil {
+			return "", fmt.Errorf("failed to inspect package: %s", err)
+		}
+
+		name := header.Name
+
+		switch header.Typeflag {
+		case tar.TypeDir:
+			continue
+		case tar.TypeReg:
+			if name == "./control" {
+				io.Copy(&controlBuf, tarReader)
+				return controlBuf.String(), nil
+			}
+		default:
+			log.Printf(
+				"Unable to figure out type : %c in file %s\n",
+				header.Typeflag, name,
+			)
+		}
+	}
+	return "", nil
+}

deb/release/release.go

@@ -0,0 +1,42 @@
+package release
+
+import (
+	"time"
+	"io"
+	"bufio"
+)
+
+type Release struct {
+	Architectures []string
+	Origin string
+	Label string
+	Suite string
+	Codename string
+	Version string
+	Components []string
+	Date time.Time
+	Files []*File
+}
+
+func (r *Release) Append(f *File) {
+	if r.Files == nil {
+		r.Files = make([]*File, 0)
+	}
+
+	r.Files = append(r.Files, f)
+}
+
+func (r *Release) Write(w io.Writer) {
+	bufw := &writer{bufio.NewWriter(w)}
+
+	bufw.WriteValue("Suite", r.Suite)
+	bufw.WriteSlice("Architectures", r.Architectures)
+	bufw.WriteSlice("Components", r.Components)
+	bufw.WriteValue("Date", r.Date.In(time.UTC).Format("Mon, 02 Jan 2006 15:04:05 -0700"))
+
+	bufw.WriteHashTable("MD5Sum", r.Files)
+	bufw.WriteHashTable("SHA1", r.Files)
+	bufw.WriteHashTable("SHA256", r.Files)
+
+	bufw.Flush()
+}

deb/release/release_file.go

@@ -0,0 +1,20 @@
+package release
+
+type File struct {
+	Name string
+	Size int64
+	MD5Sum string
+	SHA1 string
+	SHA256 string
+}
+
+func (f *File) Hash(key string) string {
+	if key == "MD5Sum" {
+		return f.MD5Sum
+	} else if key == "SHA1" {
+		return f.SHA1
+	} else if key == "SHA256" {
+		return f.SHA256
+	}
+	return ""
+}

deb/release/release_test.go

@@ -0,0 +1,22 @@
+package release
+
+import (
+	"testing"
+	"bytes"
+	"time"
+)
+
+func TestRelease_Write(t *testing.T) {
+	r := &Release{
+		Architectures: []string{"all", "i386", "amd64"},
+		Suite: "stable",
+		Components: []string{"main"},
+		Date: time.Now(),
+	}
+
+	var b bytes.Buffer
+
+	r.Write(&b)
+
+	t.Log(b.String())
+}

deb/release/writer.go

@@ -0,0 +1,47 @@
+package release
+
+import (
+	"strings"
+	"fmt"
+	"bufio"
+)
+
+type writer struct {
+	writer *bufio.Writer
+}
+
+func (r *writer) WriteValue(key, value string) (int, error) {
+	if len(value) == 0 {
+		return 0, nil
+	}
+
+	return r.writer.WriteString(key + ": " + value + "\n")
+}
+
+func (r *writer) WriteSlice(key string, s []string) (int, error) {
+	if len(s) == 0 {
+		return 0, nil
+	}
+
+	return r.writer.WriteString(key + ": " + strings.Join(s, " ") + "\n")
+}
+
+func (r *writer) WriteHashTable(key string, files []*File) {
+	if files == nil || len(files) == 0 {
+		return
+	}
+
+	r.writer.WriteString(key + ":\n")
+
+	var hash string
+
+	for _, f := range files {
+		if hash = f.Hash(key); hash != "" {
+			fmt.Fprintf(r.writer, " %s %d %s\n", hash, f.Size, f.Name)
+		}
+	}
+}
+
+func (r *writer) Flush() {
+	r.writer.Flush()
+}