meta4-check workability again

[meta4ra.git] / cmd / meta4-create / main.go

diff --git a/cmd/meta4-create/main.go b/cmd/meta4-create/main.go
index b5d9abac4175411f8079f19ecf5cb37754825cae..f5d8b5ca4c98858ea3bc6812806534c944c34ec4 100644 (file)
--- a/cmd/meta4-create/main.go
+++ b/cmd/meta4-create/main.go
@@ -20,103 +20,24 @@ package main
 
 import (
        "bufio"
-       "bytes"
        "encoding/xml"
        "flag"
        "io"
        "log"
        "os"
-       "os/exec"
        "path"
        "strings"
-       "sync"
        "time"
 
        "go.stargrave.org/meta4ra"
 )
 
-type Hasher struct {
-       names []string
-       cmds  []*exec.Cmd
-       ins   []io.WriteCloser
-       outs  []io.ReadCloser
-       wg    sync.WaitGroup
-}
-
-func NewHasher(hashes string) *Hasher {
-       h := Hasher{}
-       for _, hc := range strings.Split(hashes, ",") {
-               cols := strings.SplitN(hc, ":", 2)
-               name, cmdline := cols[0], cols[1]
-               cmd := exec.Command(cmdline)
-               in, err := cmd.StdinPipe()
-               if err != nil {
-                       log.Fatalln(err)
-               }
-               out, err := cmd.StdoutPipe()
-               if err != nil {
-                       log.Fatalln(err)
-               }
-               if err = cmd.Start(); err != nil {
-                       log.Fatalln(err)
-               }
-               h.names = append(h.names, name)
-               h.ins = append(h.ins, in)
-               h.outs = append(h.outs, out)
-               h.cmds = append(h.cmds, cmd)
-       }
-       return &h
-}
-
-func (h *Hasher) Write(p []byte) (n int, err error) {
-       h.wg.Add(len(h.names))
-       for _, in := range h.ins {
-               go func(in io.WriteCloser) {
-                       if _, err := io.Copy(in, bytes.NewReader(p)); err != nil {
-                               log.Fatalln(err)
-                       }
-                       h.wg.Done()
-               }(in)
-       }
-       h.wg.Wait()
-       return len(p), nil
-}
-
-func (h *Hasher) Sums() []meta4ra.Hash {
-       sums := make([]meta4ra.Hash, 0, len(h.names))
-       for i, name := range h.names {
-               if err := h.ins[i].Close(); err != nil {
-                       log.Fatalln(err)
-               }
-               dgst, err := io.ReadAll(h.outs[i])
-               if err != nil {
-                       log.Fatalln(err)
-               }
-               sums = append(sums, meta4ra.Hash{Type: name, Hash: string(dgst[:len(dgst)-1])})
-               if err = h.cmds[i].Wait(); err != nil {
-                       log.Fatalln(err)
-               }
-       }
-       return sums
-}
-
 func main() {
        fn := flag.String("fn", "", "Filename")
        mtime := flag.String("mtime", "", "Take that file's mtime as a Published date")
        desc := flag.String("desc", "", "Description")
        sig := flag.String("sig", "", "Path to signature file")
-       hashesDef := []string{
-               "sha-256:sha256",
-               "sha-512:sha512",
-               "shake128:shake128sum",
-               "shake256:shake256sum",
-               "streebog-256:streebog256sum",
-               "streebog-512:streebog512sum",
-               "skein-256:skein256",
-               "skein-512:skein512",
-               "blake3-256:b3sum",
-       }
-       hashes := flag.String("hashes", strings.Join(hashesDef, ","), "hash-name:command-s")
+       hashes := flag.String("hashes", strings.Join(meta4ra.HashesDefault, ","), "hash-name:command-s")
        torrent := flag.String("torrent", "", "Torrent URL")
        log.SetFlags(log.Lshortfile)
        flag.Parse()
@@ -127,7 +48,8 @@ func main() {
        for _, u := range flag.Args() {
                urls = append(urls, meta4ra.URL{URL: u})
        }
-       h := NewHasher(*hashes)
+       h := meta4ra.NewHasher(*hashes)
+       h.Start()
        br := bufio.NewReaderSize(os.Stdin, 1<<20)
        buf := make([]byte, 1<<20)
        size, err := io.CopyBuffer(h, br, buf)