func main() {
useSHA := flag.String("use-sha", "", "<default>=no hashing, 1=sha1, 256=sha256, 512=sha512, blake=blake2b")
useBH := flag.Bool("use-bh", false, "whether we buzhash the bytes")
flag.Parse(true)
flag.Usage = func() {
fmt.Printf("%s <big-file>\n", os.Args[0])
flag.PrintDefaults()
return
}
if len(flag.Args()) < 1 {
flag.Usage()
return
}
p := flag.Args()[0]
bh := buzhash.NewBuzHash(64 * 8)
f, _ := os.Open(p)
defer f.Close()
t0 := time.Now()
buf := make([]byte, 4*1024)
l := uint64(0)
var h hash.Hash
if *useSHA == "1" {
h = sha1.New()
} else if *useSHA == "256" {
h = sha256.New()
} else if *useSHA == "512" {
h = sha512.New()
} else if *useSHA == "blake" {
h = blake2.NewBlake2B()
}
for {
n, err := f.Read(buf)
l += uint64(n)
if err == io.EOF {
break
}
s := buf[:n]
if h != nil {
h.Write(s)
}
if *useBH {
bh.Write(s)
}
}
t1 := time.Now()
d := t1.Sub(t0)
fmt.Printf("Read %s in %s (%s/s)\n", humanize.Bytes(l), d, humanize.Bytes(uint64(float64(l)/d.Seconds())))
digest := []byte{}
if h != nil {
fmt.Printf("%x\n", h.Sum(digest))
}
}
func main() {
usage := func() {
fmt.Fprintln(os.Stderr, "Usage: noms ui [-host HOST] directory [args...]\n")
fmt.Fprintln(os.Stderr, " args are of the form arg1=val1, arg2=val2, etc. \"ldb:\" values are automatically translated into paths to an HTTP noms database server.\n")
flag.PrintDefaults()
}
flag.Parse(true)
flag.Usage = usage
if len(flag.Args()) == 0 {
usage()
os.Exit(1)
}
uiDir := flag.Arg(0)
qsValues, stores := constructQueryString(flag.Args()[1:])
router := &httprouter.Router{
HandleMethodNotAllowed: true,
NotFound: http.FileServer(http.Dir(uiDir)),
RedirectFixedPath: true,
}
prefix := dsPathPrefix + "/:store"
router.POST(prefix+constants.GetRefsPath, routeToStore(stores, datas.HandleGetRefs))
router.OPTIONS(prefix+constants.GetRefsPath, routeToStore(stores, datas.HandleGetRefs))
router.GET(prefix+constants.RootPath, routeToStore(stores, datas.HandleRootGet))
router.POST(prefix+constants.RootPath, routeToStore(stores, datas.HandleRootPost))
router.OPTIONS(prefix+constants.RootPath, routeToStore(stores, datas.HandleRootGet))
l, err := net.Listen("tcp", fmt.Sprintf("localhost:%d", *portFlag))
d.Chk.NoError(err)
srv := &http.Server{
Handler: http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
router.ServeHTTP(w, req)
}),
}
qs := ""
if len(qsValues) > 0 {
qs = "?" + qsValues.Encode()
}
fmt.Printf("Starting UI %s at http://%s%s\n", uiDir, l.Addr().String(), qs)
log.Fatal(srv.Serve(l))
}
func main() {
flag.Usage = func() {
fmt.Fprintf(os.Stderr, "usage: %s <dataset> <file>\n", os.Args[0])
flag.PrintDefaults()
}
spec.RegisterDatabaseFlags(flag.CommandLine)
flag.Parse(true)
if len(flag.Args()) != 2 {
d.CheckError(errors.New("expected dataset and file flags"))
}
var blob types.Blob
path := flag.Arg(0)
if db, val, err := spec.GetPath(path); err != nil {
d.CheckErrorNoUsage(err)
} else if val == nil {
d.CheckErrorNoUsage(fmt.Errorf("No value at %s", path))
} else if b, ok := val.(types.Blob); !ok {
d.CheckErrorNoUsage(fmt.Errorf("Value at %s is not a blob", path))
} else {
defer db.Close()
blob = b
}
filePath := flag.Arg(1)
if filePath == "" {
d.CheckErrorNoUsage(errors.New("Empty file path"))
}
// Note: overwrites any existing file.
file, err := os.OpenFile(filePath, os.O_WRONLY|os.O_CREATE, 0644)
d.CheckErrorNoUsage(err)
defer file.Close()
expected := humanize.Bytes(blob.Len())
start := time.Now()
progReader := progressreader.New(blob.Reader(), func(seen uint64) {
elapsed := time.Since(start).Seconds()
rate := uint64(float64(seen) / elapsed)
status.Printf("%s of %s written in %ds (%s/s)...", humanize.Bytes(seen), expected, int(elapsed), humanize.Bytes(rate))
})
io.Copy(file, progReader)
status.Done()
}
func main() {
flag.Usage = func() {
fmt.Fprintf(os.Stderr, "usage: %s <url> <dataset>\n", os.Args[0])
flag.PrintDefaults()
}
spec.RegisterDatabaseFlags(flag.CommandLine)
flag.Parse(true)
if len(flag.Args()) != 2 {
d.CheckError(errors.New("expected url and dataset flags"))
}
ds, err := spec.GetDataset(flag.Arg(1))
d.CheckError(err)
url := flag.Arg(0)
if url == "" {
flag.Usage()
}
res, err := http.Get(url)
if err != nil {
log.Fatalf("Error fetching %s: %+v\n", url, err)
} else if res.StatusCode != 200 {
log.Fatalf("Error fetching %s: %s\n", url, res.Status)
}
defer res.Body.Close()
var jsonObject interface{}
err = json.NewDecoder(res.Body).Decode(&jsonObject)
if err != nil {
log.Fatalln("Error decoding JSON: ", err)
}
_, err = ds.CommitValue(jsontonoms.NomsValueFromDecodedJSON(jsonObject, true))
d.PanicIfError(err)
ds.Database().Close()
}
func main() {
flag.Usage = usage
flag.Parse(false)
args := flag.Args()
if len(args) < 1 {
usage()
return
}
if args[0] == "help" {
help(args[1:])
return
}
for _, cmd := range commands {
if cmd.Name() == args[0] {
flags := cmd.Flags()
flags.Usage = cmd.Usage
flags.Parse(true, args[1:])
args = flags.Args()
if cmd.Nargs != 0 && len(args) < cmd.Nargs {
cmd.Usage()
}
exitCode := cmd.Run(args)
if exitCode != 0 {
os.Exit(exitCode)
}
return
}
}
fmt.Fprintf(os.Stderr, "noms: unknown command %q\n", args[0])
usage()
}