.github: update upstream actions to latest version

[nsscash/nsscash.git] / main.go

diff --git a/main.go b/main.go
index e411da4bf9410fc177b4e21350c9e3f1ecacede8..7a7d8b0da8e6855b8545c609f6169184819db7ae 100644 (file)
--- a/main.go
+++ b/main.go
@@ -1,6 +1,6 @@
 // Main file for nsscash
 
-// Copyright (C) 2019  Simon Ruderich
+// Copyright (C) 2019-2021  Simon Ruderich
 //
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU Affero General Public License as published by
@@ -18,16 +18,22 @@
 package main
 
 import (
+       "bytes"
        "flag"
        "fmt"
+       "io/ioutil"
        "log"
        "os"
+       "path/filepath"
+
+       "github.com/google/renameio"
 )
 
 func main() {
        flag.Usage = func() {
                fmt.Fprintf(os.Stderr,
                        "usage: %[1]s [options] fetch <config>\n"+
+                               "usage: %[1]s [options] convert <type> <src> <dst>\n"+
                                "",
                        os.Args[0])
                flag.PrintDefaults()
@@ -46,28 +52,108 @@ func main() {
                        break
                }
 
-               cfg, err := LoadConfig(args[1])
-               if err != nil {
-                       log.Fatal(err)
-               }
-               state, err := LoadState(cfg.StatePath)
+               err := mainFetch(args[1])
                if err != nil {
                        log.Fatal(err)
                }
+               return
 
-               err = handleFiles(cfg, state)
-               if err != nil {
-                       log.Fatal(err)
+       case "convert":
+               if len(args) != 4 {
+                       break
                }
 
-               err = WriteStateIfChanged(cfg.StatePath, state)
+               err := mainConvert(args[1], args[2], args[3])
                if err != nil {
                        log.Fatal(err)
                }
-
                return
        }
 
        flag.Usage()
        os.Exit(1)
 }
+
+func mainFetch(cfgPath string) error {
+       cfg, err := LoadConfig(cfgPath)
+       if err != nil {
+               return err
+       }
+       state, err := LoadState(cfg.StatePath)
+       if err != nil {
+               return err
+       }
+       err = handleFiles(cfg, state)
+       if err != nil {
+               return err
+       }
+       // NOTE: Make sure to call WriteState() only if there were no
+       // errors (see WriteState() and README)
+       err = WriteState(cfg.StatePath, state)
+       if err != nil {
+               return err
+       }
+       return nil
+}
+
+func mainConvert(typ, srcPath, dstPath string) error {
+       var t FileType
+       err := t.UnmarshalText([]byte(typ))
+       if err != nil {
+               return err
+       }
+
+       src, err := ioutil.ReadFile(srcPath)
+       if err != nil {
+               return err
+       }
+       var x bytes.Buffer
+       if t == FileTypePlain {
+               x.Write(src)
+       } else if t == FileTypePasswd {
+               pws, err := ParsePasswds(bytes.NewReader(src))
+               if err != nil {
+                       return err
+               }
+               err = SerializePasswds(&x, pws)
+               if err != nil {
+                       return err
+               }
+       } else if t == FileTypeGroup {
+               grs, err := ParseGroups(bytes.NewReader(src))
+               if err != nil {
+                       return err
+               }
+               err = SerializeGroups(&x, grs)
+               if err != nil {
+                       return err
+               }
+       } else {
+               return fmt.Errorf("unsupported file type %v", t)
+       }
+
+       // We must create the file first or deployFile() will abort; this is
+       // ugly because deployFile() already performs an atomic replacement
+       // but the simplest solution with the least duplicate code
+       f, err := renameio.TempFile(filepath.Dir(dstPath), dstPath)
+       if err != nil {
+               return err
+       }
+       defer f.Cleanup()
+
+       err = deployFile(&File{
+               Type: t,
+               Url:  srcPath,
+               Path: f.Name(),
+               body: x.Bytes(),
+       })
+       if err != nil {
+               return err
+       }
+
+       err = f.CloseAtomicallyReplace()
+       if err != nil {
+               return err
+       }
+       return syncPath(filepath.Dir(dstPath))
+}