func TestTraceSetToFile(t *testing.T) {
stdOut := bytes.NewBuffer([]byte{})
trace.SetStdout(stdOut)
fileutils.TempFile("trace_test", func(file *os.File, err error) {
assert.NoError(t, err)
file.Write([]byte("pre-existing content"))
os.Setenv(trace.CF_TRACE, file.Name())
logger := trace.NewLogger()
logger.Print("hello world")
file.Seek(0, os.SEEK_SET)
result, err := ioutil.ReadAll(file)
assert.NoError(t, err)
byteString := string(result)
assert.Contains(t, byteString, "pre-existing content")
assert.Contains(t, byteString, "hello world")
result, _ = ioutil.ReadAll(stdOut)
assert.Equal(t, string(result), "")
})
}
func (repo CloudControllerApplicationBitsRepository) uploadBits(appGuid string, zipFile *os.File, presentResourcesJson []byte) (apiResponse net.ApiResponse) {
url := fmt.Sprintf("%s/v2/apps/%s/bits", repo.config.ApiEndpoint(), appGuid)
fileutils.TempFile("requests", func(requestFile *os.File, err error) {
if err != nil {
apiResponse = net.NewApiResponseWithError("Error creating tmp file: %s", err)
return
}
boundary, err := repo.writeUploadBody(zipFile, requestFile, presentResourcesJson)
if err != nil {
apiResponse = net.NewApiResponseWithError("Error writing to tmp file: %s", err)
return
}
var request *net.Request
request, apiResponse = repo.gateway.NewRequest("PUT", url, repo.config.AccessToken(), requestFile)
if apiResponse.IsNotSuccessful() {
return
}
contentType := fmt.Sprintf("multipart/form-data; boundary=%s", boundary)
request.HttpReq.Header.Set("Content-Type", contentType)
response := &Resource{}
_, apiResponse = repo.gateway.PerformPollingRequestForJSONResponse(request, response, 5*time.Minute)
if apiResponse.IsNotSuccessful() {
return
}
})
return
}
func (repo CloudControllerBuildpackBitsRepository) uploadBits(buildpack cf.Buildpack, zipFile *os.File) (apiResponse net.ApiResponse) {
url := fmt.Sprintf("%s/v2/buildpacks/%s/bits", repo.config.Target, buildpack.Guid)
fileutils.TempFile("requests", func(requestFile *os.File, err error) {
if err != nil {
apiResponse = net.NewApiResponseWithMessage(err.Error())
return
}
boundary, err := repo.writeUploadBody(zipFile, requestFile)
if err != nil {
apiResponse = net.NewApiResponseWithError("Error creating upload", err)
return
}
request, apiResponse := repo.gateway.NewRequest("PUT", url, repo.config.AccessToken, requestFile)
contentType := fmt.Sprintf("multipart/form-data; boundary=%s", boundary)
request.HttpReq.Header.Set("Content-Type", contentType)
if apiResponse.IsNotSuccessful() {
return
}
apiResponse = repo.gateway.PerformRequest(request)
})
return
}
func (repo CloudControllerBuildpackBitsRepository) downloadBuildpack(url string, cb func(*os.File, error)) {
fileutils.TempFile("buildpack-download", func(tempfile *os.File, err error) {
if err != nil {
cb(nil, err)
return
}
var certPool *x509.CertPool
if len(repo.TrustedCerts) > 0 {
certPool = x509.NewCertPool()
for _, tlsCert := range repo.TrustedCerts {
cert, _ := x509.ParseCertificate(tlsCert.Certificate[0])
certPool.AddCert(cert)
}
}
client := &http.Client{
Transport: &http.Transport{
TLSClientConfig: &tls.Config{RootCAs: certPool},
Proxy: http.ProxyFromEnvironment,
},
}
response, err := client.Get(url)
if err != nil {
cb(nil, err)
return
}
io.Copy(tempfile, response.Body)
tempfile.Seek(0, 0)
cb(tempfile, nil)
})
}
func TestZipWithInvalidFile(t *testing.T) {
fileutils.TempFile("zip_test", func(zipFile *os.File, err error) {
zipper := ApplicationZipper{}
err = zipper.Zip("/a/bogus/directory", zipFile)
assert.Error(t, err)
assert.Contains(t, err.Error(), "open /a/bogus/directory")
})
}
func TestZipWithEmptyDir(t *testing.T) {
fileutils.TempFile("zip_test", func(zipFile *os.File, err error) {
fileutils.TempDir("zip_test", func(emptyDir string, err error) {
zipper := ApplicationZipper{}
err = zipper.Zip(emptyDir, zipFile)
assert.Error(t, err)
assert.Equal(t, err.Error(), "Directory is empty")
})
})
}
func TestZipWithJarFile(t *testing.T) {
fileutils.TempFile("zip_test", func(zipFile *os.File, err error) {
dir, err := os.Getwd()
assert.NoError(t, err)
zipper := ApplicationZipper{}
err = zipper.Zip(filepath.Join(dir, "../fixtures/application.jar"), zipFile)
assert.NoError(t, err)
assert.Equal(t, fileToString(t, zipFile), "This is an application jar file\n")
})
}
func TestZipWithDirectory(t *testing.T) {
fileutils.TempFile("zip_test", func(zipFile *os.File, err error) {
workingDir, err := os.Getwd()
assert.NoError(t, err)
dir := filepath.Join(workingDir, "../fixtures/zip/")
err = os.Chmod(filepath.Join(dir, "subDir/bar.txt"), 0666)
assert.NoError(t, err)
zipper := ApplicationZipper{}
err = zipper.Zip(dir, zipFile)
assert.NoError(t, err)
offset, err := zipFile.Seek(0, os.SEEK_CUR)
assert.NoError(t, err)
assert.Equal(t, offset, 0)
fileStat, err := zipFile.Stat()
assert.NoError(t, err)
reader, err := zip.NewReader(zipFile, fileStat.Size())
assert.NoError(t, err)
readFileInZip := func(index int) (string, string) {
buf := &bytes.Buffer{}
file := reader.File[index]
fReader, err := file.Open()
_, err = io.Copy(buf, fReader)
assert.NoError(t, err)
return file.Name, string(buf.Bytes())
}
assert.Equal(t, len(reader.File), 3)
name, contents := readFileInZip(0)
assert.Equal(t, name, "foo.txt")
assert.Equal(t, contents, "This is a simple text file.")
name, contents = readFileInZip(1)
assert.Equal(t, name, "subDir/bar.txt")
assert.Equal(t, contents, "I am in a subdirectory.")
assert.Equal(t, reader.File[1].FileInfo().Mode(), uint32(0666))
name, contents = readFileInZip(2)
assert.Equal(t, name, "subDir/otherDir/file.txt")
assert.Equal(t, contents, "This file should be present.")
})
}
func (repo CloudControllerBuildpackBitsRepository) UploadBuildpack(buildpack models.Buildpack, buildpackLocation string) (apiErr error) {
fileutils.TempFile("buildpack-upload", func(zipFileToUpload *os.File, err error) {
if err != nil {
apiErr = errors.NewWithError("Couldn't create temp file for upload", err)
return
}
var buildpackFileName string
if isWebURL(buildpackLocation) {
buildpackFileName = path.Base(buildpackLocation)
repo.downloadBuildpack(buildpackLocation, func(downloadFile *os.File, downloadErr error) {
if downloadErr != nil {
err = downloadErr
return
}
err = normalizeBuildpackArchive(downloadFile, zipFileToUpload)
})
} else {
buildpackFileName = filepath.Base(buildpackLocation)
stats, err := os.Stat(buildpackLocation)
if err != nil {
apiErr = errors.NewWithError("Error opening buildpack file", err)
return
}
if stats.IsDir() {
err = repo.zipper.Zip(buildpackLocation, zipFileToUpload)
} else {
specifiedFile, err := os.Open(buildpackLocation)
if err != nil {
apiErr = errors.NewWithError("Couldn't open buildpack file", err)
return
}
err = normalizeBuildpackArchive(specifiedFile, zipFileToUpload)
}
}
if err != nil {
apiErr = errors.NewWithError("Couldn't write zip file", err)
return
}
apiErr = repo.uploadBits(buildpack, zipFileToUpload, buildpackFileName)
})
return
}
func (repo CloudControllerApplicationBitsRepository) UploadApp(appGuid string, appDir string, cb func(path string, zipSize, fileCount uint64)) (apiResponse net.ApiResponse) {
fileutils.TempDir("apps", func(uploadDir string, err error) {
if err != nil {
apiResponse = net.NewApiResponseWithMessage(err.Error())
return
}
var presentResourcesJson []byte
repo.sourceDir(appDir, func(sourceDir string, sourceErr error) {
if sourceErr != nil {
err = sourceErr
return
}
presentResourcesJson, err = repo.copyUploadableFiles(sourceDir, uploadDir)
})
if err != nil {
apiResponse = net.NewApiResponseWithMessage("%s", err)
return
}
fileutils.TempFile("uploads", func(zipFile *os.File, err error) {
if err != nil {
apiResponse = net.NewApiResponseWithMessage("%s", err.Error())
return
}
err = repo.zipper.Zip(uploadDir, zipFile)
if err != nil {
apiResponse = net.NewApiResponseWithError("Error zipping application", err)
return
}
stat, err := zipFile.Stat()
if err != nil {
apiResponse = net.NewApiResponseWithError("Error zipping application", err)
return
}
cb(appDir, uint64(stat.Size()), cf.CountFiles(uploadDir))
apiResponse = repo.uploadBits(appGuid, zipFile, presentResourcesJson)
if apiResponse.IsNotSuccessful() {
return
}
})
})
return
}
func (repo CloudControllerBuildpackBitsRepository) UploadBuildpack(buildpack cf.Buildpack, dir string) (apiResponse net.ApiResponse) {
fileutils.TempFile("buildpack", func(zipFile *os.File, err error) {
if err != nil {
apiResponse = net.NewApiResponseWithMessage(err.Error())
return
}
err = repo.zipper.Zip(dir, zipFile)
if err != nil {
apiResponse = net.NewApiResponseWithError("Invalid buildpack", err)
return
}
apiResponse = repo.uploadBits(buildpack, zipFile)
if apiResponse.IsNotSuccessful() {
return
}
})
return
}
func init() {
permissionsToSet = 0467
fileutils.TempFile("permissionedFile", func(file *os.File, err error) {
if err != nil {
panic("could not create tmp file")
}
fileInfo, err := file.Stat()
if err != nil {
panic("could not stat tmp file")
}
expectedPermissionBits = fileInfo.Mode()
if runtime.GOOS != "windows" {
expectedPermissionBits |= permissionsToSet & 0111
}
})
}
func (repo CloudControllerApplicationBitsRepository) UploadApp(app cf.Application, appDir string) (apiResponse net.ApiResponse) {
fileutils.TempDir("apps", func(uploadDir string, err error) {
if err != nil {
apiResponse = net.NewApiResponseWithMessage(err.Error())
return
}
var resourcesJson []byte
repo.sourceDir(appDir, func(sourceDir string, sourceErr error) {
if sourceErr != nil {
err = sourceErr
return
}
resourcesJson, err = repo.copyUploadableFiles(sourceDir, uploadDir)
})
if err != nil {
apiResponse = net.NewApiResponseWithMessage(err.Error())
return
}
fileutils.TempFile("uploads", func(zipFile *os.File, err error) {
if err != nil {
apiResponse = net.NewApiResponseWithMessage(err.Error())
return
}
err = repo.zipper.Zip(uploadDir, zipFile)
if err != nil {
apiResponse = net.NewApiResponseWithError("Error zipping application", err)
return
}
apiResponse = repo.uploadBits(app, zipFile, resourcesJson)
if apiResponse.IsNotSuccessful() {
return
}
})
})
return
}
func TestTraceSetToInvalidFile(t *testing.T) {
stdOut := bytes.NewBuffer([]byte{})
trace.SetStdout(stdOut)
fileutils.TempFile("trace_test", func(file *os.File, err error) {
assert.NoError(t, err)
file.Chmod(0000)
os.Setenv(trace.CF_TRACE, file.Name())
logger := trace.NewLogger()
logger.Print("hello world")
result, _ := ioutil.ReadAll(file)
assert.Equal(t, string(result), "")
result, _ = ioutil.ReadAll(stdOut)
assert.Contains(t, string(result), "hello world")
})
}
func (repo CloudControllerBuildpackBitsRepository) performMultiPartUpload(url string, fieldName string, fileName string, body io.Reader) (apiErr error) {
fileutils.TempFile("requests", func(requestFile *os.File, err error) {
if err != nil {
apiErr = err
return
}
writer := multipart.NewWriter(requestFile)
part, err := writer.CreateFormFile(fieldName, fileName)
if err != nil {
writer.Close()
return
}
_, err = io.Copy(part, body)
writer.Close()
if err != nil {
apiErr = errors.NewWithError("Error creating upload", err)
return
}
var request *net.Request
request, apiErr = repo.gateway.NewRequest("PUT", url, repo.config.AccessToken(), requestFile)
contentType := fmt.Sprintf("multipart/form-data; boundary=%s", writer.Boundary())
request.HttpReq.Header.Set("Content-Type", contentType)
if apiErr != nil {
return
}
apiErr = repo.gateway.PerformRequest(request)
})
return
}
func downloadBuildpack(url string, cb func(*os.File, error)) {
fileutils.TempFile("buildpack-download", func(tempfile *os.File, err error) {
if err != nil {
cb(nil, err)
return
}
client := &http.Client{
Transport: &http.Transport{
TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
Proxy: http.ProxyFromEnvironment,
},
}
response, err := client.Get(url)
if err != nil {
cb(nil, err)
return
}
io.Copy(tempfile, response.Body)
tempfile.Seek(0, 0)
cb(tempfile, nil)
})
}
fileutils.TempFile("zip_test", func(zipFile *os.File, err error) {
workingDir, err := os.Getwd()
Expect(err).NotTo(HaveOccurred())
dir := filepath.Join(workingDir, "../fixtures/zip/")
err = os.Chmod(filepath.Join(dir, "subDir/bar.txt"), 0666)
Expect(err).NotTo(HaveOccurred())
zipper := ApplicationZipper{}
err = zipper.Zip(dir, zipFile)
Expect(err).NotTo(HaveOccurred())
offset, err := zipFile.Seek(0, os.SEEK_CUR)
Expect(err).NotTo(HaveOccurred())
Expect(offset).To(Equal(int64(0)))
fileStat, err := zipFile.Stat()
Expect(err).NotTo(HaveOccurred())
reader, err := zip.NewReader(zipFile, fileStat.Size())
Expect(err).NotTo(HaveOccurred())
readFileInZip := func(index int) (string, string) {
buf := &bytes.Buffer{}
file := reader.File[index]
fReader, err := file.Open()
_, err = io.Copy(buf, fReader)
Expect(err).NotTo(HaveOccurred())
return file.Name, string(buf.Bytes())
}
Expect(len(reader.File)).To(Equal(3))
name, contents := readFileInZip(0)
Expect(name).To(Equal("foo.txt"))
Expect(contents).To(Equal("This is a simple text file."))
name, contents = readFileInZip(1)
Expect(name).To(Equal("subDir/bar.txt"))
Expect(contents).To(Equal("I am in a subdirectory."))
Expect(reader.File[1].FileInfo().Mode()).To(Equal(os.FileMode(0666)))
name, contents = readFileInZip(2)
Expect(name).To(Equal("subDir/otherDir/file.txt"))
Expect(contents).To(Equal("This file should be present."))
})
})
It("TestTraceSetToFile", func() {
stdOut := bytes.NewBuffer([]byte{})
trace.SetStdout(stdOut)
fileutils.TempFile("trace_test", func(file *os.File, err error) {
Expect(err).NotTo(HaveOccurred())
file.Write([]byte("pre-existing content"))
os.Setenv(trace.CF_TRACE, file.Name())
logger := trace.NewLogger()
logger.Print("hello world")
file.Seek(0, os.SEEK_SET)
result, err := ioutil.ReadAll(file)
Expect(err).NotTo(HaveOccurred())
byteString := string(result)
Expect(byteString).To(ContainSubstring("pre-existing content"))
Expect(byteString).To(ContainSubstring("hello world"))
result, _ = ioutil.ReadAll(stdOut)
Expect(string(result)).To(Equal(""))
})
})
It("TestTraceSetToInvalidFile", func() {
if runtime.GOOS != "windows" {
stdOut := bytes.NewBuffer([]byte{})
trace.SetStdout(stdOut)