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()
}
// Summary prints a summary of the diff between two values to stdout.
func Summary(value1, value2 types.Value) {
if datas.IsCommitType(value1.Type()) && datas.IsCommitType(value2.Type()) {
fmt.Println("Comparing commit values")
value1 = value1.(types.Struct).Get(datas.ValueField)
value2 = value2.(types.Struct).Get(datas.ValueField)
}
var singular, plural string
if value1.Type().Kind() == value2.Type().Kind() {
switch value1.Type().Kind() {
case types.StructKind:
singular = "field"
plural = "fields"
case types.MapKind:
singular = "entry"
plural = "entries"
default:
singular = "value"
plural = "values"
}
}
// waitChan := make(chan struct{})
ch := make(chan diffSummaryProgress)
go func() {
diffSummary(ch, value1, value2)
close(ch)
}()
acc := diffSummaryProgress{}
for p := range ch {
acc.Adds += p.Adds
acc.Removes += p.Removes
acc.Changes += p.Changes
acc.NewSize += p.NewSize
acc.OldSize += p.OldSize
if status.WillPrint() {
formatStatus(acc, singular, plural)
}
}
formatStatus(acc, singular, plural)
status.Done()
}
func main() {
flag.Usage = func() {
fmt.Fprintf(os.Stderr, "Fetches a URL into a noms blob\n\nUsage: %s <dataset> <url>:\n", os.Args[0])
flag.PrintDefaults()
}
spec.RegisterDatabaseFlags()
flag.Parse()
if flag.NArg() != 2 {
util.CheckError(errors.New("expected dataset and url arguments"))
}
ds, err := spec.GetDataset(flag.Arg(0))
util.CheckError(err)
defer ds.Database().Close()
url := flag.Arg(1)
start = time.Now()
var pr io.Reader
if strings.HasPrefix(url, "http") {
resp, err := http.Get(url)
if err != nil {
fmt.Fprintf(os.Stderr, "Could not fetch url %s, error: %s\n", url, err)
return
}
switch resp.StatusCode / 100 {
case 4, 5:
fmt.Fprintf(os.Stderr, "Could not fetch url %s, error: %d (%s)\n", url, resp.StatusCode, resp.Status)
return
}
pr = progressreader.New(resp.Body, getStatusPrinter(resp.ContentLength))
} else {
// assume it's a file
f, err := os.Open(url)
if err != nil {
fmt.Fprintf(os.Stderr, "Invalid URL %s - does not start with 'http' and isn't local file either. fopen error: %s", url, err)
return
}
s, err := f.Stat()
if err != nil {
fmt.Fprintf(os.Stderr, "Could not stat file %s: %s", url, err)
return
}
pr = progressreader.New(f, getStatusPrinter(s.Size()))
}
b := types.NewBlob(pr)
ds, err = ds.Commit(b)
if err != nil {
d.Chk.True(datas.ErrMergeNeeded == err)
fmt.Fprintf(os.Stderr, "Could not commit, optimistic concurrency failed.")
return
}
status.Done()
fmt.Println("Done")
}
func main() {
comment := flag.String("comment", "", "comment to add to commit's meta data")
spec.RegisterDatabaseFlags(flag.CommandLine)
flag.Usage = func() {
fmt.Fprintf(os.Stderr, "Fetches a URL (or file) into a noms blob\n\nUsage: %s <url-or-local-path> <dataset>:\n", os.Args[0])
flag.PrintDefaults()
}
flag.Parse(true)
if flag.NArg() != 2 {
d.CheckErrorNoUsage(errors.New("expected dataset and url arguments"))
}
ds, err := spec.GetDataset(flag.Arg(1))
d.CheckErrorNoUsage(err)
defer ds.Database().Close()
url := flag.Arg(0)
fileOrUrl := "file"
start = time.Now()
var pr io.Reader
if strings.HasPrefix(url, "http") {
resp, err := http.Get(url)
if err != nil {
fmt.Fprintf(os.Stderr, "Could not fetch url %s, error: %s\n", url, err)
return
}
switch resp.StatusCode / 100 {
case 4, 5:
fmt.Fprintf(os.Stderr, "Could not fetch url %s, error: %d (%s)\n", url, resp.StatusCode, resp.Status)
return
}
pr = progressreader.New(resp.Body, getStatusPrinter(resp.ContentLength))
fileOrUrl = "url"
} else {
// assume it's a file
f, err := os.Open(url)
if err != nil {
fmt.Fprintf(os.Stderr, "Invalid URL %s - does not start with 'http' and isn't local file either. fopen error: %s", url, err)
return
}
s, err := f.Stat()
if err != nil {
fmt.Fprintf(os.Stderr, "Could not stat file %s: %s", url, err)
return
}
pr = progressreader.New(f, getStatusPrinter(s.Size()))
fileOrUrl = "file"
}
b := types.NewStreamingBlob(pr, ds.Database())
mi := metaInfoForCommit(fileOrUrl, url, *comment)
ds, err = ds.Commit(b, dataset.CommitOptions{Meta: mi})
if err != nil {
d.Chk.Equal(datas.ErrMergeNeeded, err)
fmt.Fprintf(os.Stderr, "Could not commit, optimistic concurrency failed.")
return
}
status.Done()
fmt.Println("Done")
}
func main() {
comment := flag.String("comment", "", "comment to add to commit's meta data")
stdin := flag.Bool("stdin", false, "read blob from stdin")
spec.RegisterDatabaseFlags(flag.CommandLine)
flag.Usage = func() {
fmt.Fprintf(os.Stderr, "Fetches a URL, file, or stdin into a noms blob\n\nUsage: %s [--stdin?] [url-or-local-path?] [dataset]\n", os.Args[0])
flag.PrintDefaults()
}
flag.Parse(true)
if !(*stdin && flag.NArg() == 1) && flag.NArg() != 2 {
flag.Usage()
os.Exit(-1)
}
start = time.Now()
ds, err := spec.GetDataset(flag.Arg(flag.NArg() - 1))
d.CheckErrorNoUsage(err)
defer ds.Database().Close()
var r io.Reader
var contentLength int64
var sourceType, sourceVal string
if *stdin {
r = os.Stdin
contentLength = -1
} else if url := flag.Arg(0); strings.HasPrefix(url, "http") {
resp, err := http.Get(url)
if err != nil {
fmt.Fprintf(os.Stderr, "Could not fetch url %s, error: %s\n", url, err)
return
}
switch resp.StatusCode / 100 {
case 4, 5:
fmt.Fprintf(os.Stderr, "Could not fetch url %s, error: %d (%s)\n", url, resp.StatusCode, resp.Status)
return
}
r = resp.Body
contentLength = resp.ContentLength
sourceType, sourceVal = "url", url
} else {
// assume it's a file
f, err := os.Open(url)
if err != nil {
fmt.Fprintf(os.Stderr, "Invalid URL %s - does not start with 'http' and isn't local file either. fopen error: %s", url, err)
return
}
s, err := f.Stat()
if err != nil {
fmt.Fprintf(os.Stderr, "Could not stat file %s: %s", url, err)
return
}
r = f
contentLength = s.Size()
sourceType, sourceVal = "file", url
}
pr := progressreader.New(r, getStatusPrinter(contentLength))
b := types.NewStreamingBlob(pr, ds.Database())
mi := metaInfoForCommit(sourceType, sourceVal, *comment)
ds, err = ds.Commit(b, dataset.CommitOptions{Meta: mi})
if err != nil {
d.Chk.Equal(datas.ErrMergeNeeded, err)
fmt.Fprintf(os.Stderr, "Could not commit, optimistic concurrency failed.")
return
}
status.Done()
fmt.Println("Done")
}