├── .github
└── workflows
│ └── deploy.yml
├── .gitignore
├── Dockerfile
├── LICENSE
├── README.md
├── docker-compose.example.yml
├── etc
└── pepic
│ └── config.yml
├── go.mod
├── go.sum
├── html
├── base.html
├── error.html
├── index.html
└── meta.html
├── main.go
├── pepic
├── cmd
│ ├── root.go
│ └── serve.go
├── config
│ └── app.go
├── entity
│ └── file.go
├── handler
│ ├── errors.go
│ ├── handler.go
│ ├── index.go
│ ├── meta.go
│ ├── proxy.go
│ └── upload.go
├── processing
│ ├── image.go
│ ├── processing.go
│ └── video.go
├── storage
│ ├── fs.go
│ └── storage.go
├── template
│ └── renderer.go
└── utils
│ ├── file.go
│ └── media.go
└── static
├── css
└── style.css
├── favicon
├── android-chrome-192x192.png
├── android-chrome-512x512.png
├── apple-touch-icon.png
├── favicon-16x16.png
├── favicon-32x32.png
└── favicon.ico
└── images
├── logo.png
├── screenshot1.png
└── screenshot2.png
/.github/workflows/deploy.yml:
--------------------------------------------------------------------------------
1 | name: Docker image
2 |
3 | on:
4 | push:
5 | branches:
6 | - master
7 |
8 | jobs:
9 | build:
10 | name: Build image
11 | runs-on: ubuntu-latest
12 | steps:
13 | - uses: actions/checkout@v2
14 | with:
15 | ref: 'master'
16 | - run: docker login ghcr.io -u $GITHUB_ACTOR -p ${{ secrets.TOKEN }}
17 | - run: docker build -t ghcr.io/$GITHUB_ACTOR/pepic:latest .
18 | - run: docker image push ghcr.io/$GITHUB_ACTOR/pepic:latest
19 |
--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | # Edit at https://www.toptal.com/developers/gitignore?templates=go,macos,intellij+all
2 |
3 | ### Go ###
4 | # Binaries for programs and plugins
5 | *.exe
6 | *.exe~
7 | *.dll
8 | *.so
9 | *.dylib
10 |
11 | # Test binary, built with `go test -c`
12 | *.test
13 |
14 | # Output of the go coverage tool, specifically when used with LiteIDE
15 | *.out
16 |
17 | # Dependency directories (remove the comment below to include it)
18 | # vendor/
19 |
20 | ### Go Patch ###
21 | /vendor/
22 | /Godeps/
23 |
24 | ### Intellij+all ###
25 | # Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio, WebStorm and Rider
26 | # Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839
27 |
28 | # User-specific stuff
29 | .idea/**/workspace.xml
30 | .idea/**/tasks.xml
31 | .idea/**/usage.statistics.xml
32 | .idea/**/dictionaries
33 | .idea/**/shelf
34 |
35 | # Generated files
36 | .idea/**/contentModel.xml
37 |
38 | # Sensitive or high-churn files
39 | .idea/**/dataSources/
40 | .idea/**/dataSources.ids
41 | .idea/**/dataSources.local.xml
42 | .idea/**/sqlDataSources.xml
43 | .idea/**/dynamic.xml
44 | .idea/**/uiDesigner.xml
45 | .idea/**/dbnavigator.xml
46 |
47 | # Gradle
48 | .idea/**/gradle.xml
49 | .idea/**/libraries
50 |
51 | # Gradle and Maven with auto-import
52 | # When using Gradle or Maven with auto-import, you should exclude module files,
53 | # since they will be recreated, and may cause churn. Uncomment if using
54 | # auto-import.
55 | # .idea/artifacts
56 | # .idea/compiler.xml
57 | # .idea/jarRepositories.xml
58 | # .idea/modules.xml
59 | # .idea/*.iml
60 | # .idea/modules
61 | # *.iml
62 | # *.ipr
63 |
64 | # CMake
65 | cmake-build-*/
66 |
67 | # Mongo Explorer plugin
68 | .idea/**/mongoSettings.xml
69 |
70 | # File-based project format
71 | *.iws
72 |
73 | # IntelliJ
74 | out/
75 |
76 | # mpeltonen/sbt-idea plugin
77 | .idea_modules/
78 |
79 | # JIRA plugin
80 | atlassian-ide-plugin.xml
81 |
82 | # Cursive Clojure plugin
83 | .idea/replstate.xml
84 |
85 | # Crashlytics plugin (for Android Studio and IntelliJ)
86 | com_crashlytics_export_strings.xml
87 | crashlytics.properties
88 | crashlytics-build.properties
89 | fabric.properties
90 |
91 | # Editor-based Rest Client
92 | .idea/httpRequests
93 |
94 | # Android studio 3.1+ serialized cache file
95 | .idea/caches/build_file_checksums.ser
96 |
97 | ### Intellij+all Patch ###
98 | # Ignores the whole .idea folder and all .iml files
99 | # See https://github.com/joeblau/gitignore.io/issues/186 and https://github.com/joeblau/gitignore.io/issues/360
100 |
101 | .idea/
102 |
103 | # Reason: https://github.com/joeblau/gitignore.io/issues/186#issuecomment-249601023
104 |
105 | *.iml
106 | modules.xml
107 | .idea/misc.xml
108 | *.ipr
109 |
110 | # Sonarlint plugin
111 | .idea/sonarlint
112 |
113 | ### macOS ###
114 | # General
115 | .DS_Store
116 | .AppleDouble
117 | .LSOverride
118 |
119 | # Icon must end with two \r
120 | Icon
121 |
122 | # Thumbnails
123 | ._*
124 |
125 | # Files that might appear in the root of a volume
126 | .DocumentRevisions-V100
127 | .fseventsd
128 | .Spotlight-V100
129 | .TemporaryItems
130 | .Trashes
131 | .VolumeIcon.icns
132 | .com.apple.timemachine.donotpresent
133 |
134 | # Directories potentially created on remote AFP share
135 | .AppleDB
136 | .AppleDesktop
137 | Network Trash Folder
138 | Temporary Items
139 | .apdisk
140 |
141 | # Exclude upload folders
142 | uploads/*
143 |
--------------------------------------------------------------------------------
/Dockerfile:
--------------------------------------------------------------------------------
1 | FROM alpine:edge AS builder
2 |
3 | ENV GOOS=linux
4 | ENV CGO_CFLAGS_ALLOW="-Xpreprocessor"
5 |
6 | RUN apk add --no-cache go gcc g++ vips-dev git
7 | COPY . /build
8 | WORKDIR /build
9 | RUN go get
10 | RUN go build -a -o /build/app -ldflags="-s -w -h" .
11 |
12 | FROM alpine:latest
13 |
14 | RUN apk --no-cache add ca-certificates mailcap ffmpeg vips
15 | COPY --from=builder /build/app /app/pepic
16 | COPY html /app/html
17 | COPY static /app/static
18 | COPY etc/pepic /etc/pepic
19 | WORKDIR /app
20 |
21 | EXPOSE 8118
22 |
23 | ENTRYPOINT ["/app/pepic", "serve", "--config", "/etc/pepic/config.yml"]
24 |
--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
1 | MIT License
2 |
3 | Copyright (c) 2020 Vasily Zubarev, me@vas3k.ru
4 |
5 | Permission is hereby granted, free of charge, to any person obtaining a copy
6 | of this software and associated documentation files (the "Software"), to deal
7 | in the Software without restriction, including without limitation the rights
8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 |
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 |
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
PEPIC
5 |
11 |
12 |
{{ Code }}
13 |
{{ Message }}
14 |
15 |
12 |
13 |
🎥 🗃 🖼
Drag files or click here...
14 |
15 |
21 |
24 |
31 |
32 | {% endif %}
33 | {% endblock %}
34 |
--------------------------------------------------------------------------------
/html/meta.html:
--------------------------------------------------------------------------------
1 | {% extends "base.html" %}
2 |
3 | {% block title %}Meta{% endblock %}
4 |
5 | {% block main %}
6 | {% for file in files %}
7 |
45 | {% endfor %}
46 |
47 | {% if files|length > 1 %}
48 |
60 | {% endif %}
61 |
62 |
65 | {% endblock %}
66 |
--------------------------------------------------------------------------------
/main.go:
--------------------------------------------------------------------------------
1 | package main
2 |
3 | import (
4 | "log"
5 |
6 | "github.com/vas3k/pepic/pepic/cmd"
7 | )
8 |
9 | func main() {
10 | err := cmd.Execute()
11 | if err != nil {
12 | log.Fatal(err)
13 | }
14 | }
15 |
--------------------------------------------------------------------------------
/pepic/cmd/root.go:
--------------------------------------------------------------------------------
1 | package cmd
2 |
3 | import (
4 | "log"
5 |
6 | "github.com/ilyakaznacheev/cleanenv"
7 | "github.com/spf13/cobra"
8 | "github.com/vas3k/pepic/pepic/config"
9 | )
10 |
11 | var (
12 | configFile string
13 | rootCmd = &cobra.Command{
14 | Use: "pepic",
15 | RunE: func(cmd *cobra.Command, args []string) error {
16 | return cmd.Usage()
17 | },
18 | }
19 | )
20 |
21 | func Execute() error {
22 | return rootCmd.Execute()
23 | }
24 |
25 | func init() {
26 | cobra.OnInitialize(initConfig)
27 | rootCmd.PersistentFlags().StringVar(&configFile, "config", "", "config file")
28 |
29 | rootCmd.AddCommand(serveCmd)
30 | // Add more commands here
31 | }
32 |
33 | func initConfig() {
34 | var err error
35 |
36 | if configFile != "" {
37 | err = cleanenv.ReadConfig(configFile, &config.App)
38 | } else {
39 | err = cleanenv.ReadConfig("/etc/pepic/config.yml", &config.App)
40 | }
41 |
42 | if err != nil {
43 | log.Fatalf("config error: %s", err)
44 | }
45 | }
46 |
--------------------------------------------------------------------------------
/pepic/cmd/serve.go:
--------------------------------------------------------------------------------
1 | package cmd
2 |
3 | import (
4 | "fmt"
5 |
6 | "github.com/labstack/echo/v4"
7 | "github.com/vas3k/pepic/pepic/config"
8 | "github.com/vas3k/pepic/pepic/handler"
9 | "github.com/vas3k/pepic/pepic/processing"
10 | "github.com/vas3k/pepic/pepic/storage"
11 | "github.com/vas3k/pepic/pepic/template"
12 |
13 | "github.com/labstack/echo/v4/middleware"
14 | "github.com/spf13/cobra"
15 | )
16 |
17 | var serveCmd = &cobra.Command{
18 | Use: "serve",
19 | Short: "`serve` starts server on configured port",
20 | RunE: func(cmd *cobra.Command, args []string) error {
21 | e := echo.New()
22 |
23 | // main app handler
24 | h := &handler.PepicHandler{
25 | Processing: processing.Processing{
26 | Image: processing.NewImageBackend(),
27 | Video: processing.NewVideoBackend(),
28 | },
29 | Storage: storage.NewStorage(
30 | storage.NewFileSystemBackend(config.App.Storage.Dir),
31 | ),
32 | }
33 |
34 | // logging, limiting, panic recovery and other useful middlewares
35 | e.Use(middleware.Recover())
36 | e.Use(middleware.LoggerWithConfig(middleware.LoggerConfig{
37 | Format: "${remote_ip} - [${time_rfc3339}] \"${method} ${uri}\" ${status} ${bytes_out} \"-\" \"${user_agent}\" \n",
38 | }))
39 |
40 | if config.App.Global.MaxUploadSize != "" {
41 | // limit uploads size if needed
42 | e.Use(middleware.BodyLimit(config.App.Global.MaxUploadSize))
43 | }
44 |
45 | // json/html error handler
46 | e.HTTPErrorHandler = h.ErrorHandler
47 |
48 | // template
49 | e.Renderer = template.NewTemplateRenderer("html")
50 |
51 | // serve static files
52 | e.Static("/static", "static/")
53 | e.Static("/favicon", "static/favicon")
54 | e.File("/favicon.ico", "static/favicon/favicon.ico")
55 |
56 | // register routes
57 | e.GET("/", h.Index)
58 | e.POST("/upload/multipart/", h.UploadMultipart)
59 | e.POST("/upload/bytes/", h.UploadBodyBytes)
60 | e.GET("/meta/:name", h.GetMeta)
61 | e.GET("/:length/:name", h.GetResizedFile)
62 | e.GET("/:name", h.GetOriginalFile)
63 |
64 | // start server
65 | address := fmt.Sprintf("%s:%d", config.App.Global.Host, config.App.Global.Port)
66 | return e.Start(address)
67 | },
68 | }
69 |
--------------------------------------------------------------------------------
/pepic/config/app.go:
--------------------------------------------------------------------------------
1 | package config
2 |
3 | type Config struct {
4 | Global struct {
5 | Host string `yaml:"host" env:"HOST" env-default:"0.0.0.0"`
6 | Port int `yaml:"port" env:"PORT" env-default:"8118"`
7 | BaseUrl string `yaml:"base_url" env:"BASE_URL" env-default:"http://0.0.0.0:8118/"`
8 | SecretCode string `yaml:"secret_code" env:"SECRET_CODE" env-default:""`
9 | MaxUploadSize string `yaml:"max_upload_size" env:"MAX_UPLOAD_SIZE" env-default:""`
10 | FileTreeSplitChars int `yaml:"file_tree_split_chars" env:"FILE_TREE_SPLIT_CHARS" env-default:"3"`
11 | } `yaml:"global"`
12 |
13 | Storage struct {
14 | Type string `yaml:"type" env:"STORAGE_TYPE" env-default:"provider"`
15 | Dir string `yaml:"dir" env:"STORAGE_DIR" env-default:"uploads/"`
16 | } `yaml:"storage"`
17 |
18 | Images struct {
19 | StoreOriginals bool `yaml:"store_originals" env:"IMAGE_STORE_ORIGINALS" env-default:"false"`
20 | OriginalLength int `yaml:"original_length" env:"IMAGE_ORIGINAL_LENGTH" env-default:"1800"`
21 | LiveResize bool `yaml:"live_resize" env:"IMAGE_LIVE_RESIZE" env-default:"true"`
22 | AutoConvert string `yaml:"auto_convert" env:"IMAGE_AUTO_CONVERT" env-default:"false"`
23 | JPEGQuality int `yaml:"jpeg_quality" env:"IMAGE_JPEG_QUALITY" env-default:"95"`
24 | PNGCompression int `yaml:"png_compression" env:"IMAGE_PNG_COMPRESSION" env-default:"0"`
25 | GIFConvert string `yaml:"gif_convert" env:"IMAGE_GIF_CONVERT" env-default:"video/mp4"`
26 | } `yaml:"images"`
27 |
28 | Videos struct {
29 | StoreOriginals bool `yaml:"store_originals" env:"VIDEO_STORE_ORIGINALS" env-default:"false"`
30 | OriginalLength int `yaml:"original_length" env:"VIDEO_ORIGINAL_LENGTH" env-default:"480"`
31 | LiveResize bool `yaml:"live_resize" env:"VIDEO_LIVE_RESIZE" env-default:"false"`
32 | AutoConvert string `yaml:"auto_convert" env:"VIDEO_AUTO_CONVERT" env-default:"video/mp4"`
33 | FFmpeg struct {
34 | TempDir string `yaml:"temp_dir" env:"VIDEO_FFMPEG_TEMP_DIR" env-default:"/tmp"`
35 | Preset string `yaml:"preset" env:"VIDEO_FFMPEG_PRESET" env-default:"slow"`
36 | CRF int `yaml:"crf" env:"VIDEO_FFMPEG_CRF" env-default:"24"`
37 | BufferSize int `yaml:"buffer_size" env:"VIDEO_FFMPEG_BUFFER_SIZE" env-default:"1024000"`
38 | VideoCodec string `yaml:"video_codec" env:"VIDEO_FFMPEG_VIDEO_CODEC" env-default:"libx264"`
39 | VideoBitrate string `yaml:"video_bitrate" env:"VIDEO_FFMPEG_VIDEO_BITRATE" env-default:"1024k"`
40 | VideoProfile string `yaml:"video_profile" env:"VIDEO_FFMPEG_VIDEO_PROFILE" env-default:"main"`
41 | AudioCodec string `yaml:"audio_codec" env:"VIDEO_FFMPEG_AUDIO_CODEC" env-default:"aac"`
42 | AudioBitrate string `yaml:"audio_bitrate" env:"VIDEO_FFMPEG_AUDIO_BITRATE" env-default:"128k"`
43 | MovFlags string `yaml:"mov_flags" env:"VIDEO_FFMPEG_MOV_FLAGS" env-default:"+faststart"`
44 | PixFmt string `yaml:"pix_fmt" env:"VIDEO_FFMPEG_PIX_FMT" env-default:"yuv420p"`
45 | } `yaml:"ffmpeg"`
46 | } `yaml:"videos"`
47 |
48 | Meta struct {
49 | ImageTemplates []struct {
50 | Title string `yaml:"title"`
51 | Template string `yaml:"template"`
52 | } `yaml:"image_templates" env:"META_IMAGE_TEMPLATES"`
53 |
54 | VideoTemplates []struct {
55 | Title string `yaml:"title"`
56 | Template string `yaml:"template"`
57 | } `yaml:"video_templates" env:"META_VIDEO_TEMPLATES"`
58 |
59 | MultiTemplates []struct {
60 | Title string `yaml:"title"`
61 | Template string `yaml:"template"`
62 | } `yaml:"multi_templates" env:"META_MULTI_TEMPLATES"`
63 | } `yaml:"meta"`
64 | }
65 |
66 | var App Config
67 |
--------------------------------------------------------------------------------
/pepic/entity/file.go:
--------------------------------------------------------------------------------
1 | package entity
2 |
3 | import (
4 | "strings"
5 |
6 | "github.com/vas3k/pepic/pepic/config"
7 | )
8 |
9 | type ProcessingFile struct {
10 | Filename string
11 | Mime string
12 | Path string
13 | Bytes []byte
14 | Size int64
15 | }
16 |
17 | func (p *ProcessingFile) Url() string {
18 | return config.App.Global.BaseUrl + p.Filename
19 | }
20 |
21 | func (p *ProcessingFile) IsGIF() bool {
22 | return p.Mime == "image/gif"
23 | }
24 |
25 | func (p *ProcessingFile) IsImage() bool {
26 | return strings.HasPrefix(p.Mime, "image/")
27 | }
28 |
29 | func (p *ProcessingFile) IsVideo() bool {
30 | return strings.HasPrefix(p.Mime, "video/")
31 | }
32 |
--------------------------------------------------------------------------------
/pepic/handler/errors.go:
--------------------------------------------------------------------------------
1 | package handler
2 |
3 | import (
4 | "fmt"
5 | "log"
6 | "net/http"
7 |
8 | "github.com/labstack/echo/v4"
9 | )
10 |
11 | type JSONError struct {
12 | Code int `json:"code"`
13 | Message string `json:"message"`
14 | }
15 |
16 | func (h *PepicHandler) ErrorHandler(err error, c echo.Context) {
17 | code := http.StatusInternalServerError
18 | message := err.Error()
19 | if httpError, ok := err.(*echo.HTTPError); ok {
20 | code = httpError.Code
21 | message = fmt.Sprintf("%v", httpError.Message)
22 | }
23 |
24 | log.Printf("Error %d: %s", code, message)
25 |
26 | acceptContent := c.Request().Header.Get("Accept")
27 | if acceptContent == "application/json" {
28 | c.JSON(code, struct {
29 | error JSONError
30 | }{
31 | error: JSONError{
32 | Code: code,
33 | Message: message,
34 | },
35 | })
36 | } else {
37 | c.Render(code, "error.html", map[string]interface{}{
38 | "Code": code,
39 | "Message": message,
40 | })
41 | }
42 | }
43 |
--------------------------------------------------------------------------------
/pepic/handler/handler.go:
--------------------------------------------------------------------------------
1 | package handler
2 |
3 | import (
4 | "errors"
5 | "net/http"
6 | "time"
7 |
8 | "github.com/labstack/echo/v4"
9 | "github.com/vas3k/pepic/pepic/config"
10 | "github.com/vas3k/pepic/pepic/processing"
11 | "github.com/vas3k/pepic/pepic/storage"
12 | )
13 |
14 | type PepicHandler struct {
15 | Processing processing.Processing
16 | Storage storage.Storage
17 | }
18 |
19 | const SecretCodeKey = "code"
20 | const SecretCodeCookieTTL = 30 * 24 * time.Hour
21 |
22 | // Auth for poor people
23 | // We simply store secret code in http-only cookies. Works for us.
24 | // You'd better think about extra protection layer on top.
25 | // API gateway or nginx + basic auth will suffice.
26 | func (h *PepicHandler) checkSecretCode(c echo.Context) (string, error) {
27 | var code string
28 |
29 | // ignore code check if it's not configured
30 | if config.App.Global.SecretCode != "" {
31 | cookie, err := c.Cookie(SecretCodeKey)
32 | if err != nil || cookie.Value == "" {
33 | code = c.QueryParam(SecretCodeKey)
34 | if code == "" {
35 | code = c.FormValue(SecretCodeKey)
36 | }
37 | } else {
38 | code = cookie.Value
39 | }
40 |
41 | if code != config.App.Global.SecretCode {
42 | return code, errors.New("secret code is invalid")
43 | }
44 |
45 | newCookie := new(http.Cookie)
46 | newCookie.Name = SecretCodeKey
47 | newCookie.Value = code
48 | newCookie.Expires = time.Now().Add(SecretCodeCookieTTL)
49 | newCookie.HttpOnly = true
50 | c.SetCookie(newCookie)
51 | }
52 |
53 | return code, nil
54 | }
55 |
--------------------------------------------------------------------------------
/pepic/handler/index.go:
--------------------------------------------------------------------------------
1 | package handler
2 |
3 | import (
4 | "net/http"
5 |
6 | "github.com/labstack/echo/v4"
7 | )
8 |
9 | // GET /
10 | // Index page
11 | // Shows a form for uploading a file or entering a secret code (if configured)
12 | func (h *PepicHandler) Index(c echo.Context) error {
13 | code, codeErr := h.checkSecretCode(c)
14 | return c.Render(http.StatusOK, "index.html", map[string]interface{}{
15 | "isAuthorized": codeErr == nil,
16 | "secretCode": code,
17 | })
18 | }
19 |
--------------------------------------------------------------------------------
/pepic/handler/meta.go:
--------------------------------------------------------------------------------
1 | package handler
2 |
3 | import (
4 | "net/http"
5 | "strings"
6 |
7 | "github.com/labstack/echo/v4"
8 | "github.com/vas3k/pepic/pepic/config"
9 | "github.com/vas3k/pepic/pepic/entity"
10 | )
11 |
12 | // GET /meta/:name
13 | // Render HTML page with uploaded images/videos and pre-defined templates for them
14 | func (h *PepicHandler) GetMeta(c echo.Context) error {
15 | names := strings.Split(c.Param("name"), ",")
16 | var files []*entity.ProcessingFile
17 |
18 | for _, name := range names {
19 | file, err := h.Storage.GetFile("orig", name)
20 | if err != nil {
21 | return echo.NewHTTPError(http.StatusNotFound, "File not found")
22 | }
23 | files = append(files, file)
24 | }
25 |
26 | return c.Render(http.StatusOK, "meta.html", map[string]interface{}{
27 | "files": files,
28 | "host": c.Request().URL,
29 | "meta": config.App.Meta,
30 | })
31 | }
32 |
--------------------------------------------------------------------------------
/pepic/handler/proxy.go:
--------------------------------------------------------------------------------
1 | package handler
2 |
3 | import (
4 | "errors"
5 | "net/http"
6 | "path"
7 | "strconv"
8 |
9 | "github.com/labstack/echo/v4"
10 | "github.com/vas3k/pepic/pepic/config"
11 | "github.com/vas3k/pepic/pepic/entity"
12 | )
13 |
14 | const MinLength = 200
15 |
16 | // GET /:name
17 | // Returns originally stored file
18 | func (h *PepicHandler) GetOriginalFile(c echo.Context) error {
19 | file, err := h.Storage.GetFile("orig", c.Param("name"))
20 | if err != nil {
21 | return echo.NewHTTPError(http.StatusNotFound, "File not found")
22 | }
23 |
24 | return h.Storage.Proxy(c, file.Path)
25 | }
26 |
27 | // GET /:length/:name
28 | // Resizes the file, stores and returns it
29 | func (h *PepicHandler) GetResizedFile(c echo.Context) error {
30 | lengthString := c.Param("length")
31 | if lengthString == "full" {
32 | return h.GetOriginalFile(c)
33 | }
34 |
35 | length, err := strconv.Atoi(lengthString)
36 | if err != nil {
37 | return echo.NewHTTPError(http.StatusBadRequest, "Bad 'length' parameter. Need an integer!")
38 | }
39 |
40 | // return original image if requested size is bigger
41 | if length >= config.App.Images.OriginalLength {
42 | return h.GetOriginalFile(c)
43 | }
44 |
45 | // do not return too small images
46 | if length < MinLength {
47 | length = MinLength
48 | }
49 |
50 | // resize and store the resized one
51 | filename := c.Param("name")
52 | file, err := h.resizeFile(filename, length)
53 | if err != nil {
54 | return echo.NewHTTPError(http.StatusInternalServerError, err)
55 | }
56 |
57 | return h.Storage.Proxy(c, file.Path)
58 | }
59 |
60 | func (h *PepicHandler) resizeFile(filename string, length int) (*entity.ProcessingFile, error) {
61 | resizePath := path.Join("resize", strconv.Itoa(length))
62 | file, err := h.Storage.GetFile(resizePath, filename)
63 | if err == nil {
64 | // resized file already exists, just return it
65 | return file, nil
66 | }
67 | if file == nil {
68 | return nil, errors.New("file is empty or corrupted")
69 | }
70 |
71 | if file.IsImage() {
72 | if config.App.Images.LiveResize {
73 | err := h.Storage.ReadFileBytes(file, "orig")
74 | if err != nil {
75 | return file, err
76 | }
77 |
78 | err = h.Processing.Image.Resize(file, length)
79 | if err != nil {
80 | return file, err
81 | }
82 |
83 | err = h.Storage.StoreFile(file, resizePath)
84 | if err != nil {
85 | return file, err
86 | }
87 | }
88 | return file, nil
89 | }
90 |
91 | if file.IsVideo() {
92 | if config.App.Videos.LiveResize {
93 | err := h.Storage.ReadFileBytes(file, "orig")
94 | if err != nil {
95 | return file, err
96 | }
97 |
98 | err = h.Processing.Video.Transcode(file, length)
99 | if err != nil {
100 | return file, err
101 | }
102 |
103 | err = h.Storage.StoreFile(file, resizePath)
104 | if err != nil {
105 | return file, err
106 | }
107 | }
108 | return file, nil
109 | }
110 |
111 | return nil, errors.New("file does not exist")
112 | }
113 |
--------------------------------------------------------------------------------
/pepic/handler/upload.go:
--------------------------------------------------------------------------------
1 | package handler
2 |
3 | import (
4 | "io"
5 | "log"
6 | "mime/multipart"
7 | "net/http"
8 | "strings"
9 |
10 | "github.com/labstack/echo/v4"
11 | "github.com/vas3k/pepic/pepic/config"
12 | "github.com/vas3k/pepic/pepic/entity"
13 | "github.com/vas3k/pepic/pepic/utils"
14 | )
15 |
16 | type UploadResult struct {
17 | Filename string `json:"filename"`
18 | Url string `json:"url"`
19 | }
20 |
21 | // POST /upload/multipart/
22 | // Handles multipart upload
23 | func (h *PepicHandler) UploadMultipart(c echo.Context) error {
24 | if _, err := h.checkSecretCode(c); err != nil {
25 | return echo.NewHTTPError(http.StatusUnauthorized, "Secret code required")
26 | }
27 |
28 | form, err := c.MultipartForm()
29 | if err != nil {
30 | return echo.NewHTTPError(http.StatusBadRequest, err)
31 | }
32 |
33 | var uploaded []UploadResult
34 |
35 | for _, multipartHeader := range form.File["media"] {
36 | log.Printf("Processing file: %s", multipartHeader.Filename)
37 |
38 | bytes, err := multipartToBytes(multipartHeader)
39 | if err != nil {
40 | return echo.NewHTTPError(http.StatusBadRequest, err)
41 | }
42 |
43 | result, err := h.uploadBytes(multipartHeader.Filename, bytes)
44 | if err != nil {
45 | return echo.NewHTTPError(http.StatusInternalServerError, err)
46 | }
47 |
48 | uploaded = append(uploaded, UploadResult{
49 | Filename: result.Filename,
50 | Url: result.Url(),
51 | })
52 | }
53 |
54 | if len(uploaded) == 0 {
55 | return echo.NewHTTPError(http.StatusBadRequest, "No files to upload")
56 | }
57 |
58 | return renderUploadResults(uploaded, c)
59 | }
60 |
61 | // POST /upload/bytes/
62 | // Handles raw bytes upload from body
63 | func (h *PepicHandler) UploadBodyBytes(c echo.Context) error {
64 | if _, err := h.checkSecretCode(c); err != nil {
65 | return echo.NewHTTPError(http.StatusUnauthorized, "Secret code required")
66 | }
67 |
68 | var bytes []byte
69 | if c.Request().Body != nil {
70 | bytes, _ = io.ReadAll(c.Request().Body)
71 | }
72 |
73 | result, err := h.uploadBytes("", bytes)
74 | if err != nil {
75 | return echo.NewHTTPError(http.StatusInternalServerError, err)
76 | }
77 |
78 | return renderUploadResults([]UploadResult{
79 | {Url: "/" + result.Filename},
80 | }, c)
81 | }
82 |
83 | func (h *PepicHandler) uploadBytes(filename string, bytes []byte) (*entity.ProcessingFile, error) {
84 | var err error
85 |
86 | file := &entity.ProcessingFile{
87 | Filename: filename,
88 | Mime: utils.DetectMimeType(filename, bytes),
89 | Bytes: bytes,
90 | }
91 |
92 | log.Printf("Processing %s file", file.Mime)
93 |
94 | hashedFilename, err := utils.CalculateHashName(file)
95 | if err != nil {
96 | return file, err
97 | }
98 |
99 | file.Filename = hashedFilename
100 |
101 | if !config.App.Images.StoreOriginals {
102 | if file.IsGIF() {
103 | log.Printf("Converting GIF to video...")
104 | err = h.Processing.Video.Convert(file, config.App.Images.GIFConvert)
105 | if err != nil {
106 | return file, err
107 | }
108 | }
109 |
110 | if file.IsVideo() || file.IsGIF() {
111 | log.Printf("Processing video...")
112 |
113 | err = h.Processing.Video.Transcode(file, config.App.Videos.OriginalLength)
114 | if err != nil {
115 | return file, err
116 | }
117 |
118 | if config.App.Videos.AutoConvert != "false" {
119 | err = h.Processing.Video.Convert(file, config.App.Videos.AutoConvert)
120 | if err != nil {
121 | return file, err
122 | }
123 | }
124 | }
125 |
126 | if file.IsImage() {
127 | log.Printf("Processing image...")
128 |
129 | err = h.Processing.Image.AutoRotate(file)
130 | if err != nil {
131 | return file, err
132 | }
133 |
134 | err = h.Processing.Image.Resize(file, config.App.Images.OriginalLength)
135 | if err != nil {
136 | return file, err
137 | }
138 |
139 | if config.App.Images.AutoConvert != "false" {
140 | err := h.Processing.Image.Convert(file, config.App.Images.AutoConvert)
141 | if err != nil {
142 | return file, err
143 | }
144 | }
145 | }
146 | }
147 |
148 | err = h.Storage.StoreFile(file, "orig")
149 | if err != nil {
150 | return file, err
151 | }
152 |
153 | return file, nil
154 | }
155 |
156 | func multipartToBytes(multipartFile *multipart.FileHeader) ([]byte, error) {
157 | src, err := multipartFile.Open()
158 | if err != nil {
159 | return nil, err
160 | }
161 | defer src.Close()
162 | return io.ReadAll(src)
163 | }
164 |
165 | func renderUploadResults(results []UploadResult, c echo.Context) error {
166 | accept := c.Request().Header.Get("Accept")
167 |
168 | // on json upload - return structured results
169 | if strings.HasPrefix(accept, "application/json") {
170 | var urls []string
171 | for _, result := range results {
172 | urls = append(urls, result.Url)
173 | }
174 | return c.JSON(http.StatusCreated, map[string]interface{}{
175 | "uploaded": urls,
176 | })
177 | }
178 |
179 | // on simple html upload - redirect to meta page
180 | var filenames []string
181 | for _, result := range results {
182 | filenames = append(filenames, result.Filename)
183 | }
184 | return c.Redirect(http.StatusFound, "/meta/"+strings.Join(filenames, ","))
185 | }
186 |
--------------------------------------------------------------------------------
/pepic/processing/image.go:
--------------------------------------------------------------------------------
1 | package processing
2 |
3 | import (
4 | "bytes"
5 | "errors"
6 | "fmt"
7 | "image"
8 | "image/color"
9 | "image/draw"
10 | "image/jpeg"
11 | _ "image/png"
12 | "log"
13 |
14 | "github.com/h2non/bimg"
15 | "github.com/vas3k/pepic/pepic/config"
16 | "github.com/vas3k/pepic/pepic/entity"
17 | "github.com/vas3k/pepic/pepic/utils"
18 | )
19 |
20 | type ImageBackend interface {
21 | AutoRotate(file *entity.ProcessingFile) error
22 | Resize(file *entity.ProcessingFile, maxLength int) error
23 | Convert(file *entity.ProcessingFile, newMimeType string) error
24 | }
25 |
26 | type imageBackend struct {
27 | }
28 |
29 | func NewImageBackend() ImageBackend {
30 | return &imageBackend{}
31 | }
32 |
33 | func (i *imageBackend) AutoRotate(file *entity.ProcessingFile) error {
34 | log.Printf("Auto-rotate image '%s'", file.Filename)
35 | if file.Bytes == nil {
36 | return errors.New("file data is empty, try reading it first")
37 | }
38 |
39 | img := bimg.NewImage(file.Bytes)
40 | rotatedImg, err := img.AutoRotate()
41 | if err != nil {
42 | return err
43 | }
44 |
45 | file.Bytes = rotatedImg
46 |
47 | return nil
48 | }
49 |
50 | func (i *imageBackend) Resize(file *entity.ProcessingFile, maxLength int) error {
51 | log.Printf("Resizing image '%s' to %d px", file.Filename, maxLength)
52 | if file.Bytes == nil {
53 | return errors.New("file data is empty, try reading it first")
54 | }
55 |
56 | img := bimg.NewImage(file.Bytes)
57 | origSize, err := img.Size()
58 | if err != nil {
59 | return err
60 | }
61 |
62 | width, height := utils.FitSize(origSize.Width, origSize.Height, maxLength)
63 | log.Printf("Orig width '%d' height %d px", origSize.Width, origSize.Height)
64 | resizedImg, err := img.Process(bimg.Options{
65 | Width: width,
66 | Height: height,
67 | Embed: true,
68 | StripMetadata: true,
69 | Quality: config.App.Images.JPEGQuality,
70 | Compression: config.App.Images.PNGCompression,
71 | })
72 | if err != nil {
73 | return err
74 | }
75 |
76 | file.Bytes = resizedImg
77 |
78 | return nil
79 | }
80 |
81 | func (i *imageBackend) Convert(file *entity.ProcessingFile, newMimeType string) error {
82 | log.Printf("Converting image '%s' to %s", file.Filename, newMimeType)
83 | if file.Bytes == nil {
84 | return errors.New("file data is empty, try reading it first")
85 | }
86 |
87 | newImgType, err := i.mimeTypeToImageType(newMimeType)
88 | if err != nil {
89 | return err
90 | }
91 |
92 | img := bimg.NewImage(file.Bytes)
93 |
94 | // fix PNG -> JPG transparency if needed
95 | if bimg.DetermineImageType(file.Bytes) == bimg.PNG && newImgType == bimg.JPEG {
96 | img = i.fixPNGTransparency(img)
97 | }
98 |
99 | convertedImg, err := img.Process(bimg.Options{
100 | Type: newImgType,
101 | StripMetadata: true,
102 | Quality: config.App.Images.JPEGQuality,
103 | Compression: config.App.Images.PNGCompression,
104 | })
105 | if err != nil {
106 | return err
107 | }
108 |
109 | newExt, _ := utils.ExtensionByMimeType(newMimeType)
110 | file.Bytes = convertedImg
111 | file.Mime = newMimeType
112 | file.Filename = utils.ReplaceExt(file.Filename, newExt)
113 | if file.Path != "" {
114 | file.Path = utils.ReplaceExt(file.Path, newExt)
115 | }
116 |
117 | return nil
118 | }
119 |
120 | func (i imageBackend) fixPNGTransparency(img *bimg.Image) *bimg.Image {
121 | // convert to go image because bimg has no drawing features
122 | origImg, _, err := image.Decode(bytes.NewReader(img.Image()))
123 | if err != nil {
124 | return img
125 | }
126 |
127 | // draw white square and paste image on top of it
128 | newImg := image.NewRGBA(origImg.Bounds())
129 | draw.Draw(newImg, newImg.Bounds(), &image.Uniform{color.White}, image.Point{}, draw.Src)
130 | draw.Draw(newImg, newImg.Bounds(), origImg, origImg.Bounds().Min, draw.Over)
131 |
132 | // convert back to bytes
133 | buf := new(bytes.Buffer)
134 | err = jpeg.Encode(buf, newImg, nil)
135 | if err != nil {
136 | return img
137 | }
138 | return bimg.NewImage(buf.Bytes())
139 | }
140 |
141 | func (i imageBackend) mimeTypeToImageType(mimeType string) (bimg.ImageType, error) {
142 | mapping := map[string]bimg.ImageType{
143 | "image/jpeg": bimg.JPEG,
144 | "image/pjpeg": bimg.JPEG,
145 | "image/webp": bimg.WEBP,
146 | "image/png": bimg.PNG,
147 | "image/tiff": bimg.TIFF,
148 | "image/gif": bimg.GIF,
149 | "image/svg": bimg.SVG,
150 | "image/heic": bimg.HEIF,
151 | "image/heif": bimg.HEIF,
152 | "image/avif": bimg.AVIF,
153 | }
154 | if imageType, ok := mapping[mimeType]; ok {
155 | return imageType, nil
156 | } else {
157 | return bimg.UNKNOWN, fmt.Errorf("'%s' is not supported", mimeType)
158 | }
159 | }
160 |
--------------------------------------------------------------------------------
/pepic/processing/processing.go:
--------------------------------------------------------------------------------
1 | package processing
2 |
3 | type Processing struct {
4 | Image ImageBackend
5 | Video VideoBackend
6 | }
7 |
--------------------------------------------------------------------------------
/pepic/processing/video.go:
--------------------------------------------------------------------------------
1 | package processing
2 |
3 | import (
4 | "errors"
5 | "fmt"
6 | "log"
7 | "os"
8 | "path"
9 |
10 | "github.com/vas3k/pepic/pepic/config"
11 | "github.com/vas3k/pepic/pepic/entity"
12 | "github.com/vas3k/pepic/pepic/utils"
13 | "github.com/xfrr/goffmpeg/transcoder"
14 | )
15 |
16 | type VideoBackend interface {
17 | Transcode(file *entity.ProcessingFile, maxLength int) error
18 | Convert(file *entity.ProcessingFile, newMimeType string) error
19 | }
20 |
21 | type videoBackend struct {
22 | }
23 |
24 | func NewVideoBackend() VideoBackend {
25 | return &videoBackend{}
26 | }
27 |
28 | func (v *videoBackend) Transcode(file *entity.ProcessingFile, maxLength int) error {
29 | log.Printf("Transcoding video '%s' to %d px", file.Filename, maxLength)
30 | if file.Bytes == nil {
31 | return errors.New("file data is empty, try reading it first")
32 | }
33 |
34 | // save bytes to disc because ffmpeg works with filenames
35 | tempOrigFile := path.Join(config.App.Videos.FFmpeg.TempDir, file.Filename)
36 | dst, err := os.Create(tempOrigFile)
37 | if err != nil {
38 | return err
39 | }
40 | defer dst.Close()
41 | defer os.Remove(tempOrigFile)
42 |
43 | _, err = dst.Write(file.Bytes)
44 | if err != nil {
45 | return err
46 | }
47 |
48 | // create temp file output
49 | tempTransFile := path.Join(config.App.Videos.FFmpeg.TempDir, fmt.Sprintf("trans_%s", file.Filename))
50 | dst, err = os.Create(tempTransFile)
51 | if err != nil {
52 | return err
53 | }
54 | defer dst.Close()
55 | defer os.Remove(tempTransFile)
56 |
57 | // create and configure video transcoder
58 | trans, err := v.initTranscoder(tempOrigFile, tempTransFile)
59 | if err != nil {
60 | return err
61 | }
62 |
63 | // add resize filter
64 | trans.MediaFile().SetVideoFilter(fmt.Sprintf("scale=trunc(oh*a/2)*2:%d", maxLength))
65 |
66 | // run transcoding and monitor the process
67 | done := v.runTranscoder(trans)
68 | err = <-done
69 | if err != nil {
70 | return err
71 | }
72 |
73 | // load transcoded video back to memory and remove temp files (deferred)
74 | file.Bytes, err = os.ReadFile(tempTransFile)
75 | if err != nil {
76 | return err
77 | }
78 |
79 | return nil
80 | }
81 |
82 | func (v *videoBackend) Convert(file *entity.ProcessingFile, newMimeType string) error {
83 | log.Printf("Converting video '%s' to %s", file.Filename, newMimeType)
84 | if file.Bytes == nil {
85 | return errors.New("file data is empty, try reading it first")
86 | }
87 |
88 | // save bytes to disc because ffmpeg works with filenames
89 | tempOrigFile := path.Join(config.App.Videos.FFmpeg.TempDir, file.Filename)
90 | dst, err := os.Create(tempOrigFile)
91 | if err != nil {
92 | return err
93 | }
94 | defer dst.Close()
95 | defer os.Remove(tempOrigFile)
96 |
97 | _, err = dst.Write(file.Bytes)
98 | if err != nil {
99 | return err
100 | }
101 |
102 | // create temp file output
103 | newExt, _ := utils.ExtensionByMimeType(newMimeType)
104 | convFilename := utils.ReplaceExt(file.Filename, newExt)
105 | tempTransFile := path.Join(config.App.Videos.FFmpeg.TempDir, fmt.Sprintf("conv_%s", convFilename))
106 | dst, err = os.Create(tempTransFile)
107 | if err != nil {
108 | return err
109 | }
110 | defer dst.Close()
111 | defer os.Remove(tempTransFile)
112 |
113 | // create and configure video transcoder
114 | trans, err := v.initTranscoder(tempOrigFile, tempTransFile)
115 | if err != nil {
116 | return err
117 | }
118 |
119 | // run transcoding and monitor the process
120 | done := v.runTranscoder(trans)
121 | err = <-done
122 | if err != nil {
123 | return err
124 | }
125 |
126 | // load transcoded video back to memory and remove temp files (deferred)
127 | file.Bytes, err = os.ReadFile(tempTransFile)
128 | if err != nil {
129 | return err
130 | }
131 |
132 | file.Mime = newMimeType
133 | file.Filename = convFilename
134 | if file.Path != "" {
135 | file.Path = utils.ReplaceExt(file.Path, newExt)
136 | }
137 |
138 | return nil
139 | }
140 |
141 | func (v *videoBackend) initTranscoder(inputPath string, outputPath string) (*transcoder.Transcoder, error) {
142 | trans := new(transcoder.Transcoder)
143 | err := trans.Initialize(inputPath, outputPath)
144 | if err != nil {
145 | return nil, err
146 | }
147 |
148 | trans.MediaFile().SetPreset(config.App.Videos.FFmpeg.Preset)
149 | trans.MediaFile().SetCRF(uint32(config.App.Videos.FFmpeg.CRF))
150 | trans.MediaFile().SetVideoCodec(config.App.Videos.FFmpeg.VideoCodec)
151 | trans.MediaFile().SetVideoBitRate(config.App.Videos.FFmpeg.VideoBitrate)
152 | trans.MediaFile().SetVideoProfile(config.App.Videos.FFmpeg.VideoProfile)
153 | trans.MediaFile().SetAudioCodec(config.App.Videos.FFmpeg.AudioCodec)
154 | trans.MediaFile().SetAudioBitRate(config.App.Videos.FFmpeg.AudioBitrate)
155 | trans.MediaFile().SetBufferSize(config.App.Videos.FFmpeg.BufferSize)
156 | trans.MediaFile().SetMovFlags(config.App.Videos.FFmpeg.MovFlags)
157 | trans.MediaFile().SetPixFmt(config.App.Videos.FFmpeg.PixFmt)
158 |
159 | return trans, nil
160 | }
161 |
162 | func (v *videoBackend) runTranscoder(trans *transcoder.Transcoder) <-chan error {
163 | done := trans.Run(true)
164 | progress := trans.Output()
165 | for msg := range progress {
166 | log.Print(msg)
167 | }
168 | return done
169 | }
170 |
--------------------------------------------------------------------------------
/pepic/storage/fs.go:
--------------------------------------------------------------------------------
1 | package storage
2 |
3 | import (
4 | "github.com/labstack/echo/v4"
5 | "io/ioutil"
6 | "os"
7 | "path"
8 | )
9 |
10 | type FileSystemBackend struct {
11 | dir string
12 | }
13 |
14 | func NewFileSystemBackend(dir string) *FileSystemBackend {
15 | fs := new(FileSystemBackend)
16 | fs.dir = dir
17 | return fs
18 | }
19 |
20 | func (fs *FileSystemBackend) PutObject(objectName string, data []byte) (string, error) {
21 | fullPath := path.Join(fs.dir, objectName)
22 |
23 | if err := os.MkdirAll(path.Dir(fullPath), os.ModePerm); err != nil {
24 | return "", err
25 | }
26 |
27 | dst, err := os.Create(fullPath)
28 |
29 | if err != nil {
30 | return "", err
31 | }
32 |
33 | defer dst.Close()
34 |
35 | if _, err = dst.Write(data); err != nil {
36 | return "", err
37 | }
38 |
39 | return fullPath, nil
40 | }
41 |
42 | func (fs *FileSystemBackend) GetObject(objectName string) ([]byte, error) {
43 | fullPath := path.Join(fs.dir, objectName)
44 |
45 | data, err := ioutil.ReadFile(fullPath)
46 | if err != nil {
47 | return nil, err
48 | }
49 |
50 | return data, nil
51 | }
52 |
53 | func (fs *FileSystemBackend) IsExists(objectName string) bool {
54 | fullPath := path.Join(fs.dir, objectName)
55 |
56 | if _, err := os.Stat(fullPath); os.IsNotExist(err) {
57 | return false
58 | }
59 |
60 | return true
61 | }
62 |
63 | func (fs *FileSystemBackend) Size(objectName string) int64 {
64 | file, err := os.Open(path.Join(fs.dir, objectName))
65 | defer file.Close()
66 | if err != nil {
67 | return 0
68 | }
69 |
70 | info, err := file.Stat()
71 | if err != nil {
72 | return 0
73 | }
74 | return info.Size()
75 | }
76 |
77 | func (fs *FileSystemBackend) Proxy(c echo.Context, objectName string) error {
78 | return c.File(path.Join(fs.dir, objectName))
79 | }
80 |
--------------------------------------------------------------------------------
/pepic/storage/storage.go:
--------------------------------------------------------------------------------
1 | package storage
2 |
3 | import (
4 | "errors"
5 | "log"
6 | "mime"
7 | "path"
8 |
9 | "github.com/labstack/echo/v4"
10 | "github.com/vas3k/pepic/pepic/entity"
11 | "github.com/vas3k/pepic/pepic/utils"
12 | )
13 |
14 | type Backend interface {
15 | PutObject(objectName string, data []byte) (string, error)
16 | GetObject(objectName string) ([]byte, error)
17 | Size(objectName string) int64
18 | IsExists(objectName string) bool
19 | Proxy(c echo.Context, objectName string) error
20 | }
21 |
22 | type Storage interface {
23 | GetFile(directory string, filename string) (*entity.ProcessingFile, error)
24 | ReadFileBytes(file *entity.ProcessingFile, directories ...string) error
25 | StoreFile(file *entity.ProcessingFile, directories ...string) error
26 | Proxy(c echo.Context, objectName string) error
27 | }
28 |
29 | type storage struct {
30 | Backend Backend
31 | }
32 |
33 | func (s *storage) GetFile(directory string, filename string) (*entity.ProcessingFile, error) {
34 | canonicalFilename := utils.CanonizeFileName(filename)
35 | filePath := path.Join(directory, canonicalFilename)
36 | file := &entity.ProcessingFile{
37 | Filename: filename,
38 | Path: filePath,
39 | Mime: mime.TypeByExtension(path.Ext(canonicalFilename)),
40 | }
41 |
42 | if !s.Backend.IsExists(filePath) {
43 | log.Printf("File does not exists %s", filePath)
44 | return file, errors.New("file does not exists")
45 | }
46 |
47 | file.Size = s.Backend.Size(filePath)
48 |
49 | return file, nil
50 | }
51 |
52 | func (s *storage) ReadFileBytes(file *entity.ProcessingFile, directories ...string) error {
53 | log.Printf("Reading file contents: %s", file.Filename)
54 | canonicalPath := path.Join(
55 | path.Join(directories...),
56 | utils.CanonizeFileName(file.Filename),
57 | )
58 |
59 | data, err := s.Backend.GetObject(canonicalPath)
60 | if err != nil {
61 | log.Fatalf("Error getting file '%s' from storage: %s", canonicalPath, err)
62 | return err
63 | }
64 |
65 | file.Bytes = data
66 | file.Size = int64(len(data))
67 |
68 | return nil
69 | }
70 |
71 | func (s *storage) StoreFile(file *entity.ProcessingFile, directories ...string) error {
72 | log.Printf("Storing file data: %s", file.Filename)
73 | canonicalPath := path.Join(
74 | path.Join(directories...),
75 | utils.CanonizeFileName(file.Filename),
76 | )
77 |
78 | _, err := s.Backend.PutObject(canonicalPath, file.Bytes)
79 | if err != nil {
80 | log.Fatalf("Error writing file '%s' to storage: %s", canonicalPath, err)
81 | return err
82 | }
83 |
84 | file.Path = canonicalPath
85 |
86 | return nil
87 | }
88 |
89 | func (s *storage) Proxy(c echo.Context, objectName string) error {
90 | return s.Backend.Proxy(c, objectName)
91 | }
92 |
93 | func NewStorage(backend Backend) Storage {
94 | return &storage{
95 | Backend: backend,
96 | }
97 | }
98 |
--------------------------------------------------------------------------------
/pepic/template/renderer.go:
--------------------------------------------------------------------------------
1 | package template
2 |
3 | import (
4 | "errors"
5 | "fmt"
6 | "io"
7 | "os"
8 | "path"
9 | "path/filepath"
10 |
11 | "github.com/flosch/pongo2"
12 | "github.com/labstack/echo/v4"
13 | "github.com/vas3k/pepic/pepic/entity"
14 | )
15 |
16 | type Renderer struct {
17 | templates map[string]*pongo2.Template
18 | }
19 |
20 | func (t *Renderer) Render(w io.Writer, name string, data interface{}, c echo.Context) error {
21 | viewContext, isMap := data.(map[string]interface{})
22 | if !isMap {
23 | return errors.New("template context should be a map")
24 | }
25 | viewContext["reverse"] = c.Echo().Reverse
26 | viewContext["renderFileTemplate"] = func(text string, file *entity.ProcessingFile) string {
27 | tpl, err := pongo2.FromString(text)
28 | if err != nil {
29 | return "ERROR"
30 | }
31 | result, _ := tpl.Execute(pongo2.Context{"file": file})
32 | return result
33 | }
34 | viewContext["renderMultipleFileTemplate"] = func(text string, files []*entity.ProcessingFile) string {
35 | tpl, err := pongo2.FromString(text)
36 | if err != nil {
37 | return "ERROR"
38 | }
39 | result, _ := tpl.Execute(pongo2.Context{"files": files})
40 | return result
41 | }
42 | viewContext["bytesHumanize"] = func(b int64) string {
43 | const unit = 1000
44 | if b < unit {
45 | return fmt.Sprintf("%d B", b)
46 | }
47 | div, exp := int64(unit), 0
48 | for n := b / unit; n >= unit; n /= unit {
49 | div *= unit
50 | exp++
51 | }
52 | return fmt.Sprintf("%.1f %cB",
53 | float64(b)/float64(div), "kMGTPE"[exp])
54 | }
55 | return t.templates[name].ExecuteWriter(viewContext, w)
56 | }
57 |
58 | func NewTemplateRenderer(templatesPath string) *Renderer {
59 | templates := make(map[string]*pongo2.Template)
60 | filepath.Walk(templatesPath, func(file string, info os.FileInfo, err error) error {
61 | if path.Ext(file) == ".html" {
62 | templates[path.Base(file)] = pongo2.Must(pongo2.FromFile(file))
63 | }
64 | return nil
65 | })
66 |
67 | renderer := new(Renderer)
68 | renderer.templates = templates
69 | return renderer
70 | }
71 |
--------------------------------------------------------------------------------
/pepic/utils/file.go:
--------------------------------------------------------------------------------
1 | package utils
2 |
3 | import (
4 | "crypto/sha256"
5 | "encoding/hex"
6 | "log"
7 | "mime"
8 | "path"
9 | "strings"
10 |
11 | "github.com/vas3k/pepic/pepic/config"
12 | "github.com/vas3k/pepic/pepic/entity"
13 | )
14 |
15 | var canonicalExtensions = map[string]string{
16 | ".jpeg": ".jpg",
17 | ".jpe": ".jpg",
18 | ".jfif": ".jpg",
19 | ".qt": ".mov",
20 | ".moov": ".mov",
21 | ".f4v": ".mp4",
22 | }
23 |
24 | func ExtensionByMimeType(mimeType string) (string, error) {
25 | exts, err := mime.ExtensionsByType(mimeType)
26 | if err != nil {
27 | return "", err
28 | }
29 |
30 | var ext string
31 | if val, ok := canonicalExtensions[exts[0]]; ok {
32 | ext = val
33 | } else {
34 | ext = exts[0]
35 | }
36 |
37 | return ext, nil
38 | }
39 |
40 | func SplitFileNameNGrams(filename string, n int, stop int) string {
41 | ext := path.Ext(filename)
42 | base := strings.TrimSuffix(filename, ext)
43 |
44 | var resultBuilder strings.Builder
45 | resultBuilder.Grow(len(base) + 5)
46 | for i, r := range base {
47 | resultBuilder.WriteRune(r)
48 | if (i+1)%n == 0 && i < len(base)-1 {
49 | resultBuilder.WriteRune('/')
50 | }
51 | if i >= stop {
52 | resultBuilder.WriteString(base[i+1:])
53 | break
54 | }
55 | }
56 | return resultBuilder.String() + ext
57 | }
58 |
59 | func ReplaceExt(filename string, newExt string) string {
60 | ext := path.Ext(filename)
61 | return filename[:len(filename)-len(ext)] + newExt
62 | }
63 |
64 | func CalculateHashName(file *entity.ProcessingFile) (string, error) {
65 | log.Printf("Calculating file name: %s", file.Filename)
66 | ext, err := ExtensionByMimeType(file.Mime)
67 | if err != nil {
68 | return "", err
69 | }
70 |
71 | sum := sha256.Sum256(file.Bytes)
72 |
73 | return strings.ToLower(hex.EncodeToString(sum[:]) + ext), nil
74 | }
75 |
76 | func CanonizeFileName(filename string) string {
77 | return SplitFileNameNGrams(filename, config.App.Global.FileTreeSplitChars, 10)
78 | }
79 |
--------------------------------------------------------------------------------
/pepic/utils/media.go:
--------------------------------------------------------------------------------
1 | package utils
2 |
3 | import (
4 | "mime"
5 | "net/http"
6 | "path"
7 | )
8 |
9 | func DetectMimeType(filename string, data []byte) string {
10 | mimeType := http.DetectContentType(data)
11 | if mimeType == "application/octet-stream" {
12 | mimeType = mime.TypeByExtension(path.Ext(filename))
13 | }
14 | return mimeType
15 | }
16 |
17 | func FitSize(origWidth int, origHeight int, length int) (int, int) {
18 | if origWidth > origHeight {
19 | return length, (origHeight * length) / origWidth
20 | } else if origWidth < origHeight {
21 | return (origWidth * length) / origHeight, length
22 | } else {
23 | return length, length
24 | }
25 | }
26 |
--------------------------------------------------------------------------------
/static/css/style.css:
--------------------------------------------------------------------------------
1 | :root {
2 | --sans-font: "Ubuntu", Helvetica, Verdana, sans-serif;
3 |
4 | --bg-color: #4D535A;
5 |
6 | --text-color: #FCFBF8;
7 | --brighter-text-color: #FFFFFF;
8 |
9 | --link-color: #FCFBF8;
10 | --link-hover-color: #FFFFFF;
11 | --visited-link-color: #FCFBF8;
12 |
13 | --block-bg-color: #22272C;
14 | --block-shadow: 10px 25px 40px rgba(128, 137, 149, 0.2);
15 | --block-border-radius: 50px;
16 |
17 | --button-color: #ededf6;
18 | --button-bg-color: #573DAB;
19 | --button-border: solid 2px #573DAB;
20 | --button-hover-color: #573DAB;
21 | --button-hover-bg-color: #ededf6;
22 | --button-hover-border: solid 2px #573DAB;
23 | --button-border-radius: 25px;
24 | }
25 |
26 | html, body {
27 | font-family: var(--sans-font);
28 | font-size: 18px;
29 | font-weight: 400;
30 | line-height: 1.42;
31 | color: var(--text-color);
32 | background-color: var(--bg-color);
33 | text-rendering: optimizeLegibility;
34 | -webkit-font-smoothing: antialiased;
35 | -moz-osx-font-smoothing: grayscale;
36 | position: relative;
37 | margin: 0;
38 | padding: 0;
39 | width: 100%;
40 | box-sizing: border-box;
41 | }
42 |
43 | a {
44 | color: var(--link-color);
45 | transition: color linear .1s;
46 | }
47 |
48 | a:hover {
49 | color: var(--link-hover-color);
50 | }
51 |
52 | img {
53 | max-width: 100%;
54 | }
55 |
56 | .block {
57 | padding: 30px;
58 | margin-bottom: 30px;
59 | box-sizing: border-box;
60 | box-shadow: var(--block-shadow);
61 | background-color: var(--block-bg-color);
62 | border-radius: var(--block-border-radius);
63 | }
64 |
65 | .logo {
66 | font-size: 42px;
67 | font-weight: bold;
68 | width: 200px;
69 | padding: 20px;
70 | margin: 70px auto;
71 | text-align: center;
72 | }
73 |
74 | .logo img {
75 | display: inline-block;
76 | vertical-align: middle;
77 | max-width: 52px;
78 | position: relative;
79 | top: -7px;
80 | box-shadow: var(--block-shadow);
81 | }
82 |
83 | .logo a {
84 | text-decoration: none;
85 | }
86 |
87 | .button {
88 | display: inline-block;
89 | padding: 0.4em 1em;
90 | box-sizing: border-box;
91 | text-decoration: none;
92 | border-radius: var(--button-border-radius);
93 | background-color: var(--button-bg-color);
94 | border: var(--button-border);
95 | color: var(--button-color);
96 | text-align: center;
97 | cursor: pointer;
98 | line-height: 1em;
99 | font-weight: 500;
100 | }
101 |
102 | .button-round {
103 | border-radius: 50%;
104 | }
105 |
106 | .button:hover {
107 | color: var(--button-hover-color);
108 | background-color: var(--button-hover-bg-color);
109 | border: var(--button-hover-border);
110 | }
111 |
112 | .upload, .error, .auth {
113 | position: relative;
114 | display: block;
115 | margin: 0 auto;
116 | max-width: 650px;
117 | box-sizing: border-box;
118 | height: 450px;
119 | color: var(--text-color);
120 | background-color: var(--block-bg-color);
121 | box-shadow: var(--block-shadow);
122 | border-radius: var(--block-border-radius);
123 | }
124 |
125 | .upload-placeholder {
126 | font-size: 40px;
127 | opacity: 0.8;
128 | line-height: 2.0em;
129 | display: flex;
130 | justify-content: center;
131 | align-items: center;
132 | text-align: center;
133 | position: absolute;
134 | top: 0;
135 | left: 0;
136 | right: 0;
137 | bottom: 0;
138 | z-index: 1;
139 | padding-bottom: 60px;
140 | }
141 |
142 | .upload-placeholder:hover {
143 | opacity: 1.0;
144 | }
145 |
146 | .upload-form, .upload-file {
147 | position: absolute;
148 | cursor: pointer;
149 | top: 0;
150 | left: 0;
151 | right: 0;
152 | bottom: 0;
153 | z-index: 10;
154 | width: 100%;
155 | outline: none;
156 | text-align: center;
157 | box-sizing: border-box;
158 | }
159 |
160 | .upload-file {
161 | opacity: 0;
162 | }
163 |
164 | .upload-submit {
165 | font-size: 180%;
166 | position: absolute;
167 | bottom: 40px;
168 | left: 50%;
169 | transform: translateX(-50%);
170 | z-index: 100;
171 | }
172 |
173 | .auth {
174 | display: flex;
175 | justify-content: center;
176 | align-items: center;
177 | text-align: center;
178 | max-width: 400px;
179 | height: 300px;
180 | font-size: 150%;
181 | padding: 40px;
182 | }
183 |
184 | .auth-form {
185 | display: block;
186 | }
187 |
188 | .auth-input {
189 | padding: 5px;
190 | display: block;
191 | width: 100%;
192 | font-size: 120%;
193 | box-sizing: border-box;
194 | margin: 20px auto;
195 | text-align: center;
196 | border: var(--button-border)
197 | }
198 |
199 | .auth-submit {
200 | font-size: 100%;
201 | }
202 |
203 | .error {
204 | display: flex;
205 | justify-content: center;
206 | align-items: center;
207 | text-align: center;
208 | height: 300px;
209 | }
210 |
211 | .error-title {
212 | font-weight: 700;
213 | font-size: 400%;
214 | padding-bottom: 20px;
215 | }
216 |
217 | .error-message {
218 | font-size: 150%;
219 | }
220 |
221 | .meta {
222 | display: block;
223 | margin: 50px auto;
224 | width: 100%;
225 | max-width: 800px;
226 | box-sizing: border-box;
227 | padding: 40px;
228 | min-height: 450px;
229 | color: var(--text-color);
230 | background-color: var(--block-bg-color);
231 | box-shadow: var(--block-shadow);
232 | border-radius: var(--block-border-radius);
233 | word-break: break-word;
234 | }
235 |
236 | .meta-media {
237 | display: block;
238 | width: 100%;
239 | margin: 0 auto;
240 | border: var(--button-border);
241 | text-align: center;
242 | border-width: 5px;
243 | box-sizing: border-box;
244 | }
245 |
246 | .meta-media:hover {
247 | border-color: var(--button-hover-bg-color);
248 | }
249 |
250 | .meta-title {
251 | display: block;
252 | text-align: center;
253 | font-size: 130%;
254 | padding: 30px 0;
255 | }
256 |
257 | .meta-info {
258 | display: block;
259 | text-align: center;
260 | opacity: 0.7;
261 | padding-bottom: 30px;
262 | }
263 |
264 | .meta-blocks {
265 | width: 100%;
266 | }
267 |
268 | .meta-block {
269 | display: block;
270 | padding-top: 20px;
271 | }
272 |
273 | .meta-block-title {
274 | display: block;
275 | padding-bottom: 10px;
276 | font-size: 110%;
277 | }
278 |
279 | .meta-block-template {
280 | width: 100%;
281 | height: 60px;
282 | padding: 10px;
283 | box-sizing: border-box;
284 | }
--------------------------------------------------------------------------------
/static/favicon/android-chrome-192x192.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vas3k/pepic/559ba26db60d8433fb0b055e2aef28be6f52bc35/static/favicon/android-chrome-192x192.png
--------------------------------------------------------------------------------
/static/favicon/android-chrome-512x512.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vas3k/pepic/559ba26db60d8433fb0b055e2aef28be6f52bc35/static/favicon/android-chrome-512x512.png
--------------------------------------------------------------------------------
/static/favicon/apple-touch-icon.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vas3k/pepic/559ba26db60d8433fb0b055e2aef28be6f52bc35/static/favicon/apple-touch-icon.png
--------------------------------------------------------------------------------
/static/favicon/favicon-16x16.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vas3k/pepic/559ba26db60d8433fb0b055e2aef28be6f52bc35/static/favicon/favicon-16x16.png
--------------------------------------------------------------------------------
/static/favicon/favicon-32x32.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vas3k/pepic/559ba26db60d8433fb0b055e2aef28be6f52bc35/static/favicon/favicon-32x32.png
--------------------------------------------------------------------------------
/static/favicon/favicon.ico:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vas3k/pepic/559ba26db60d8433fb0b055e2aef28be6f52bc35/static/favicon/favicon.ico
--------------------------------------------------------------------------------
/static/images/logo.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vas3k/pepic/559ba26db60d8433fb0b055e2aef28be6f52bc35/static/images/logo.png
--------------------------------------------------------------------------------
/static/images/screenshot1.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vas3k/pepic/559ba26db60d8433fb0b055e2aef28be6f52bc35/static/images/screenshot1.png
--------------------------------------------------------------------------------
/static/images/screenshot2.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/vas3k/pepic/559ba26db60d8433fb0b055e2aef28be6f52bc35/static/images/screenshot2.png
--------------------------------------------------------------------------------
PEPIC
8 |