Media item upload any file and download (#622)

* Add method Catalog.UploadMediaFile
* Add changelog item
* Add method Media.Download
    It allows to download the media contents as a bytes stream
* Add test to upload and download media item
* Add deferred close for response body

---------

Signed-off-by: Giuseppe Maxia <gmaxia@vmware.com>

Author: dataclouder

.changes/v2.22.0/621-features.md

@@ -0,0 +1 @@
+* Added method `Catalog.UploadMediaFile` to upload any file as catalog Media [GH-621,GH-622]

.changes/v2.22.0/622-features.md

@@ -0,0 +1 @@
+* Added method `Media.Download` to download a Media item as a byte stream [GH-622]

govcd/catalog.go

@@ -827,7 +827,14 @@ func removeCatalogItemOnError(client *Client, vappTemplateLink *url.URL, itemNam
 	}
 }
 
+// UploadMediaImage uploads a media image to the catalog
 func (cat *Catalog) UploadMediaImage(mediaName, mediaDescription, filePath string, uploadPieceSize int64) (UploadTask, error) {
+	return cat.UploadMediaFile(mediaName, mediaDescription, filePath, uploadPieceSize, true)
+}
+
+// UploadMediaFile uploads any file to the catalog.
+// However, if checkFileIsIso is true, only .ISO are allowed.
+func (cat *Catalog) UploadMediaFile(fileName, mediaDescription, filePath string, uploadPieceSize int64, checkFileIsIso bool) (UploadTask, error) {
 
 	if *cat == (Catalog{}) {
 		return UploadTask{}, errors.New("catalog can not be empty or nil")
@@ -838,9 +845,11 @@ func (cat *Catalog) UploadMediaImage(mediaName, mediaDescription, filePath strin
 		return UploadTask{}, err
 	}
 
-	isISOGood, err := verifyIso(mediaFilePath)
-	if err != nil || !isISOGood {
-		return UploadTask{}, fmt.Errorf("[ERROR] File %s isn't correct iso file: %#v", mediaFilePath, err)
+	if checkFileIsIso {
+		isISOGood, err := verifyIso(mediaFilePath)
+		if err != nil || !isISOGood {
+			return UploadTask{}, fmt.Errorf("[ERROR] File %s isn't correct iso file: %#v", mediaFilePath, err)
+		}
 	}
 
 	file, e := os.Stat(mediaFilePath)
@@ -850,8 +859,8 @@ func (cat *Catalog) UploadMediaImage(mediaName, mediaDescription, filePath strin
 	fileSize := file.Size()
 
 	for _, catalogItemName := range getExistingCatalogItems(cat) {
-		if catalogItemName == mediaName {
-			return UploadTask{}, fmt.Errorf("media item '%s' already exists. Upload with different name", mediaName)
+		if catalogItemName == fileName {
+			return UploadTask{}, fmt.Errorf("media item '%s' already exists. Upload with different name", fileName)
 		}
 	}
 
@@ -860,17 +869,17 @@ func (cat *Catalog) UploadMediaImage(mediaName, mediaDescription, filePath strin
 		return UploadTask{}, err
 	}
 
-	media, err := createMedia(cat.client, catalogItemUploadURL.String(), mediaName, mediaDescription, fileSize)
+	media, err := createMedia(cat.client, catalogItemUploadURL.String(), fileName, mediaDescription, fileSize)
 	if err != nil {
 		return UploadTask{}, fmt.Errorf("[ERROR] Issue creating media: %#v", err)
 	}
 
-	createdMedia, err := queryMedia(cat.client, media.Entity.HREF, mediaName)
+	createdMedia, err := queryMedia(cat.client, media.Entity.HREF, fileName)
 	if err != nil {
 		return UploadTask{}, err
 	}
 
-	return executeUpload(cat.client, createdMedia, mediaFilePath, mediaName, fileSize, uploadPieceSize)
+	return executeUpload(cat.client, createdMedia, mediaFilePath, fileName, fileSize, uploadPieceSize)
 }
 
 // Refresh gets a fresh copy of the catalog from vCD

govcd/media.go

@@ -747,3 +747,99 @@ func (vdc *Vdc) QueryAllMedia(mediaName string) ([]*MediaRecord, error) {
 	util.Logger.Printf("[TRACE] Found media records by name: %#v \n", mediaResults)
 	return newMediaRecords, nil
 }
+
+// enableDownload prepares a media item for download and returns a download link
+// Note: depending on the size of the item, it may take a long time.
+func (media *Media) enableDownload() (string, error) {
+	downloadUrl := getUrlFromLink(media.Media.Link, "enable", "")
+	if downloadUrl == "" {
+		return "", fmt.Errorf("no enable URL found")
+	}
+	// The result of this operation is the creation of an entry in the 'Files' field of the media structure
+	// Inside that field, there will be a Link entry with the URL for the download
+	// e.g.
+	//<Files>
+	//    <File size="25434" name="file">
+	//        <Link rel="download:default" href="https://example.com/transfer/1638969a-06da-4f6c-b097-7796c1556c54/file"/>
+	//    </File>
+	//</Files>
+	task, err := media.client.executeTaskRequest(
+		downloadUrl,
+		http.MethodPost,
+		types.MimeTask,
+		"error enabling download: %s",
+		nil,
+		media.client.APIVersion)
+	if err != nil {
+		return "", err
+	}
+	err = task.WaitTaskCompletion()
+	if err != nil {
+		return "", err
+	}
+
+	err = media.Refresh()
+	if err != nil {
+		return "", err
+	}
+
+	if media.Media.Files == nil || len(media.Media.Files.File) == 0 {
+		return "", fmt.Errorf("no downloadable file info found")
+	}
+	downloadHref := ""
+	for _, f := range media.Media.Files.File {
+		for _, l := range f.Link {
+			if l.Rel == "download:default" {
+				downloadHref = l.HREF
+				break
+			}
+			if downloadHref != "" {
+				break
+			}
+		}
+	}
+
+	if downloadHref == "" {
+		return "", fmt.Errorf("no download URL found")
+	}
+
+	return downloadHref, nil
+}
+
+// Download gets the contents of a media item as a byte stream
+// NOTE: the whole item will be saved in local memory. Do not attempt this operation for very large items
+func (media *Media) Download() ([]byte, error) {
+
+	downloadHref, err := media.enableDownload()
+	if err != nil {
+		return nil, err
+	}
+
+	downloadUrl, err := url.ParseRequestURI(downloadHref)
+	if err != nil {
+		return nil, fmt.Errorf("error getting download URL: %s", err)
+	}
+
+	request := media.client.NewRequest(map[string]string{}, http.MethodGet, *downloadUrl, nil)
+	resp, err := media.client.Http.Do(request)
+	if err != nil {
+		return nil, fmt.Errorf("error getting media download: %s", err)
+	}
+
+	if !isSuccessStatus(resp.StatusCode) {
+		return nil, fmt.Errorf("error downloading media: %s", resp.Status)
+	}
+	body, err := io.ReadAll(resp.Body)
+
+	defer func() {
+		err = resp.Body.Close()
+		if err != nil {
+			panic(fmt.Sprintf("error closing body: %s", err))
+		}
+	}()
+
+	if err != nil {
+		return nil, err
+	}
+	return body, nil
+}

govcd/media_test.go

@@ -8,8 +8,10 @@ package govcd
 
 import (
 	"fmt"
-
 	. "gopkg.in/check.v1"
+	"os"
+	"path"
+	"runtime"
 )
 
 // Tests System function Delete by creating media item and
@@ -57,6 +59,73 @@ func (vcd *TestVCD) Test_DeleteMedia(check *C) {
 	check.Assert(IsNotFound(err), Equals, true)
 }
 
+func (vcd *TestVCD) Test_UploadAnyMediaFile(check *C) {
+	fmt.Printf("Running: %s\n", check.TestName())
+
+	if vcd.config.VCD.Org == "" {
+		check.Skip("Test_UploadAnyMediaFile: Org name not given")
+		return
+	}
+	if vcd.config.VCD.Catalog.Name == "" {
+		check.Skip("Test_UploadAnyMediaFile: Catalog name not given")
+		return
+	}
+	org, err := vcd.client.GetOrgByName(vcd.config.VCD.Org)
+	check.Assert(err, IsNil)
+	check.Assert(org, NotNil)
+
+	catalog, err := org.GetCatalogByName(vcd.config.VCD.Catalog.Name, false)
+	check.Assert(err, IsNil)
+	check.Assert(catalog, NotNil)
+
+	_, sourceFile, _, _ := runtime.Caller(0)
+	sourceFile = path.Clean(sourceFile)
+	itemName := check.TestName()
+	itemPath := sourceFile
+
+	// Upload the source file of the current test as a media item
+	uploadTask, err := catalog.UploadMediaFile(itemName, "Text file uploaded from test", itemPath, 1024, false)
+	check.Assert(err, IsNil)
+	err = uploadTask.WaitTaskCompletion()
+	check.Assert(err, IsNil)
+
+	AddToCleanupList(itemName, "mediaCatalogImage", vcd.org.Org.Name+"|"+vcd.config.VCD.Catalog.Name, check.TestName())
+
+	// Retrieve the media item
+	media, err := catalog.GetMediaByName(itemName, true)
+	check.Assert(err, IsNil)
+	check.Assert(media, NotNil)
+	check.Assert(media.Media.Name, Equals, itemName)
+
+	// Repeat the download a few times. Make sure that a repeated download works as well as the first one
+	for i := 0; i < 2; i++ {
+		// Download the media item from VCD as a byte slice
+		contents, err := media.Download()
+		check.Assert(err, IsNil)
+		check.Assert(len(contents), Not(Equals), 0)
+		check.Assert(media.Media.Files, NotNil)
+		check.Assert(media.Media.Files.File, NotNil)
+		check.Assert(media.Media.Files.File[0].Name, Not(Equals), "")
+		check.Assert(len(media.Media.Files.File[0].Link), Not(Equals), 0)
+
+		// Read the source file from disk
+		fromFile, err := os.ReadFile(path.Clean(sourceFile))
+		check.Assert(err, IsNil)
+		// Make sure that what we downloaded from VCD corresponds to the file contents.
+		check.Assert(len(fromFile), Equals, len(contents))
+		check.Assert(fromFile, DeepEquals, contents)
+	}
+
+	task, err := media.Delete()
+	check.Assert(err, IsNil)
+	err = task.WaitTaskCompletion()
+	check.Assert(err, IsNil)
+
+	_, err = catalog.GetMediaByName(itemName, true)
+	check.Assert(err, NotNil)
+	check.Assert(IsNotFound(err), Equals, true)
+}
+
 // Tests System function Refresh
 func (vcd *TestVCD) Test_RefreshMedia(check *C) {
 	fmt.Printf("Running: %s\n", check.TestName())