Refactoring

README.md

@@ -1,111 +1,130 @@
-[![Go](https://github.com/derfenix/photocatalog/actions/workflows/go.yml/badge.svg)](https://github.com/derfenix/photocatalog/actions/workflows/go.yml)
-
 # Effortless Photo Organizer
 
-Just copy/hardlink photos (or video, or any other files) from one place to
-another, separating them in sub-directories like `$ROOT/year/month/day/`.
+[![Go](https://github.com/derfenix/photocatalog/actions/workflows/go.yml/badge.svg)](https://github.com/derfenix/photocatalog/actions/workflows/go.yml)
 
-### TL;DR 
+A simple tool to organize your photos, videos, or other files by copying or hardlinking them into a date-based directory structure like `$ROOT/year/month/day/`.
 
-I use a smartphone along with Syncthing to seamlessly sync all my photos to my PC without any manual effort. However, there's a catch: I can't keep all my photos in the synced folder indefinitely. If I clear my phone's memory, the photos on my PC get deleted as well. To avoid this, I need to remember to copy the files to another location before cleaning up my phone.
+## TL;DR
 
-Simply dumping all my photos into one folder isn't a solution either — finding anything later would be a nightmare, and a folder with thousands of unsorted photos is far from ideal.
+I use a smartphone and Syncthing to automatically sync my photos to my PC. However, if I clean up my phone's memory, the synced photos on my PC are deleted as well.
+Dumping everything into one folder wasn't an option — finding anything later would be a nightmare. 
 
-To address these issues, I created this tool in just one evening. Its primary purpose is to copy (or create hardlinks for) files from one location to another, while organizing them into a simple, date-based directory structure.
+To avoid this, I needed a solution to back up and organize my photos without manual effort. So, I built this tool in one evening to solve the problem. It has worked flawlessly for me and might help you too. If you encounter any issues, feel free to open a ticket — I'll do my best to assist.
 
-This tool was built for personal use and has been serving me well for quite some time without any problems. However, if you encounter any issues, feel free to report them — I’d be happy to help.
+## Installation
+
+Install the tool via `go`:
 
-## Installing
 ```bash
 go install github.com/derfenix/photocatalog/v2@latest
 ```
-Optionally you could copy created binary from the GO's bin path to 
-system or user $PATH, e.g. /usr/local/bin/.
+
+Optionally, copy the binary to a directory in your system or user's `$PATH` (e.g., `/usr/local/bin`):
+
 ```bash
 sudo cp ${GOPATH}/bin/photocatalog /usr/local/bin/photocatalog
 ```
 
-## Migrating from v0.*
+## Organization Modes
 
-TODO 
+The tool supports the following organization modes:
 
-## Organization modes
+- **copy** — Copies files to the target directory. If the filesystem supports it, uses Copy-on-Write (COW) for efficiency (via FICLONE ioctl call).
+- **hardlink** — Creates hardlinks to the source files, saving disk space. Ideal (and usable only) if the source and target are on the same partition, 
+though file permissions remain linked to the original. Fallback to copy on fail.
+- **move** — Moves files from the source to the target directory.
+- **symlink** — Creates symbolic links at the target pointing to the source files.
 
-Next organization modes supported:
-    
-- **copy** — copy files to target root. Make COW (using syscall) if FS supports it.
-- **hardlink** — create hardlink to the source file instead of copying. 
-The best choice if source and target are in same partition for compatibility
-and resource usage, but we can't chmod target files, because of original file mode will 
-be changed too. 
-- **move** — moves original files to new place.
-- **symlink** — create a symlink at the target for the source files. 
+## Supported Formats
 
-## Supported formats
-At this moment supported jpeg and tiff files with filled exif data and any other 
-files but with names matching pattern `yyymmdd_HHMMSS.ext` with optional suffixes after a timestamp.
-Such names format applied by the Android's camera software (I guess all cams 
-use this format, fix me if I'm wrong). 
+- **JPEG and TIFF files** with valid EXIF metadata.
+- Files named in the format `yyyymmdd_HHMMSS.ext` (optionally with suffixes after the timestamp) (e.g., `20230101_123456.jpg`). This format is common in Android cameras and other devices.
 
-Jpeg/Tiff files without modification date if exif will be fallen back to the name parsing.
+If a file lacks EXIF data, the tool falls back to parsing the filename.
 
-No able to change names format without modifying source code for now. Just because 
-I have reasons to believe that this format is the most popular for the application use cases.
-But let me know if you need different timestamp formats support.
+Currently, the timestamp format is not customizable. Let me know if support for additional formats is required.
 
 ## Usage
-### One-shot 
-#### Copy files
-```bash
-photocalog -mode copy -target ./photos/ -source ./sync/photos/
+
+Arguments
+```
+  -dir-mode string
+        Mode bits for directories can be created while syncing (default "0777")
+  -file-mode string
+        Mode bits for files created while syncing (not applicable for hardlink mode) (default "0644")
+  -mode string
+        Organazing mode (default "hardlink")
+  -overwrite
+        Overwrite existing files
+  -skip-full-sync
+        Skip full sync at startup
+  -source string
+        Source directory
+  -target string
+        Target directory
+  -watch
+        Watch for changes in the source directory (default true)
+
 ```
 
-#### Create hardlinks
-```bash
-photocalog -mode hardlink -target ./photos/ -source ./sync/photos/
-```
-or 
-```bash
-photocalog -target ./photos/ -source ./sync/photos/*
+`-skip-full-sync` and `-watch` are not compatible.
+
+`-source` and `-target` are required.
+
+
+## Examples
+
+### One-Time Run
+
+#### Copy Files
+```shell
+photocatalog -mode copy -target ./photos/ -source ./sync/photos/
 ```
 
-### Watch mode
-#### Copy files
-```bash
-photocalog -mode copy -target ./photos -watch -source ./sync/photos/
+#### Create Hardlinks
+```shell
+photocatalog -mode hardlink -target ./photos/ -source ./sync/photos/
 ```
 
-#### Create hardlinks
-```bash
-photocalog -mode hardlink -target ./photos/ -watch -source ./sync/photos/
-```
-or 
-```bash
-photocalog -target ./photos/ -watch -source ./sync/photos/
+### Watch Mode
+
+Enable continuous monitoring of a source directory:
+
+#### Copy Files
+```shell
+photocatalog -mode copy -target ./photos -watch -source ./sync/photos/
 ```
 
-## Install and run monitor service
+#### Create Hardlinks
+```shell
+photocatalog -mode hardlink -target ./photos/ -watch -source ./sync/photos/
+```
 
-### Systemd
-```bash
+## Running as a Service
+
+### Systemd Setup
+
+Install and configure the service:
+```shell
 sh ./init/install_service.sh systemd
 ```
-This command will install unit file, create stub for its config and open
-editor to allow you edit configuration. Config file stored at 
-`$HOME/.config/photocatalog`.
 
-Then enable and start service
-```bash
+This will:
+
+1. Install a systemd unit file.
+2. Create a configuration stub at `$HOME/.config/photocatalog`.
+3. Open the config file for editing.
+
+Enable and start the service:
+```shell
 systemctl --user enable --now photocatalog
 ```
-That's all. Now, if any file will be placed in directory, specified as `MONITOR`
-in config file, this file will be copied or hardlinked into the target dir
-under corresponding sub-dir. 
+
+Now, files added to the monitored directory (`MONITOR` in the config) will automatically be organized into the target directory under the corresponding subdirectories.
 
 ## FAQ
 
-### Why this tool was created if there is awesome XXX tool?
-I had two good reasons:
-1. I wish
-2. I can
-
+### Why did you create this tool when awesome tool XXX already exists?
+Two reasons:
+1. I wanted to.
+2. I could.

application/application.go

@@ -43,24 +43,24 @@ func (a *Application) Start(ctx context.Context, wg *sync.WaitGroup) error {
 		WithDirMode(os.FileMode(a.config.DirMode)).
 		WithFileMode(os.FileMode(a.config.FileMode)).
 		WithErrLogger(func(err error) {
-			log.Println(err)
+			log.Println("ERROR:", err.Error())
 		})
 
 	if a.config.Overwrite {
 		org = org.WithOverwrite()
 	}
 
-	if !a.config.SkipFullSync {
-		if err := org.FullSync(ctx); err != nil {
-			return fmt.Errorf("full sync: %w", err)
-		}
-	}
-
 	if a.config.Watch {
 		if err := org.Watch(ctx, wg); err != nil {
 			return fmt.Errorf("initialize watch: %w", err)
 		}
 	}
 
+	if !a.config.SkipFullSync {
+		if err := org.FullSync(ctx); err != nil {
+			return fmt.Errorf("full sync: %w", err)
+		}
+	}
+
 	return nil
 }

application/config.go

@@ -14,6 +14,8 @@ const (
 	ModeMove     Mode = "move"
 )
 
+var SupportedModes = []Mode{ModeHardlink, ModeSymlink, ModeMove, ModeCopy}
+
 type Config struct {
 	SourceDir    string
 	TargetDir    string
@@ -34,8 +36,8 @@ func (c *Config) Validate() error {
 		return fmt.Errorf("target dir is required")
 	}
 
-	if !slices.Contains([]Mode{ModeHardlink, ModeSymlink, ModeMove, ModeCopy}, c.Mode) {
-		return fmt.Errorf("invalid mode %s", c.Mode)
+	if !slices.Contains(SupportedModes, c.Mode) {
+		return fmt.Errorf("invalid mode %s, supported modes: %s", c.Mode, SupportedModes)
 	}
 
 	if c.SkipFullSync && !c.Watch {

init/systemd/photocatalog.service

@@ -7,5 +7,5 @@ WantedBy=default.target
 [Service]
 Type=simple
 EnvironmentFile=/home/%u/.config/photocatalog
-ExecStart=photocatalog -mode $MODE -target $TARGET -monitor $MONITOR -update_mtime $UPDATECTIME
-ExecStartPre=photocatalog -mode $MODE -target $TARGET ${MONITOR}
+ExecStart=photocatalog -mode $MODE -target $TARGET -watch -source $MONITOR -skip-full-sync
+ExecStartPre=photocatalog -mode $MODE -target $TARGET -source ${MONITOR}

internal/organizer/modes/hardlink.go

@@ -1,21 +1,38 @@
 package modes
 
 import (
-	"fmt"
+	"log"
 	"os"
+	"sync/atomic"
 )
 
+var hardLinkNotSupported = atomic.Bool{}
+
 type HardLink struct {
 }
 
 func (h HardLink) PlaceIt(sourcePath, targetPath string, mode os.FileMode) error {
+	if hardLinkNotSupported.Load() {
+		return h.fallBack(sourcePath, targetPath, mode)
+	}
+
 	if err := os.Link(sourcePath, targetPath); err != nil {
 		if os.IsExist(err) {
 			return nil
 		}
 
-		return fmt.Errorf("create hard link: %w", err)
+		log.Println("Create hardlink failed:", err.Error())
+		hardLinkNotSupported.Store(true)
+
+		return h.fallBack(sourcePath, targetPath, mode)
 	}
 
 	return nil
 }
+
+func (h HardLink) fallBack(sourcePath string, targetPath string, mode os.FileMode) error {
+	if copyErr := (Copy{}).PlaceIt(sourcePath, targetPath, mode); copyErr != nil {
+		return copyErr
+	}
+	return nil
+}

internal/organizer/organizer.go

@@ -11,6 +11,7 @@ import (
 	"strconv"
 	"strings"
 	"sync"
+	"syscall"
 
 	"github.com/fsnotify/fsnotify"
 
@@ -130,6 +131,8 @@ func (o *Organizer) Watch(ctx context.Context, wg *sync.WaitGroup) error {
 		if err := watcher.Close(); err != nil {
 			o.logErr(fmt.Errorf("close watcher: %w", err))
 		}
+
+		syscall.Sync()
 	}()
 
 	go func() {
@@ -149,15 +152,17 @@ func (o *Organizer) Watch(ctx context.Context, wg *sync.WaitGroup) error {
 					// Add new directories to the watcher.
 					if stat.IsDir() {
 						if err := watcher.Add(event.Name); err != nil {
-							o.logErr(fmt.Errorf("watch dir: %w", err))
+							o.logErr(fmt.Errorf("add the directory %s to watcher: %w", event.Name, err))
 						}
 
 						continue
 					}
 
-					if err := o.processFile(event.Name); err != nil {
-						o.logErr(fmt.Errorf("process file %s: %w", event.Name, err))
-					}
+					go func() {
+						if err := o.processFile(event.Name); err != nil {
+							o.logErr(fmt.Errorf("process file %s: %w", event.Name, err))
+						}
+					}()
 				}
 
 			case <-ctx.Done():
@@ -180,7 +185,9 @@ func (o *Organizer) FullSync(ctx context.Context) error {
 		}
 
 		if err := o.processFile(path); err != nil {
-			return err
+			log.Printf("Process file `%s` failed: %s", path, err.Error())
+
+			return nil
 		}
 
 		return nil
@@ -203,7 +210,7 @@ func (o *Organizer) getMetaForPath(fp string) (metadata.Metadata, error) {
 
 	meta, err := o.getMetadata(fp, file)
 	if err != nil {
-		return metadata.Metadata{}, fmt.Errorf("get metadata: %w", err)
+		return metadata.Metadata{}, fmt.Errorf("get metadatas: %w", err)
 	}
 
 	return meta, nil
@@ -246,7 +253,7 @@ func (o *Organizer) processFile(sourcePath string) error {
 		return fmt.Errorf("build target path: %w", err)
 	}
 
-	if pathExists(targetPath) && !o.overwrite {
+	if o.pathExists(targetPath) && !o.overwrite {
 		return nil
 	}
 
@@ -281,7 +288,7 @@ func (o *Organizer) BuildTargetPath(sourcePath string, meta metadata.Metadata) (
 }
 
 func (o *Organizer) ensureTargetPath(targetPath string) error {
-	if pathExists(targetPath) {
+	if o.pathExists(targetPath) {
 		return nil
 	}
 
@@ -303,13 +310,15 @@ func (o *Organizer) ensureTargetPath(targetPath string) error {
 	return nil
 }
 
-func pathExists(path string) bool {
+func (o *Organizer) pathExists(path string) bool {
 	_, err := os.Stat(path)
 	if err != nil {
 		if os.IsNotExist(err) {
 			return false
 		}
 
+		o.logErr(fmt.Errorf("pathExists stat %s: %w", path, err))
+
 		return true
 	}
 

main.go

@@ -3,8 +3,10 @@ package main
 import (
 	"context"
 	"flag"
+	"fmt"
 	"log"
 	"os/signal"
+	"slices"
 	"strconv"
 	"sync"
 	"syscall"
@@ -38,31 +40,49 @@ func loadCfg() application.Config {
 	flag.StringVar(&cfg.SourceDir, "source", "", "Source directory")
 	flag.StringVar(&cfg.TargetDir, "target", "", "Target directory")
 	flag.BoolVar(&cfg.Overwrite, "overwrite", false, "Overwrite existing files")
-	flag.BoolVar(&cfg.Watch, "watch", true, "Watch for changes in the source directory")
+	flag.BoolVar(&cfg.Watch, "watch", false, "Watch for changes in the source directory")
+	flag.BoolVar(&cfg.Watch, "monitor", false, "Watch for changes in the source directory") // Legacy option
 	flag.BoolVar(&cfg.SkipFullSync, "skip-full-sync", false, "Skip full sync at startup")
 
-	var dirMode string
-	var fileMode string
-	flag.StringVar(&dirMode, "dir-mode", "0777", "Mode bits for directories can be created while syncing")
-	flag.StringVar(&fileMode, "file-mode", "0644", "Mode bits for files created while syncing (not applicable for hardlink mode)")
+	flag.Func("dir-mode", "Mode bits for directories can be created while syncing", func(s string) error {
+		var err error
 
-	var mode string
-	flag.StringVar(&mode, "mode", "hardlink", "Mode")
+		cfg.DirMode, err = strconv.ParseUint(s, 8, 32)
+		if err != nil {
+			return err
+		}
+
+		return nil
+	})
+
+	flag.Func("file-mode", "Mode bits for files created while syncing (not applicable for hardlink mode)", func(s string) error {
+		var err error
+
+		cfg.FileMode, err = strconv.ParseUint(s, 8, 32)
+		if err != nil {
+			return err
+		}
+
+		return nil
+	})
+
+	flag.Func("mode", "Organizing mode", func(s string) error {
+		cfg.Mode = application.Mode(s)
+
+		if !slices.Contains(application.SupportedModes, cfg.Mode) {
+			return fmt.Errorf("invalid mode, supported modes: %s", application.SupportedModes)
+		}
+
+		return nil
+	})
 
 	flag.Parse()
 
-	cfg.Mode = application.Mode(mode)
+	// Legacy fallback
+	if cfg.SourceDir == "" {
+		log.Println("Source directory not specified. May be using old systemd unit file.")
 
-	var err error
-
-	cfg.DirMode, err = strconv.ParseUint(dirMode, 8, 32)
-	if err != nil {
-		cfg.DirMode = 0o777
-	}
-
-	cfg.FileMode, err = strconv.ParseUint(fileMode, 8, 32)
-	if err != nil {
-		cfg.DirMode = 0o644
+		cfg.SourceDir = flag.Arg(0)
 	}
 
 	return cfg