Stowage/rest-server
2
0
Fork 0
mirror of https://github.com/restic/rest-server.git synced 2025-10-19 15:43:21 +00:00
Code Issues Projects Releases Packages Wiki Activity

command line args

Browse source
This commit is contained in:
Chapuis Bertil 2015-09-07 15:29:24 +02:00
parent 436de7f687
commit 738e78c439
6 changed files with 110 additions and 74 deletions
Download patch file Download diff file Expand all files Collapse all files

13
auth.go
View file

@ -6,14 +6,25 @@ import (
) )
func Authorize(r *http.Request) error { func Authorize(r *http.Request) error {
htpasswd, err := NewHtpasswdFromFile("/tmp/restic/.htpasswd")
if err != nil {
return errors.New("internal server error")
}
username, password, ok := r.BasicAuth() username, password, ok := r.BasicAuth()
if !ok { if !ok {
return errors.New("malformed basic auth credentials") return errors.New("malformed basic auth credentials")
} }
if username != "user" || password != "pass" { if !htpasswd.Validate(username, password) {
return errors.New("unknown user") return errors.New("unknown user")
} }
repo, err := RepositoryName(r.RequestURI)
if err != nil || repo != username {
return errors.New("wrong repository")
}
return nil return nil
} }

13
context.go
View file

@ -20,7 +20,16 @@ func NewContext(path string) Context {
return Context{path} return Context{path}
} }
func (c *Context) Repository(name string) (Repository, error) { func (c *Context) Repository(name string) (*Repository, error) {
name, err := ParseRepositoryName(name) name, err := ParseRepositoryName(name)
return Repository{filepath.Join(c.path, name)}, err if err != nil {
return nil, err
}
repo, err := NewRepository(filepath.Join(c.path, name))
if err != nil {
return nil, err
}
return repo, nil
} }

100
handlers.go
View file

@ -11,13 +11,13 @@ type Handler func(w http.ResponseWriter, r *http.Request, c *Context)
func HeadConfig(w http.ResponseWriter, r *http.Request, c *Context) { func HeadConfig(w http.ResponseWriter, r *http.Request, c *Context) {
uri := r.RequestURI uri := r.RequestURI
name, errrn := RepositoryName(uri) name, err := RepositoryName(uri)
if errrn != nil { if err != nil {
http.NotFound(w, r) http.NotFound(w, r)
return return
} }
repo, errr := c.Repository(name) repo, err := c.Repository(name)
if errr != nil { if err != nil {
http.NotFound(w, r) http.NotFound(w, r)
return return
} }
@ -29,18 +29,18 @@ func HeadConfig(w http.ResponseWriter, r *http.Request, c *Context) {
func GetConfig(w http.ResponseWriter, r *http.Request, c *Context) { func GetConfig(w http.ResponseWriter, r *http.Request, c *Context) {
uri := r.RequestURI uri := r.RequestURI
name, errrn := RepositoryName(uri) name, err := RepositoryName(uri)
if errrn != nil { if err != nil {
http.NotFound(w, r) http.NotFound(w, r)
return return
} }
repo, errr := c.Repository(name) repo, err := c.Repository(name)
if errr != nil { if err != nil {
http.NotFound(w, r) http.NotFound(w, r)
return return
} }
config, errrc := repo.ReadConfig() config, err := repo.ReadConfig()
if errrc != nil { if err != nil {
http.NotFound(w, r) http.NotFound(w, r)
return return
} }
@ -49,37 +49,37 @@ func GetConfig(w http.ResponseWriter, r *http.Request, c *Context) {
func PostConfig(w http.ResponseWriter, r *http.Request, c *Context) { func PostConfig(w http.ResponseWriter, r *http.Request, c *Context) {
uri := r.RequestURI uri := r.RequestURI
name, errrn := RepositoryName(uri) name, err := RepositoryName(uri)
if errrn != nil { if err != nil {
http.NotFound(w, r) http.NotFound(w, r)
return return
} }
repo, errr := c.Repository(name) repo, err := c.Repository(name)
if errr != nil { if err != nil {
http.NotFound(w, r) http.NotFound(w, r)
return return
} }
config, errc := ioutil.ReadAll(r.Body) config, err := ioutil.ReadAll(r.Body)
if err != nil {
http.NotFound(w, r)
return
}
errc := repo.WriteConfig(config)
if errc != nil { if errc != nil {
http.NotFound(w, r) http.NotFound(w, r)
return return
} }
errwc := repo.WriteConfig(config)
if errwc != nil {
http.NotFound(w, r)
return
}
} }
func ListBlob(w http.ResponseWriter, r *http.Request, c *Context) { func ListBlob(w http.ResponseWriter, r *http.Request, c *Context) {
uri := r.RequestURI uri := r.RequestURI
name, errrn := RepositoryName(uri) name, err := RepositoryName(uri)
if errrn != nil { if err != nil {
http.NotFound(w, r) http.NotFound(w, r)
return return
} }
repo, errr := c.Repository(name) repo, err := c.Repository(name)
if errr != nil { if err != nil {
http.NotFound(w, r) http.NotFound(w, r)
return return
} }
@ -88,13 +88,13 @@ func ListBlob(w http.ResponseWriter, r *http.Request, c *Context) {
http.NotFound(w, r) http.NotFound(w, r)
return return
} }
blobs, errb := repo.ListBlob(bt) blobs, err := repo.ListBlob(bt)
if errb != nil { if err != nil {
http.NotFound(w, r) http.NotFound(w, r)
return return
} }
json, errj := json.Marshal(blobs) json, err := json.Marshal(blobs)
if errj != nil { if err != nil {
http.NotFound(w, r) http.NotFound(w, r)
return return
} }
@ -103,13 +103,13 @@ func ListBlob(w http.ResponseWriter, r *http.Request, c *Context) {
func HeadBlob(w http.ResponseWriter, r *http.Request, c *Context) { func HeadBlob(w http.ResponseWriter, r *http.Request, c *Context) {
uri := r.RequestURI uri := r.RequestURI
name, errrn := RepositoryName(uri) name, err := RepositoryName(uri)
if errrn != nil { if err != nil {
http.NotFound(w, r) http.NotFound(w, r)
return return
} }
repo, errr := c.Repository(name) repo, err := c.Repository(name)
if errr != nil { if err != nil {
http.NotFound(w, r) http.NotFound(w, r)
return return
} }
@ -131,13 +131,13 @@ func HeadBlob(w http.ResponseWriter, r *http.Request, c *Context) {
func GetBlob(w http.ResponseWriter, r *http.Request, c *Context) { func GetBlob(w http.ResponseWriter, r *http.Request, c *Context) {
uri := r.RequestURI uri := r.RequestURI
name, errrn := RepositoryName(uri) name, err := RepositoryName(uri)
if errrn != nil { if err != nil {
http.NotFound(w, r) http.NotFound(w, r)
return return
} }
repo, errr := c.Repository(name) repo, err := c.Repository(name)
if errr != nil { if err != nil {
http.NotFound(w, r) http.NotFound(w, r)
return return
} }
@ -151,8 +151,8 @@ func GetBlob(w http.ResponseWriter, r *http.Request, c *Context) {
http.NotFound(w, r) http.NotFound(w, r)
return return
} }
blob, errb := repo.ReadBlob(bt, id) blob, errr := repo.ReadBlob(bt, id)
if errb != nil { if errr != nil {
http.NotFound(w, r) http.NotFound(w, r)
return return
} }
@ -161,13 +161,13 @@ func GetBlob(w http.ResponseWriter, r *http.Request, c *Context) {
func PostBlob(w http.ResponseWriter, r *http.Request, c *Context) { func PostBlob(w http.ResponseWriter, r *http.Request, c *Context) {
uri := r.RequestURI uri := r.RequestURI
name, errrn := RepositoryName(uri) name, err := RepositoryName(uri)
if errrn != nil { if err != nil {
http.NotFound(w, r) http.NotFound(w, r)
return return
} }
repo, errr := c.Repository(name) repo, err := c.Repository(name)
if errr != nil { if err != nil {
http.NotFound(w, r) http.NotFound(w, r)
return return
} }
@ -181,13 +181,13 @@ func PostBlob(w http.ResponseWriter, r *http.Request, c *Context) {
http.NotFound(w, r) http.NotFound(w, r)
return return
} }
blob, errb := ioutil.ReadAll(r.Body) blob, err := ioutil.ReadAll(r.Body)
if errb != nil { if err != nil {
http.NotFound(w, r) http.NotFound(w, r)
return return
} }
errwb := repo.WriteBlob(bt, id, blob) errw := repo.WriteBlob(bt, id, blob)
if errwb != nil { if errw != nil {
http.NotFound(w, r) http.NotFound(w, r)
return return
} }
@ -196,13 +196,13 @@ func PostBlob(w http.ResponseWriter, r *http.Request, c *Context) {
func DeleteBlob(w http.ResponseWriter, r *http.Request, c *Context) { func DeleteBlob(w http.ResponseWriter, r *http.Request, c *Context) {
uri := r.RequestURI uri := r.RequestURI
name, errrn := RepositoryName(uri) name, err := RepositoryName(uri)
if errrn != nil { if err != nil {
http.NotFound(w, r) http.NotFound(w, r)
return return
} }
repo, errr := c.Repository(name) repo, err := c.Repository(name)
if errr != nil { if err != nil {
http.NotFound(w, r) http.NotFound(w, r)
return return
} }

26
repository.go
View file

@ -14,25 +14,25 @@ type Repository struct {
path string path string
} }
// Creates the file structure of the Repository func NewRepository(path string) (*Repository, error) {
func (r *Repository) Init() error {
dirs := []string{ dirs := []string{
r.path, path,
filepath.Join(r.path, string(backend.Data)), filepath.Join(path, string(backend.Data)),
filepath.Join(r.path, string(backend.Snapshot)), filepath.Join(path, string(backend.Snapshot)),
filepath.Join(r.path, string(backend.Index)), filepath.Join(path, string(backend.Index)),
filepath.Join(r.path, string(backend.Lock)), filepath.Join(path, string(backend.Lock)),
filepath.Join(r.path, string(backend.Key)), filepath.Join(path, string(backend.Key)),
} }
for _, d := range dirs { for _, d := range dirs {
if _, errs := os.Stat(d); errs != nil { _, err := os.Stat(d)
errmk := os.MkdirAll(d, backend.Modes.Dir) if err != nil {
if errmk != nil { err := os.MkdirAll(d, backend.Modes.Dir)
return errmk if err != nil {
return nil, err
} }
} }
} }
return nil return &Repository{path}, nil
} }
func (r *Repository) HasConfig() bool { func (r *Repository) HasConfig() bool {

4
router.go
View file

@ -12,6 +12,10 @@ type Router struct {
Context Context
} }
func NewRouter(context Context) *Router {
return &Router{context}
}
func (router Router) ServeHTTP(w http.ResponseWriter, r *http.Request) { func (router Router) ServeHTTP(w http.ResponseWriter, r *http.Request) {
m := r.Method m := r.Method
u := r.RequestURI u := r.RequestURI

28
server.go
View file

@ -1,19 +1,31 @@
package main package main
import ( import (
//"io/ioutil" "flag"
"log" "log"
"net/http" "net/http"
"path/filepath"
)
const (
HTTP = ":8000"
HTTPS = ":8443"
) )
func main() { func main() {
context := NewContext("/tmp/restic") var path = flag.String("path", "/tmp/restic", "specifies the path of the data directory")
var tls = flag.Bool("tls", false, "turns on tls support")
repo, _ := context.Repository("user") flag.Parse()
repo.Init()
context := NewContext(*path)
router := Router{context} router := Router{context}
port := ":8000" if !*tls {
log.Printf("start server on port %s", port) log.Printf("start server on port %s", HTTP)
http.ListenAndServe(port, router) http.ListenAndServe(HTTP, router)
} else {
log.Printf("start server on port %s", HTTPS)
privateKey := filepath.Join(*path, "private_key")
publicKey := filepath.Join(*path, "public_key")
http.ListenAndServeTLS(HTTPS, privateKey, publicKey, router)
}
} }