Add support for group files

[nsscash/nsscash.git] / main.go

diff --git a/main.go b/main.go
index 50263877f2a71380b1b774e40f3984498324a8c6..b10f57e55b92776a18ff5dfa76fb7ed25cc5b39c 100644 (file)
--- a/main.go
+++ b/main.go
@@ -18,32 +18,114 @@
 package main
 
 import (
+       "bytes"
+       "flag"
+       "fmt"
+       "io/ioutil"
        "log"
        "os"
 )
 
 func main() {
-       if len(os.Args) != 2 {
-               log.SetFlags(0)
-               log.Fatalf("usage: %s <path/to/config>\n", os.Args[0])
+       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()
        }
+       flag.Parse()
 
-       cfg, err := LoadConfig(os.Args[1])
-       if err != nil {
-               log.Fatal(err)
-       }
-       state, err := LoadState(cfg.StatePath)
-       if err != nil {
-               log.Fatal(err)
+       args := flag.Args()
+       if len(args) == 0 {
+               flag.Usage()
+               os.Exit(1)
        }
 
-       err = handleFiles(cfg, state)
-       if err != nil {
-               log.Fatal(err)
-       }
+       switch args[0] {
+       case "fetch":
+               if len(args) != 2 {
+                       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)
+               if err != nil {
+                       log.Fatal(err)
+               }
+               return
+
+       case "convert":
+               if len(args) != 4 {
+                       break
+               }
 
-       err = WriteStateIfChanged(cfg.StatePath, state)
-       if err != nil {
-               log.Fatal(err)
+               var t FileType
+               err := t.UnmarshalText([]byte(args[1]))
+               if err != nil {
+                       log.Fatal(err)
+               }
+
+               src, err := ioutil.ReadFile(args[2])
+               if err != nil {
+                       log.Fatal(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 if t == FileTypeGroup {
+                       grs, err := ParseGroups(bytes.NewReader(src))
+                       if err != nil {
+                               log.Fatal(err)
+                       }
+                       err = SerializeGroups(&x, grs)
+                       if err != nil {
+                               log.Fatal(err)
+                       }
+               } else {
+                       log.Fatalf("unsupported file type %v", t)
+               }
+
+               // We must create the file first or deployFile() will abort
+               f, err := os.Create(args[3])
+               if err != nil {
+                       log.Fatal(err)
+               }
+               f.Close()
+
+               err = deployFile(&File{
+                       Type: t,
+                       Url:  args[2],
+                       Path: args[3],
+                       body: x.Bytes(),
+               })
+               if err != nil {
+                       log.Fatal(err)
+               }
+               return
        }
+
+       flag.Usage()
+       os.Exit(1)
 }