Exemplo n.º 1
0
func init() {
	Env = "testing"
	err := os.MkdirAll("test", os.ModePerm|os.ModeDir)
	if err != nil {
		panic(err)
	}

	// If the tar file exists don't create it.
	_, err = os.Stat(uploadPath)
	if err == nil {
		return
	}

	// Create a gzipped tar file in test.
	file, err := os.Create(filepath.Join("test", "upload.tar.gz"))
	if err != nil {
		panic(err)
	}
	defer file.Close()

	contents, err := tar.Tar(".", nil)
	if err != nil {
		panic(err)
	}

	_, err = io.Copy(file, contents)
	if err != nil {
		panic(err)
	}
}
Exemplo n.º 2
0
// Upload sends the paths contents to the service compressed.
func (watcher *Watcher) Upload() error {
	var (
		err  error
		file *os.File
	)
	path := watcher.uploadPath()
	i := 0

	ignores, err := db.GetIgnores(watcher.Path)
	if err != nil {
		return watcher.wrapErr(err)
	}

	if watcher.Path != "" {
		upload, err := tar.Tar(watcher.Path, ignores)
		if err != nil {
			return watcher.wrapErr(err)
		}

		// Write the tgz file to read from.
		file, err = os.Create(path)
		if err != nil {
			return watcher.wrapErr(err)
		}
		defer os.RemoveAll(path)
		defer file.Close()

		// Copy the contents to the file.
		_, err = io.Copy(file, upload)
		if err != nil {
			return watcher.wrapErr(err)
		}
	}

	for i < 1000 {
		// If we've failed once, wait a bit.
		if err != nil {
			<-time.After(time.Millisecond * 50)
		}

		// Make sure we're at the beginning of the file.
		if watcher.Path != "" {
			_, err = file.Seek(0, os.SEEK_SET)
			if err != nil {
				return watcher.wrapErr(err)
			}
		}

		// Attempt to upload the file to the services satellite.
		err = delancey.Upload(watcher.Service.SatelliteAddr, watcher.Service.Name, file)
		if err == nil {
			return nil
		}

		i++
	}

	return watcher.wrapErr(err)
}
Exemplo n.º 3
0
// UploadSSH sends the .ssh directory to the container
func UploadSSH(container *schemas.Container, path string) error {
	contents, err := tar.Tar(path, []string{})
	if err != nil {
		return err
	}

	addr := net.JoinHostPort(container.Address, config.DelanceyProdPort)
	req, err := http.NewRequest("PUT", "http://"+addr+"/ssh", contents)
	if err != nil {
		return err
	}

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		return err
	}
	defer res.Body.Close()

	resData := new(requests.Res)
	decoder := json.NewDecoder(res.Body)
	err = decoder.Decode(resData)
	if err != nil {
		return err
	}

	if resData.Status != requests.StatusSuccess {
		// If the error matches return var.
		if resData.Error() == ErrNotInUse.Error() {
			return ErrNotInUse
		}

		return resData
	}

	return nil
}
Exemplo n.º 4
0
// GET /, Retrieve the containers code.
func indexHandler(rw http.ResponseWriter, req *http.Request) {
	var (
		contents io.Reader
		err      error
	)
	empty, gzipWriter, tarWriter := tar.NewTarGZ()
	tarWriter.Close()
	gzipWriter.Close()

	// Require a container to exist.
	if currentContainer == nil {
		renderer.JSON(rw, http.StatusBadRequest, map[string]string{
			"status": requests.StatusFailed,
			"error":  delancey.ErrNotInUse.Error(),
		})
		return
	}

	// Tar the contents of the container.
	contents, err = tar.Tar(currentContainer.RemotePath, []string{})
	if err != nil && !os.IsNotExist(err) {
		renderer.JSON(rw, http.StatusInternalServerError, map[string]string{
			"status": requests.StatusFailed,
			"error":  err.Error(),
		})
		return
	}

	// If the path didn't exist, just provide an empty targz stream.
	if err != nil {
		contents = empty
	}

	rw.WriteHeader(http.StatusOK)
	io.Copy(rw, contents)
}