hancock

// expected by `hancock-sign`.
package main

import (
	"fmt"
	"os"
	"path/filepath"

	"time"

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

func init() {
	command.RegisterOperation(command.Operation{
		Handler:     manifestMain,
		Name:        "manifest",
		Syntax:      "manifest [-r] <file or directory> [...]",
		Description: "Creates summaries of a files, suitable for signing.",
	})
}

func manifestMain() error {
	recurseFlag := command.OperationFlagSet.Bool("r", false, "descend into directories, processing all files")

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


















	if len(command.OperationFlagSet.Args()) == 0 {
		return errors.New("Expected <file or directory> parameter.")
	}

	noRecurse := errors.New("no recurse") // prepare for filepath.Walk

	timestamp := time.Now().Unix()
................................................................................

			manifest, err := model.NewFileManifest(filepath)
			if err != nil {
				command.Error(err) // log error
				return nil         // continue walk
			}
			manifest.Time = timestamp // give all manifests the same timestamp


			// encoded manifest to stdout
			fmt.Println(mustEncode(manifest))

			return nil // continue walk
		})
		if err == noRecurse {

// expected by `hancock-sign`.
package main

import (
	"fmt"
	"os"
	"path/filepath"
	"strings"
	"time"

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

func init() {
	command.RegisterOperation(command.Operation{
		Handler:     manifestMain,
		Name:        "manifest",
		Syntax:      "manifest [-r] [-role=<role>] <file or directory> [...]",
		Description: "Creates summaries of a files, suitable for signing.",
	})
}

func manifestMain() error {
	recurseFlag := command.OperationFlagSet.Bool("r", false, "descend into directories, processing all files")
	roleFlag := command.OperationFlagSet.String("role", "", "indicates relationship to source (i.e. author or auditor)")
	err := command.OperationFlagSet.Parse(command.Args()[1:])
	if err != nil {
		return err
	}

	// validate flags
	var role model.Role
	if *roleFlag != "" {
		roleNames := make([]string, 0, model.RoleCount)
		for i := 1; i < model.RoleCount; i++ {
			if strings.EqualFold(*roleFlag, model.Role(i).String()) {
				role = model.Role(i)
				break
			}
			roleNames = append(roleNames, model.Role(i).String())
		}
		if role == model.RoleUnknown {

			return fmt.Errorf("Unexpected role (%q).  Supported roles: %s.  Omit -role flag for %q.", *roleFlag, strings.Join(roleNames, ", "), model.RoleUnknown.String())
		}
	}

	if len(command.OperationFlagSet.Args()) == 0 {
		return errors.New("Expected <file or directory> parameter.")
	}

	noRecurse := errors.New("no recurse") // prepare for filepath.Walk

	timestamp := time.Now().Unix()
................................................................................

			manifest, err := model.NewFileManifest(filepath)
			if err != nil {
				command.Error(err) // log error
				return nil         // continue walk
			}
			manifest.Time = timestamp // give all manifests the same timestamp
			manifest.Role = role

			// encoded manifest to stdout
			fmt.Println(mustEncode(manifest))

			return nil // continue walk
		})
		if err == noRecurse {

							//	continue
							//}

							if command.V(1) {
								t := time.Unix(manifest.Time, 0)
								// TODO(dnc) format time in friendly "days ago" syntax
								if filepath != manifest.Path {
									command.Infof("%q authenticated by %q as %q on %s", filepath, authority.name, manifest.Path, t.Format(time.RFC850))
								} else {
									command.Infof("%q authenticated by %q on %s", filepath, authority.name, t.Format(time.RFC850))
								}
							}
							verified = true // TODO(dnc): consider a count of weighted authorities, rather than simple verified or not
						default:
							command.V(2).Info(filepath, u.String(), resp.Status)
							continue
						} // end ipfs status

							//	continue
							//}

							if command.V(1) {
								t := time.Unix(manifest.Time, 0)
								// TODO(dnc) format time in friendly "days ago" syntax
								if filepath != manifest.Path {
									command.Infof("%q authenticated by %s (%q) as %q on %s", filepath, manifest.Role, authority.name, manifest.Path, t.Format(time.RFC850))
								} else {
									command.Infof("%q authenticated by %s (%q) on %s", filepath, manifest.Role, authority.name, t.Format(time.RFC850))
								}
							}
							verified = true // TODO(dnc): consider a count of weighted authorities, rather than simple verified or not
						default:
							command.V(2).Info(filepath, u.String(), resp.Status)
							continue
						} // end ipfs status

import (
	"encoding/json"
	"io"
	"os"
	"time"
)




















type FileManifest struct {

	Path string `json:"path,omitempty"`

	Time int64  `json:"timestamp"`
	CID  CID    `json:"cid"`
}

func NewFileManifest(path string) (*FileManifest, error) {
	f, err := os.Open(path)
	if err != nil {
		return nil, err
	}

import (
	"encoding/json"
	"io"
	"os"
	"time"
)

// Role is the relationship the testifier has to the source.
type Role int

const (
	RoleUnknown Role = iota // zero

	// Author role indicates testimony provided by the author of the source.
	Author
	// Auditor role indicates testimony by a third party who has inspected the source.
	Auditor
	// Dependent role indicates testimony by a developer who includes the source as a dependency.
	Dependent

	// How many roles?
	RoleCount int = iota
)

//go:generate stringer -type=Role

type FileManifest struct {
	CID  CID    `json:"cid"`
	Path string `json:"path,omitempty"`
	Role Role   `json:"role"`
	Time int64  `json:"timestamp"`

}

func NewFileManifest(path string) (*FileManifest, error) {
	f, err := os.Open(path)
	if err != nil {
		return nil, err
	}