package main import ( "bytes" "encoding/json" "github.com/geplauder/lithium/auth" "github.com/geplauder/lithium/pipelines" "github.com/geplauder/lithium/settings" "github.com/geplauder/lithium/storage" "github.com/gorilla/mux" "github.com/spf13/afero" "io" "net/http" ) const Name string = "Lithium" const Version string = "0.1.0" type Metadata struct { Name string `json:"name"` Version string `json:"version"` } func PipelineHandler(pipeline pipelines.IPipeline, storageProvider storage.IStorageProvider, w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Type", "application/json") err := json.NewEncoder(w).Encode(pipeline) if err != nil { w.WriteHeader(http.StatusInternalServerError) } } func IndexHandler(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Type", "application/json") err := json.NewEncoder(w).Encode(Metadata{Name, Version}) if err != nil { w.WriteHeader(http.StatusInternalServerError) } } func writeError(w http.ResponseWriter, status int, errStr string) { w.WriteHeader(status) json.NewEncoder(w).Encode(struct { Error string `json:"error"` }{errStr}) } func UploadHandler(w http.ResponseWriter, r *http.Request, pipes []pipelines.IPipeline, storageProvider storage.IStorageProvider) { // open file handler formFile, handler, err := r.FormFile("file") if err != nil { writeError(w, http.StatusUnprocessableEntity, err.Error()) return } defer formFile.Close() // check pipelines form param formPipeline := r.FormValue("pipeline") if formPipeline == "" { writeError(w, http.StatusUnprocessableEntity, "pipeline parameter missing") return } var execPipe pipelines.IPipeline for _, pipe := range pipes { if formPipeline == pipe.GetSlug() { execPipe = pipe break } } if execPipe == nil { writeError(w, http.StatusUnprocessableEntity, "pipeline not found") return } bucket := r.FormValue("bucket") if bucket == "" { writeError(w, http.StatusUnprocessableEntity, "bucket parameter missing") return } // open file file, err := handler.Open() if err != nil { writeError(w, http.StatusInternalServerError, "error reading uploaded file") return } defer file.Close() // read file to buffer buf := bytes.NewBuffer(nil) _, err = io.Copy(buf, file) if err != nil { writeError(w, http.StatusInternalServerError, "error reading file from buffer") return } // store uploaded file _, err = storageProvider.StoreRaw(bucket, "source.jpg", buf.Bytes()) if err != nil { return } w.Header().Set("Content-Type", "application/json") err = json.NewEncoder(w).Encode(struct { Message string `json:"message"` }{"ok"}) if err != nil { w.WriteHeader(http.StatusInternalServerError) } } func RegisterRoutes(r *mux.Router, pipelines []pipelines.IPipeline, storageProvider storage.IStorageProvider) { r.HandleFunc("/", IndexHandler).Methods("GET") r.HandleFunc("/upload", func(w http.ResponseWriter, r *http.Request) { UploadHandler(w, r, pipelines, storageProvider) }).Methods("POST") r.HandleFunc("/pipelines/{pipeline}", func(w http.ResponseWriter, r *http.Request) { for _, pipeline := range pipelines { if pipeline.GetSlug() == mux.Vars(r)["pipeline"] { PipelineHandler(pipeline, storageProvider, w, r) return } } w.WriteHeader(404) }).Methods("GET") } func main() { appSettings, err := settings.LoadSettings(afero.NewOsFs()) if err != nil { panic(err) } var storageProvider storage.IStorageProvider if appSettings.StorageProvider.Type == 0 { storageProvider = storage.GetFileSystemStorageProvider(appSettings.StorageProvider.BasePath, "") } else { panic("Invalid file system provided!") } pipes := pipelines.LoadPipelines() authMiddleware := auth.CreateAuthenticationMiddleware(appSettings.Token) r := mux.NewRouter() r.Use(authMiddleware.Middleware) RegisterRoutes(r, pipes, storageProvider) err = http.ListenAndServe(appSettings.Endpoint, r) if err != nil { panic(err) } }