func (p *proxy) serveExistingFile(w http.ResponseWriter, r *http.Request) bool { reqFile := r.URL.Path[1:] cachedFile := p.cacheDir + reqFile if common.FileExists(cachedFile) { f, err := os.Open(cachedFile) if err != nil { if false == os.IsNotExist(err) { common.InfoErr("Cannot open %q because %s\n", cachedFile, err.Error()) } return false } defer func() { if err := f.Close(); err != nil { common.InfoErr("Failed to close file %q with Error %s\n", reqFile, err) } }() addHeaders(filepath.Ext(reqFile), cacheUntil, w) if _, err := io.Copy(w, f); err != nil { common.InfoErr("Error copying file content to http response: %s with file %q", err, reqFile) return false } return true } return false }
func newHandle(ctx *cli.Context) *handle { csvFile := ctx.String("csv") var rec [][]string if csvFile != "" { rec = record.GetCSVContent(csvFile) } h := &handle{ proxy: newProxy(ctx), fileMap: make(map[string]record.Record), pattern: ctx.String("img-pattern"), } h.Lock() defer h.Unlock() if vif := ctx.String("img-config"); vif != "" { var err error if h.virtualImages, err = parseVirtualImageConfigFile(vif); err != nil { common.InfoErr("File %s contains error:\n%s\n", vif, err) } } h.fileMap["favicon.ico"] = record.NewRecordFields("icon", "favicon.ico", 16, 16) for _, row := range rec { rec, err := record.NewRecord(h.pattern, row...) if err != nil { common.InfoErr("File %s contains error: %s\n", csvFile, err) } rec.Path = ctx.String("url-prefix") + rec.Path h.fileMap[rec.Path] = rec } h.length = len(rec) return h }
func (w *traverse) close() { w.workerStop <- struct{}{} close(w.workerRec) if err := w.outW.Close(); err != nil { common.InfoErr("GZIP close error: %s\n", err) } if err := w.outF.Close(); err != nil { common.InfoErr("File close error: %s\n", err) } w.bar.Finish() fmt.Fprintf(w.cliWriter, "Wrote to file: %s\n", w.outfile) }
func (h *handle) rootJSON(w http.ResponseWriter, r *http.Request) { w.Header().Set(ContentType, ApplicationJSONCharsetUTF8) h.RLock() //if err := json.NewEncoder(w).Encode(h.virtualImages); err != nil { // common.InfoErr("Failed to write JSON encoded virtual image configuration with error: %s\n", err) //} for _, rec := range h.fileMap { if err := rec.ToJSON(w); err != nil { common.InfoErr("Failed to write JSON with error: %s\n", err) } if _, err := w.Write(brByte); err != nil { common.InfoErr("Failed to write JSON with error: %s\n", err) } } h.RUnlock() }
func getImageDimension(imagePath string) (int, int) { file, err := os.Open(imagePath) if err != nil { common.InfoErr("Cannot open image: %s\n", err) return 0, 0 } image, _, err := image.DecodeConfig(file) if err != nil { common.InfoErr("Image %s decoding error: %s\n", imagePath, err) return 0, 0 } if err := file.Close(); err != nil { common.InfoErr("Close error: %s: %s\n", imagePath, err) return 0, 0 } return image.Width, image.Height }
// post or get request // $ curl --data "file=media/catalog/product/1/2/120---microsoft-natural-ergonomic-keyboard-4000.jpg" http://127.0.0.1:4711/fileDetails // and returns: // {"Path":"media/catalog/product/1/2/120---microsoft-natural-ergonomic-keyboard-4000.jpg","ModTime":"2014-02-16T03:27:45+01:00","Width":5184,"Height":3456} func (h *handle) fileDetails(w http.ResponseWriter, r *http.Request) { filePath := r.FormValue("file") if filePath == "" { http.NotFound(w, r) return } h.RLock() defer h.RUnlock() rec, ok := h.fileMap[filePath] if !ok { common.InfoErr("%s not found in CSV file\n", filePath) http.NotFound(w, r) return } w.Header().Set(ContentType, ApplicationJSONCharsetUTF8) if err := rec.ToJSON(w); err != nil { common.InfoErr("Failed to write JSON with error: %s\n", err) } }
func (r Record) CreateContent(f string, w io.Writer) { switch r.ext { case ".png": if err := png.Encode(w, r.generateImage()); err != nil { common.InfoErr("Failed to create PNG file %s with error: %s\n", f, err) } case ".jpg", ".jpeg": // big file size? reason why is here: https://www.reddit.com/r/golang/comments/3kn1zp/filesize_of_jpegencode/ if err := jpeg.Encode(w, r.generateImage(), &jpeg.Options{Quality: 75}); err != nil { common.InfoErr("Failed to create JPEG file %s with error: %s\n", f, err) } case ".gif", ".ico": if err := gif.Encode(w, r.generateImage(), nil); err != nil { common.InfoErr("Failed to create GIF file %s with error: %s\n", f, err) } default: if _, err := w.Write(nil); err != nil { common.InfoErr("Failed to write file %s with error: %s\n", f, err) } } }
func (r Record) CreateFile(basePath string) error { d, f := r.getDirFile(basePath) if err := os.MkdirAll(d, DirPerm); err != nil { common.UsageAndExit("Failed to create directory: %s with error: %s", d, err) } file, err := os.Create(d + f) if err != nil { return fmt.Errorf("Failed to create file %s%s", d, f) } defer func() { if err := file.Close(); err != nil { common.InfoErr("Failed to close file %s with error: %s\n", d+f, err) } }() if err := os.Chtimes(d+f, r.ModTime, r.ModTime); err != nil { common.InfoErr("Failed to change time for file %s with error: %s\n", d+f, err) } r.CreateContent(f, file) return nil }
func (p *proxy) serveAndSaveRemoteFile(w http.ResponseWriter, r *http.Request) bool { reqFile := r.URL.Path[1:] cachedFile := p.cacheDir + reqFile remoteFile := p.url + reqFile resp, err := http.Get(remoteFile) defer func() { if resp.Body != nil { if err := resp.Body.Close(); err != nil { common.UsageAndExit("Failed to close URL %q with error: %s", remoteFile, err) } } }() if err != nil { common.InfoErr("Failed to download %q with error: %s\n", remoteFile, err) return false } if resp.StatusCode != http.StatusOK { common.InfoErr("Failed to download %q with Code: %q\n", remoteFile, http.StatusText(resp.StatusCode)) return false } if dcf := filepath.Dir(cachedFile); false == common.IsDir(dcf) { if err := os.MkdirAll(dcf, 0755); err != nil { common.InfoErr("Failed to create cache folder %q with Code: %s\n", dcf, err) return false } } fw, err := os.OpenFile(cachedFile, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0644) if err != nil { common.InfoErr("Failed to open write file %q for URL %q with Error: %s\n", cachedFile, remoteFile, err) return false } defer func() { if err := fw.Close(); err != nil { common.InfoErr("Failed to close write file %q from URL %q with Error %s\n", cachedFile, remoteFile, err) } }() addHeaders(filepath.Ext(reqFile), cacheUntil, w) mw := io.MultiWriter(w, fw) if _, err := io.Copy(mw, io.LimitReader(resp.Body, maxHttpDownloadSize)); err != nil { common.InfoErr("Failed to write to http response and/or file to disk: %q with error: %s. Max Size: %d KBytes\n", remoteFile, err, maxHttpDownloadSize/1024) return false } return true }
func (h *handle) rootHTML(w http.ResponseWriter, r *http.Request) { h.RLock() defer h.RUnlock() w.Header().Set(ContentType, TextHTMLCharsetUTF8) fmt.Fprint(w, `<html> <head><title>Mediamock Content Table</title></head> <body><table>`) fmt.Fprint(w, `<thead><tr> <th>ModTime</th> <th nowrap>Width px</th> <th nowrap>Height px</th> <th>Link</th> </tr></thead><tbody>`) for path, vis := range h.virtualImages { for _, vi := range vis { _, err := fmt.Fprintf(w, `<tr> <td>n/a</td> <td>%d</td> <td>%d</td> <td><a href="%s" target="_blank">%s</a> Regex: %s</td> </tr>`, vi.Width, vi.Height, path, path, vi.regex, ) if err != nil { common.InfoErr("Failed to write HTML table with error: %s\n", err) } if _, err := w.Write(brByte); err != nil { common.InfoErr("Failed to write brByte with error: %s\n", err) } } } var pathSlice = make(sort.StringSlice, len(h.fileMap)) var i int for key, _ := range h.fileMap { pathSlice[i] = key i++ } pathSlice.Sort() for _, key := range pathSlice { rec := h.fileMap[key] _, err := fmt.Fprintf(w, `<tr> <td>%s</td> <td>%d</td> <td>%d</td> <td><a href="%s" target="_blank">%s</a></td> </tr>`, rec.ModTime, rec.Width, rec.Height, rec.Path, rec.Path, ) if err != nil { common.InfoErr("Failed to write HTML table with error: %s\n", err) } if _, err := w.Write(brByte); err != nil { common.InfoErr("Failed to write brByte with error: %s\n", err) } } fmt.Fprint(w, `</tbody></table></body> </html>`) }