Example #1
0
func createZipFile(runRoot string, files []string) (string, error) {
	zipFd, err := ioutil.TempFile(runRoot, ".results_zip")
	if err != nil {
		return "", err
	}
	defer zipFd.Close()

	zipPath := zipFd.Name()
	zip := zip.NewWriter(zipFd)
	for _, file := range files {
		f, err := os.Open(path.Join(runRoot, file))
		if err != nil {
			continue
		}
		defer f.Close()
		zf, err := zip.Create(file)
		if err != nil {
			zip.Close()
			return zipPath, err
		}
		if _, err := io.Copy(zf, f); err != nil {
			zip.Close()
			return zipPath, err
		}
	}
	return zipPath, zip.Close()
}
Example #2
0
func boomkat(name string, no_cog bool, no_delete bool) {
	usr, err := user.Current()
	if err != nil {
		log.Fatal(err)
	}

	dirname := path.Base(name)
	dirname = strings.Replace(dirname, "flac_", "", 1)
	dirname = strings.Replace(dirname, "mp3_", "", 1)
	dirname = strings.Replace(dirname, "_", " ", -1)
	dirname = dirname[:len(dirname)-4]
	dirname = strings.TrimRight(dirname, " ")
	path := usr.HomeDir + "/Music/" + dirname

	os.Mkdir(path, 0755)

	zip, err := zip.OpenReader(name)
	if err != nil {
		log.Fatal(err)
	}
	defer zip.Close()

	for _, file_in_zip := range zip.File {
		new_filename := strings.Replace(file_in_zip.Name, "_", " ", -1)
		if new_filename[1] == "-"[0] {
			new_filename = "0" + new_filename
		}
		log.Println(new_filename)
		file_path := path + "/" + new_filename

		file_handler_in_zip, err := file_in_zip.Open()
		if err != nil {
			log.Fatal(err)
		}
		defer file_handler_in_zip.Close()

		file_to_write, err := os.Create(file_path)
		if err != nil {
			log.Fatal(err)
		}
		defer file_to_write.Close()

		_, err = io.Copy(file_to_write, file_handler_in_zip)
		if err != nil {
			log.Fatal(err)
		}
	}
	if !no_delete {
		os.Remove(name)
	}
	if !no_cog {
		cmd := exec.Command("open", path, "-a", "cog")
		err := cmd.Start()
		if err != nil {
			log.Fatal(err)
		}
		err = cmd.Wait()
	}
}
Example #3
0
func Zip(zipFile, directory string) error {

	os.Mkdir(filepath.Dir(zipFile), 0755)

	zip, err := Create(zipFile)
	if err != nil {
		return err
	}
	err = zip.AddDirectory("./", directory)
	if err != nil {
		return err
	}
	err = zip.AddEntry("./.app_store.txt", filepath.Dir(filepath.Dir(zipFile))+"/../source/.app_store.txt")
	if err != nil {
		return err
	}
	err = zip.Close()
	if err != nil {
		return err
	}
	return nil
}
Example #4
0
func streamWorld(w http.ResponseWriter, r *http.Request, worldId string, filename string) {
	w.Header().Add("Content-Type", "application/zip")
	w.Header().Add("Content-Disposition",
		fmt.Sprintf("attachment; filename=%s.zip", filename))

	hexId := bson.ObjectIdHex(worldId)
	url, err := readUrlForServer(hexId)
	if err != nil {
		fmt.Println("no url for world", hexId.Hex(), err)
		http.NotFound(w, r)
	}

	tempPath, err := createTempDir(worldId)
	if err != nil {
		fmt.Println("failed to create tempdir", err)
		http.Error(w, "failed to create tempdir", 500)
	}

	zip := zip.NewWriter(w)
	defer zip.Close()

	// Zip files as they are downloaded
	watcher := NewWatcher(tempPath, 5*time.Second)
	go watcher.Watch()
	var wg sync.WaitGroup
	wg.Add(1)
	go zipFilesAsTheyAppear(tempPath, filename, watcher.C, zip, &wg)

	// start the download
	err = restoreDir(url, tempPath)
	if err != nil {
		fmt.Println("failed to download archive", err)
		http.Error(w, "failed to download archive", 500)
	}

	watcher.Cancel()
	wg.Wait()
}