bog/application/bog.go

package application

import (
    "net/http"
	"fmt"
	"strconv"
	//	"io"
	"caj-larsson/bog/domain"
	"caj-larsson/bog/integration"
)

type Router interface {
	HandleFunc(pattern string, handler func(http.ResponseWriter, *http.Request))
	ServeHTTP(http.ResponseWriter, *http.Request)
}

type Bog struct {
	router Router
	file_service domain.BogFileService
	address string
}

func buildFileDataRepository(config FileConfig) domain.FileDataRepository{
	fsBogRepo := new(integration.FileSystemBogRepository)
	fsBogRepo.Root = config.Path
	return fsBogRepo
}

func buildUserAgentRepository(config DatabaseConfig) *integration.SQLiteUserAgentRepository{
	if config.Backend != "sqlite" {
		panic("Can only handle sqlite")
	}
	return integration.NewSQLiteUserAgentRepository(config.Connection)
}

func (b *Bog) fileHandler(w http.ResponseWriter, r *http.Request) {
	if r.URL.Path == "/" {
		fmt.Fprintf(w, "Hi")
		return
	}

	ref := domain.FileReference {r.URL.Path, r.Header["User-Agent"][0]}

	switch r.Method {
	case "GET":
		bog_file, err := b.file_service.OpenOutFile(ref)

		if err == domain.ErrNotExists {
			http.NotFound(w, r)
			return
		}

		if err != nil {
			panic(err)
		}

		http.ServeContent(w, r, bog_file.Path(), bog_file.Modified(), bog_file)
	case "POST":
		fallthrough
	case "PUT":
		size_str := r.Header["Content-Length"][0]

		size, err := strconv.ParseInt(size_str, 10, 64)
		if err != nil {
			w.WriteHeader(422)
			return
		}

		err = b.file_service.SaveFile(ref, r.Body, size)

		if err != nil {
			panic(err)
		}
	}
	return
}

func (b *Bog) routes() {
	b.router.HandleFunc("/", b.fileHandler)
}


func New(config *Configuration) *Bog {
	b := new(Bog)
	b.address = config.bindAddress()

	fsBogRepo := buildFileDataRepository(config.File)
	uaRepo := buildUserAgentRepository(config.Database)

	b.file_service = domain.NewBogFileService(
		uaRepo, fsBogRepo, config.Quota.ParsedSizeBytes(), config.Quota.ParsedDuration(),
	)

	b.router = new(http.ServeMux)
	b.routes()
	return b
}

func (b *Bog) Run() {
	http.ListenAndServe(b.address, b.router)
}