nsscash: main_test: use configPath variable

[nsscash/nsscash.git] / main.go

diff --git a/main.go b/main.go
index 7a8755cac1df9d5cd4ffd2ff259b2e15c4e95b07..5455dfe0b367cc8bf92f2ba20979273a97dce086 100644 (file)
--- a/main.go
+++ b/main.go
@@ -24,6 +24,7 @@ import (
        "io/ioutil"
        "log"
        "os"
+       "path/filepath"
 )
 
 func main() {
@@ -49,19 +50,7 @@ func main() {
                        break
                }
 
-               cfg, err := LoadConfig(args[1])
-               if err != nil {
-                       log.Fatal(err)
-               }
-               state, err := LoadState(cfg.StatePath)
-               if err != nil {
-                       log.Fatal(err)
-               }
-               err = handleFiles(cfg, state)
-               if err != nil {
-                       log.Fatal(err)
-               }
-               err = WriteStateIfChanged(cfg.StatePath, state)
+               err := mainFetch(args[1])
                if err != nil {
                        log.Fatal(err)
                }
@@ -72,51 +61,98 @@ func main() {
                        break
                }
 
-               var t FileType
-               err := t.UnmarshalText([]byte(args[1]))
+               err := mainConvert(args[1], args[2], args[3])
                if err != nil {
                        log.Fatal(err)
                }
+               return
+       }
+
+       flag.Usage()
+       os.Exit(1)
+}
 
-               src, err := ioutil.ReadFile(args[2])
+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 {
-                       log.Fatal(err)
+                       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 {
-                               log.Fatal(err)
-                       }
-                       err = SerializePasswds(&x, pws)
-                       if err != nil {
-                               log.Fatal(err)
-                       }
-               } else {
-                       log.Fatalf("unsupported file type %v", t)
+               err = SerializePasswds(&x, pws)
+               if err != nil {
+                       return err
                }
-
-               // We must create the file first or deployFile() will abort
-               f, err := os.Create(args[3])
+       } else if t == FileTypeGroup {
+               grs, err := ParseGroups(bytes.NewReader(src))
                if err != nil {
-                       log.Fatal(err)
+                       return err
                }
-               f.Close()
-
-               err = deployFile(&File{
-                       Type: t,
-                       Url:  args[2],
-                       Path: args[3],
-                       body: x.Bytes(),
-               })
+               err = SerializeGroups(&x, grs)
                if err != nil {
-                       log.Fatal(err)
+                       return err
                }
-               return
+       } else {
+               return fmt.Errorf("unsupported file type %v", t)
        }
 
-       flag.Usage()
-       os.Exit(1)
+       dstDir := filepath.Dir(dstPath)
+       dstName := filepath.Base(dstPath)
+
+       // 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 := ioutil.TempFile(dstDir, "tmp-"+dstName+"-")
+       if err != nil {
+               return err
+       }
+       tmpPath := f.Name()
+       defer os.Remove(tmpPath)
+       f.Close()
+
+       err = deployFile(&File{
+               Type: t,
+               Url:  srcPath,
+               Path: tmpPath,
+               body: x.Bytes(),
+       })
+       if err != nil {
+               return err
+       }
+
+       return os.Rename(tmpPath, dstPath)
 }