server/server.go

   1 //
   2 // Armadillo File Manager
   3 // Copyright (c) 2010-2012, Robert Sesek <http://www.bluestatic.org>
   4 //
   5 // This program is free software: you can redistribute it and/or modify it under
   6 // the terms of the GNU General Public License as published by the Free Software
   7 // Foundation, either version 3 of the License, or any later version.
   8 //
   9
  10 package server
  11
  12 import (
  13         "github.com/rsesek/armadillo/config"
  14         "encoding/json"
  15         "fmt"
  16         "io"
  17         "net/http"
  18         "os"
  19         "path"
  20         "strings"
  21 )
  22
  23 var dir, file = path.Split(path.Clean(os.Getenv("_")))
  24 var kFrontEndFiles string = path.Join(dir, "frontend")
  25 var gConfig *config.Configuration
  26
  27 func indexHandler(response http.ResponseWriter, request *http.Request) {
  28         fd, err := os.Open(path.Join(kFrontEndFiles, "index.html"))
  29         if err != nil {
  30                 fmt.Print("Error opening file ", err.Error(), "\n")
  31                 return
  32         }
  33         defer fd.Close()
  34
  35         response.Header().Set("Content-Type", "text/html")
  36         io.Copy(response, fd)
  37 }
  38
  39 func serviceHandler(response http.ResponseWriter, request *http.Request) {
  40         if request.Method != "POST" {
  41                 io.WriteString(response, "Error: Not a POST request")
  42                 return
  43         }
  44
  45         switch request.FormValue("action") {
  46         case "list":
  47                 files, err := ListPath(request.FormValue("path"))
  48                 if err != nil {
  49                         errorResponse(response, err.Error())
  50                 } else {
  51                         okResponse(response, files)
  52                 }
  53         case "remove":
  54                 err := RemovePath(request.FormValue("path"))
  55                 if err != nil {
  56                         errorResponse(response, err.Error())
  57                 } else {
  58                         data := map[string]int{
  59                                 "error": 0,
  60                         }
  61                         okResponse(response, data)
  62                 }
  63         case "move":
  64                 source := request.FormValue("source")
  65                 target := request.FormValue("target")
  66                 err := MovePath(source, target)
  67                 if err != nil {
  68                         errorResponse(response, err.Error())
  69                 } else {
  70                         data := map[string]interface{}{
  71                                 "path":  target,
  72                                 "error": 0,
  73                         }
  74                         okResponse(response, data)
  75                 }
  76         case "mkdir":
  77                 path := request.FormValue("path")
  78                 err := MakeDir(path)
  79                 if err != nil {
  80                         errorResponse(response, err.Error())
  81                 } else {
  82                         data := map[string]interface{}{
  83                                 "path":  path,
  84                                 "error": 0,
  85                         }
  86                         okResponse(response, data)
  87                 }
  88         case "tv_rename":
  89                 newPath, err := RenameTVEpisode(request.FormValue("path"))
  90                 if err != nil {
  91                         errorResponse(response, err.Error())
  92                 } else {
  93                         data := map[string]interface{}{
  94                                 "path":  *newPath,
  95                                 "error": 0,
  96                         }
  97                         okResponse(response, data)
  98                 }
  99         default:
 100                 fmt.Printf("Invalid action: '%s'\n", request.FormValue("action"))
 101                 errorResponse(response, "Unhandled action")
 102         }
 103 }
 104
 105 func downloadHandler(response http.ResponseWriter, request *http.Request) {
 106         valid, fullPath := IsValidPath(request.FormValue("path"))
 107         if valid {
 108                 info, _ := os.Lstat(fullPath) // Error is already checked by |valid|.
 109                 if info.IsDir() {
 110                         http.Error(response, "Path is a directory", http.StatusBadRequest)
 111                 } else {
 112                         http.ServeFile(response, request, fullPath)
 113                 }
 114         } else {
 115                 http.NotFound(response, request)
 116         }
 117 }
 118
 119 func errorResponse(response http.ResponseWriter, message string) {
 120         message = strings.Replace(message, gConfig.JailRoot, "/", -1)
 121         data := map[string]interface{}{
 122                 "error":   -1,
 123                 "message": message,
 124         }
 125         json_data, err := json.Marshal(data)
 126
 127         response.Header().Set("Content-Type", "text/json")
 128         if err != nil {
 129                 io.WriteString(response, "{\"error\":\"-9\",\"message\":\"Internal encoding error\"}")
 130         } else {
 131                 response.Write(json_data)
 132         }
 133 }
 134
 135 func okResponse(response http.ResponseWriter, data interface{}) {
 136         response.Header().Set("Content-Type", "text/json")
 137         json_data, err := json.Marshal(data)
 138         if err != nil {
 139                 errorResponse(response, "Internal encoding error")
 140         } else {
 141                 response.Write(json_data)
 142         }
 143 }
 144
 145 func RunBackEnd(c *config.Configuration) {
 146         gConfig = c
 147
 148         mux := http.NewServeMux()
 149         mux.HandleFunc("/", indexHandler)
 150         mux.Handle("/fe/", http.StripPrefix("/fe/", http.FileServer(http.Dir(kFrontEndFiles))))
 151         mux.HandleFunc("/service", serviceHandler)
 152         mux.HandleFunc("/download", downloadHandler)
 153
 154         error := http.ListenAndServe(fmt.Sprintf(":%d", gConfig.Port), mux)
 155         fmt.Printf("error %v", error)
 156 }