hancock

// Copyright (C) 2019  David N. Cohen

// 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
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.

// This program is distributed in the hope that it will be useful,
................................................................................
//    hancock publish
//
// This operation published the files produced by `hancock testimony`.
package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io/ioutil"

	"net/http"
	"net/url"
	"os"
	"path/filepath"

	"github.com/pkg/errors"
	"src.d10.dev/command"
	"src.d10.dev/hancock/model"

)

var (
	// Flags that may be used by both publish and testimony operations.

	storeFlag command.StringSet
)

func validateStoreFlag(def string) error {

	if len(storeFlag) == 0 && def != "" {
		storeFlag = append(storeFlag, def)
	}
	for _, val := range storeFlag {
		if val == "" {
			continue
		}
		u, err := url.Parse(val)
		if err != nil {
			command.Error(errors.Wrapf(err, "bad index URL (%s)", val))
			command.Exit()
		}
		switch u.Scheme {
		case "http", "https", "file":
			// supported scheme
		default:
			command.Errorf("bad index (%q): scheme must be http(s):// or file://", val)
			command.Exit()
		}
	}
	return nil
}

func init() {
	command.RegisterOperation(command.Operation{
		Handler:     publishMain,
		Name:        "publish",
		Syntax:      "publish [-store=<url>] [in=<directory] [testimony ...]",
		Description: "Publish signed manifest to an index. Expects signed activity on stdin, as encoded by `hancock-sign`.",

	})
}

func publishMain() error {
	cfg, err := command.Config()
	command.Check(err)

	// defaults
	cfgTop := cfg.Section("")
	cfgOp := cfg.Section("publish")

	defaultStore := cfgOp.Key("store").MustString(cfgTop.Key("store").MustString("https://hancock.beyondcentral.com"))
	defaultDirectory := cfgOp.Key("testimony").MustString(cfgTop.Key("testimony").String())

	// args
	command.OperationFlagSet.Var(&storeFlag, "store", fmt.Sprintf("URL of testimony store (default %q)", defaultStore))
	inFlag := command.OperationFlagSet.String("in", defaultDirectory, "directory containing testimony files")


	// parse flags
	err = command.OperationFlagSet.Parse(command.Args()[1:])

	if err != nil {
		return err
	}

	// validate flags
	err = validateStoreFlag(defaultStore)
	if err != nil {
		return err
	}
	if len(storeFlag) == 0 {
		return errors.New("Storage URL required. Use flag `-store <URL>` or see configuration file.")
	}


	if len(command.OperationFlagSet.Args()) == 0 && *inFlag == "" {
		return errors.New("Testimony required.  Use `-in <directory>` or specify testimony files.")

	}

	if *inFlag != "" {
		inStat, err := os.Stat(*inFlag)
		if os.IsNotExist(err) {
			return fmt.Errorf("Input directory does not exist (%q).", *inFlag)


		}
		if !inStat.IsDir() {
			return fmt.Errorf("Not a directory (%q).", *inFlag)





		}
	}


	in := command.OperationFlagSet.Args()
	if len(in) == 0 {
		in = append(in, *inFlag)
	}

	// TODO(dnc): concurrency
	for _, fileOrDir := range in {
		count := 0
		err = filepath.Walk(fileOrDir, func(filepath string, info os.FileInfo, err error) error {
			if err != nil {

				return err
			}
			if info.IsDir() {
				return nil // noop, continue walk (we only process files, not directories)

			}



			f, err := os.Open(filepath)


			if err != nil {
				return err
			}
			defer f.Close()


			dec := json.NewDecoder(f)
			var testimony fileTestimony
			err = dec.Decode(&testimony)
			if err != nil {
				return err
			}
			err = testimony.FileManifest.Check()
			if err != nil {
				return err
			}

			// validate testimony here?
			stored := false
			for _, storeURL := range storeFlag {
				err = publishTestimonyToStore(storeURL, testimony)
				if err != nil {
					command.Error(err)
				} else {
					stored = true
				}
			}
			if stored {
				count++
			}
			return err
		})
		command.V(1).Infof("Published %d items from %q.", count, fileOrDir)
		if err != nil {
			command.Error(err)
		}
	}

	return nil
}

func publishTestimonyToIPFS(ipfsURL string, ft fileTestimony) error {
	err := ipfsAdd(ipfsURL, ft.Bytes(), ft.FileName())
	return err
}

// publish testimony either to local filesystem or via POST to online index.
func publishTestimonyToStore(storeURL string, ft fileTestimony) error {

	u, err := url.Parse(storeURL)
	if err != nil {
		return err
	}

	err = ft.Check()
	if err != nil {

// Copyright (C) 2019, 2020  David N. Cohen

// 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
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.

// This program is distributed in the hope that it will be useful,
................................................................................
//    hancock publish
//
// This operation published the files produced by `hancock testimony`.
package main

import (
	"bytes"

	"fmt"
	"io/ioutil"
	"log"
	"net/http"
	"net/url"
	"os"
	"path/filepath"

	"github.com/pkg/errors"
	"src.d10.dev/command"
	"src.d10.dev/hancock/model"
	"src.d10.dev/hancock/store"
)
































func init() {
	command.RegisterOperation(command.Operation{
		Handler:     publishMain,
		Name:        "publish",
		Syntax:      "publish [-store=<destination>] <source> [...]",

		Description: "Publish signed testimony from a local store to a remote store.  Use `hancock testimony` to populate local store.",
	})
}

func publishMain() error {
	cfg, err := command.Config()
	command.Check(err)

	// defaults
	cfgTop := cfg.Section("")
	cfgOp := cfg.Section("publish")

	defaultStore := cfgOp.Key("store").MustString(cfgTop.Key("store").MustString("https://hancock.beyondcentral.com"))


	// args


	storeFlag := command.OperationFlagSet.String("store", "defaultStore", fmt.Sprintf("URL of remote testimony store (default %q)", defaultStore))

	// parse flags

	err = command.ParseOperationFlagSet()
	if err != nil {
		return err
	}

	// validate flags
	remote, err := storeFromFlag(*storeFlag)
	if err != nil {
		return err
	}



	defer closeStore() // closes all results of storeFromFlag()

	if len(command.OperationFlagSet.Args()) == 0 {

		return errors.New("Local testimony store required.")
	}

	// first loop, validate that local store supports Iterable
	for _, arg := range command.OperationFlagSet.Args() {
		in, err := storeFromFlag(arg)
		if err != nil {
			command.Error(fmt.Errorf("failed to open local testimony store (%q): %w", arg, err))
			return nil
		}


		// input stores must implement Iterable (output does not need to)
		_, ok := in.(store.Iterable)
		if !ok {
			command.Errorf("Cannot publish from testimony store (%q): not iterable", arg)
			return nil
		}
	}

	pubs := 0
	for _, arg := range command.OperationFlagSet.Args() {

		tmp, err := storeFromFlag(arg)






		if err != nil {
			command.Error(fmt.Errorf("failed to open local testimony store (%q): %w", arg, err))
			return nil
		}


		in := tmp.(store.Iterable)

		err = in.ForEach(func(key model.TestimonyKey, testimony model.Testimony) error {
			// TODO(dnc): concurrency, for performance


			// sanity check (should not be needed)
			err := testimony.Check()
			if err != nil {
				return err
			}


			// publish testimony from local to remote
			k, err := remote.PutTestimony(testimony)






			if err != nil {
				return err
			}

			command.V(1).Infof("published %v to %v", k, remote)
			pubs++











			return nil
		})

		if err != nil {
			command.Error(err)
		}
	}

	command.Infof("published %d items to %q", pubs, remote)




	return nil
}

// publish testimony either to local filesystem or via POST to online index.
func XXXpublishTestimonyToStore(storeURL string, ft fileTestimony) error {
	log.Panic("replace calls to publishTestimonyToStore() with store.Store interface!")
	u, err := url.Parse(storeURL)
	if err != nil {
		return err
	}

	err = ft.Check()
	if err != nil {

import (
	"encoding/json"
	"fmt"
	"io"
	"log"
	"os"

	"github.com/pkg/errors"
	"golang.org/x/crypto/ssh"

	"src.d10.dev/command"
	"src.d10.dev/hancock/model"
)

func init() {
................................................................................
	// defaults
	cfgTop := cfg.Section("")
	cfgTestimony := cfg.Section("testimony")

	defaultStore := cfgTestimony.Key("store").MustString(cfgTop.Key("store").String())

	// define args
	command.OperationFlagSet.Var(&storeFlag, "store", fmt.Sprintf("URL where testimony is saved/published (default %q)", defaultStore))
	noopFlag := command.OperationFlagSet.Bool("n", false, "do not save/publish")

	// parse args
	err = command.OperationFlagSet.Parse(command.Args()[1:])
	if err != nil {
		return err
	}

	// validate args
	err = validateStoreFlag(defaultStore)
	if err != nil {
		return err
	}
	if len(storeFlag) == 0 {
		return errors.New("Storage URL required. Use flag `-store <URL>` or see configuration file.")
	}
	defer closeStore() // cleanup; safe to call even if no stores initialized

	// decode input
	dec := json.NewDecoder(os.Stdin)

	// first input, the public key (corresponding to signing private key)
	var authorityEncoded model.Authority
................................................................................
			Authority: authorityEncoded,
			Content:   man.Content,
			Encoded:   rawMan,
			Signature: sig,
		}

		if !*noopFlag {
			//ft := fileTestimony{Testimony: testimony, FileManifest: man} // testimony with decoded manifest
			stored := false
			for _, storeURL := range storeFlag {
				if storeURL == "" {
					continue // explicit -index="" on command line
				}
				stor, err := storeFromFlag(storeURL)
				if err != nil {
					command.Errorf("failed to publish testimony (%q) to %q: %s", man.Path, storeURL, err)
					continue
				}
				tkey, err := stor.PutTestimony(testimony)
				if err != nil {
					command.Errorf("failed to publish testimony (%q) to %q: %s", man.Path, storeURL, err)
					continue
				}
				stored = true
				command.V(2).Infof("published testimony (%q) to %q; key: %v", man.Path, storeURL, tkey)
			}
			if stored {
				command.V(1).Infof("%q testimony published", man.Path)
			}
		}
	}

	return nil
}

import (
	"encoding/json"
	"fmt"
	"io"
	"log"
	"os"


	"golang.org/x/crypto/ssh"

	"src.d10.dev/command"
	"src.d10.dev/hancock/model"
)

func init() {
................................................................................
	// defaults
	cfgTop := cfg.Section("")
	cfgTestimony := cfg.Section("testimony")

	defaultStore := cfgTestimony.Key("store").MustString(cfgTop.Key("store").String())

	// define args
	storeFlag := command.OperationFlagSet.String("store", defaultStore, "URL where testimony is saved/published")
	noopFlag := command.OperationFlagSet.Bool("n", false, "do not save/publish")

	// parse args
	err = command.OperationFlagSet.Parse(command.Args()[1:])
	if err != nil {
		return err
	}

	// validate args
	remote, err := storeFromFlag(*storeFlag)
	if err != nil {
		return err
	}



	defer closeStore() // cleanup; safe to call even if no stores initialized

	// decode input
	dec := json.NewDecoder(os.Stdin)

	// first input, the public key (corresponding to signing private key)
	var authorityEncoded model.Authority
................................................................................
			Authority: authorityEncoded,
			Content:   man.Content,
			Encoded:   rawMan,
			Signature: sig,
		}

		if !*noopFlag {











			tkey, err := remote.PutTestimony(testimony)
			if err != nil {
				command.Errorf("failed to publish testimony (%q) to %q: %s", man.Path, remote, err)
				continue
			}




			command.V(1).Infof("%q testimony key: %s", man.Path, tkey)

		}
	}

	return nil
}