func main() {
downloadTarget := "http://releases.ubuntu.com/14.04.2/ubuntu-14.04.2-desktop-amd64.iso"
resp, err := http.Get(downloadTarget)
if err != nil {
log.Fatal(err)
}
size := resp.ContentLength
progressR := &ioprogress.Reader{
Reader: resp.Body,
Size: size,
DrawInterval: time.Millisecond,
DrawFunc: func(progress, total int64) error {
if progress == total {
fmt.Printf("\rDownloading: %s%10s", ioprogress.DrawTextFormatBytes(size, size), "")
return nil
}
fmt.Printf("\rDownloading: %s%10s", ioprogress.DrawTextFormatBytes(progress, total), "")
return nil
},
}
file, err := open("ubuntu.iso")
if err != nil {
log.Fatal(err)
}
if _, err = io.Copy(file, progressR); err != nil {
log.Fatal(err)
}
}
func downloadReleaseAsset(r *github.ReleaseAsset, newName *string, newPath *string) {
var outDir string
if newPath == nil {
outDir = binDir()
} else {
outDir = *newPath
}
downloadUrlString := *r.BrowserDownloadURL
log.Infof("Downloading release asset: %s", downloadUrlString)
log.Infof("Copying to: %s", outDir)
downloadUrl, err := url.Parse(downloadUrlString)
if err != nil {
log.Fatalf("Error: Could not parse URL: %v", err)
}
var fileName string
if newName == nil {
_, fileName = path.Split(downloadUrl.Path)
} else {
fileName = *newName
}
outName := outDir + "/" + fileName
out, err := os.Create(outName)
if err != nil {
log.Fatalf("Error: Could not create local file: %v", err)
}
defer out.Close()
resp, err := http.Get(downloadUrlString)
if err != nil {
log.Fatalf("Error: Could not get remote file: %v", err)
}
defer resp.Body.Close()
bar := ioprogress.DrawTextFormatBar(20)
progressFunc := ioprogress.DrawTerminalf(os.Stdout, func(progress, total int64) string {
return fmt.Sprintf("%s %s %20s", fileName, bar(progress, total), ioprogress.DrawTextFormatBytes(progress, total))
})
progress := &ioprogress.Reader{
Reader: resp.Body,
Size: resp.ContentLength,
DrawInterval: time.Millisecond,
DrawFunc: progressFunc,
}
_, err = io.Copy(out, progress)
if err != nil {
log.Fatalf("Error: Could not copy local file: %v", err)
}
err = os.Chmod(outName, 0755)
if err != nil {
log.Fatalf("Error: Could not make %s executable. Try with (sudo)?", outName)
}
}
func downloadFile(token, fileId, filename string, fileSize int64, prefix string, dryrun bool) {
fmt.Fprintf(os.Stderr, "%s%s\n", prefix, filename)
if dryrun {
return
}
if _, err := os.Stat(filename); err == nil {
fmt.Fprintf(os.Stderr, "%s%s already exists!\n", prefix, filename)
return
}
out, err := os.Create(filename + ".tmp")
defer out.Close()
url := basespaceApiUrl + "/files/" + fileId + "/content?access_token="
resp, err := http.Get(url + token)
if err != nil {
fmt.Fprintf(os.Stderr, "Error downloading URL: %s\n\n", url)
os.Exit(1)
}
defer resp.Body.Close()
bar := ioprogress.DrawTextFormatBar(20)
fmtfunc := func(progress, total int64) string {
return fmt.Sprintf(
"%s%s %s",
prefix,
bar(progress, total),
ioprogress.DrawTextFormatBytes(progress, total))
}
progressR := &ioprogress.Reader{
Reader: resp.Body,
Size: fileSize,
DrawFunc: ioprogress.DrawTerminalf(os.Stderr, fmtfunc),
}
n, err := io.Copy(out, progressR)
if err != nil {
os.Remove(filename + ".tmp")
log.Fatal(err, n)
}
os.Rename(filename+".tmp", filename)
}
func (i *GoInstaller) progressFormat(progress, total int64) string {
return fmt.Sprintf(" %s", ioprogress.DrawTextFormatBytes(progress, total))
}
// Run invokes the CLI with the given arguments. The first argument is always
// the name of the application. This method slices accordingly.
func (cli *CLI) Run(args []string) int {
// Initialize the logger to start (overridden later if debug is given)
cli.initLogger(os.Getenv("ATLAS_LOG"))
var debug, version bool
var archiveOpts archive.ArchiveOpts
var uploadOpts UploadOpts
flags := flag.NewFlagSet(Name, flag.ContinueOnError)
flags.SetOutput(cli.errStream)
flags.Usage = func() {
fmt.Fprintf(cli.errStream, usage, Name)
}
flags.BoolVar(&archiveOpts.VCS, "vcs", false,
"use VCS to detect which files to upload")
flags.StringVar(&uploadOpts.URL, "address", "",
"Atlas server address")
flags.StringVar(&uploadOpts.Token, "token", "",
"Atlas API token")
flags.Var((*FlagSliceVar)(&archiveOpts.Exclude), "exclude",
"files/folders to exclude")
flags.Var((*FlagSliceVar)(&archiveOpts.Include), "include",
"files/folders to include")
flags.Var((*FlagMetadataVar)(&uploadOpts.Metadata), "metadata",
"arbitrary metadata to pass along with the request")
flags.BoolVar(&debug, "debug", false,
"turn on debug output")
flags.BoolVar(&version, "version", false,
"display the version")
// Parse all the flags
if err := flags.Parse(args[1:]); err != nil {
return ExitCodeParseFlagsError
}
// Turn on debug mode if requested
if debug {
levelFilter.SetMinLevel(logutils.LogLevel("DEBUG"))
}
// Version
if version {
fmt.Fprintf(cli.errStream, "%s v%s\n", Name, Version)
return ExitCodeOK
}
// Get the parsed arguments (the ones left over after all the flags have been
// parsed)
parsedArgs := flags.Args()
if len(parsedArgs) != 2 {
fmt.Fprintf(cli.errStream, "cli: must specify two arguments - slug, path\n")
flags.Usage()
return ExitCodeBadArgs
}
// Get the name of the app and the path to archive
slug, path := parsedArgs[0], parsedArgs[1]
uploadOpts.Slug = slug
// Get the archive reader
r, err := archive.CreateArchive(path, &archiveOpts)
if err != nil {
fmt.Fprintf(cli.errStream, "error archiving: %s\n", err)
return ExitCodeArchiveError
}
defer r.Close()
// Put a progress bar around the reader
pr := &ioprogress.Reader{
Reader: r,
Size: r.Size,
DrawFunc: ioprogress.DrawTerminalf(os.Stdout, func(p, t int64) string {
return fmt.Sprintf(
"Uploading %s: %s",
slug,
ioprogress.DrawTextFormatBytes(p, t))
}),
}
// Start the upload
doneCh, uploadErrCh, err := Upload(pr, r.Size, &uploadOpts)
if err != nil {
fmt.Fprintf(cli.errStream, "error starting upload: %s\n", err)
return ExitCodeUploadError
}
select {
case err := <-uploadErrCh:
fmt.Fprintf(cli.errStream, "error uploading: %s\n", err)
return ExitCodeUploadError
case version := <-doneCh:
fmt.Printf("Uploaded %s v%d\n", slug, version)
}
return ExitCodeOK
}
func main() {
log.SetFlags(0)
log.SetPrefix("ERROR: ")
flag.Usage = func() {
fmt.Fprintf(os.Stderr, usage)
}
input := flag.String("in", "", "Input file")
output := flag.String("out", "", "Output file")
verbose := flag.Bool("v", false, "Verbose mode")
stream := flag.Bool("stream", true, "Streaming mode")
flag.Parse()
if *input == "" || *output == "" {
fmt.Println("Usage:")
flag.PrintDefaults()
os.Exit(1)
}
inFile, err := os.Open(*input)
if err != nil {
log.Fatal(err)
}
defer inFile.Close()
stat, err := inFile.Stat()
if err != nil {
log.Fatal(err)
}
var inFileRdr io.Reader
if *verbose {
inFileRdr = &ioprogress.Reader{
Reader: inFile,
Size: stat.Size(),
DrawInterval: time.Microsecond,
DrawFunc: ioprogress.DrawTerminalf(os.Stdout, func(p, t int64) string {
return ioprogress.DrawTextFormatBytes(p, t)
}),
}
} else {
inFileRdr = inFile
}
outFile, err := os.Create(*output)
if err != nil {
log.Fatal(err)
}
defer outFile.Close()
inExt := fileExtension(*input)
outExt := fileExtension(*output)
if inExt == outExt {
log.Fatal("No conversion necessary. Input and output formats are identical.")
}
var inFormat, outFormat rdf.Format
switch inExt {
case "nt":
inFormat = rdf.NTriples
case "nq":
inFormat = rdf.NQuads
case "ttl":
inFormat = rdf.Turtle
case "xml", "rdf", "rdfxml":
inFormat = rdf.RDFXML
case "":
log.Fatal("Unknown file format. No file extension on input file.")
default:
log.Fatalf("Unsopported file exension on input file: %s", inFile.Name())
}
switch outExt {
case "nt":
outFormat = rdf.NTriples
case "nq":
// No other quad-formats supported ATM
log.Fatal("Serializing to N-Quads currently not supported.")
case "ttl":
outFormat = rdf.Turtle
case "":
log.Fatal("Unknown file format. No file extension on output file.")
default:
log.Fatalf("Unsopported file exension on output file: %s", outFile.Name())
}
t0 := time.Now()
n := tripleToTriple(inFileRdr, outFile, inFormat, outFormat, *stream)
if *verbose {
fmt.Printf("Done. Converted %d triples in %v.\n", n, time.Now().Sub(t0))
}
}