github.com/jghiloni/cli@v6.28.1-0.20170628223758-0ce05fe032a2+incompatible/api/cloudcontroller/ccv3/package.go (about)

     1  package ccv3
     2  
     3  import (
     4  	"bytes"
     5  	"encoding/json"
     6  	"io"
     7  	"mime/multipart"
     8  	"os"
     9  	"path/filepath"
    10  
    11  	"code.cloudfoundry.org/cli/api/cloudcontroller"
    12  	"code.cloudfoundry.org/cli/api/cloudcontroller/ccerror"
    13  	"code.cloudfoundry.org/cli/api/cloudcontroller/ccv3/internal"
    14  )
    15  
    16  type PackageState string
    17  
    18  const (
    19  	PackageStateProcessingUpload PackageState = "PROCESSING_UPLOAD"
    20  	PackageStateReady            PackageState = "READY"
    21  	PackageStateFailed           PackageState = "FAILED"
    22  	PackageStateAwaitingUpload   PackageState = "AWAITING_UPLOAD"
    23  	PackageStateCopying          PackageState = "COPYING"
    24  	PackageStateExpired          PackageState = "EXPIRED"
    25  )
    26  
    27  type PackageType string
    28  
    29  const (
    30  	PackageTypeBits   PackageType = "bits"
    31  	PackageTypeDocker PackageType = "docker"
    32  )
    33  
    34  type Package struct {
    35  	GUID          string        `json:"guid,omitempty"`
    36  	Links         APILinks      `json:"links,omitempty"`
    37  	Relationships Relationships `json:"relationships,omitempty"`
    38  	State         PackageState  `json:"state,omitempty"`
    39  	Type          PackageType   `json:"type,omitempty"`
    40  }
    41  
    42  // GetPackage returns the package with the given GUID.
    43  func (client *Client) GetPackage(guid string) (Package, Warnings, error) {
    44  	request, err := client.newHTTPRequest(requestOptions{
    45  		RequestName: internal.GetPackageRequest,
    46  		URIParams:   internal.Params{"guid": guid},
    47  	})
    48  	if err != nil {
    49  		return Package{}, nil, err
    50  	}
    51  
    52  	var responsePackage Package
    53  	response := cloudcontroller.Response{
    54  		Result: &responsePackage,
    55  	}
    56  	err = client.connection.Make(request, &response)
    57  
    58  	return responsePackage, response.Warnings, err
    59  }
    60  
    61  // CreatePackage creates a package with the given settings, Type and the
    62  // ApplicationRelationship must be set.
    63  func (client *Client) CreatePackage(pkg Package) (Package, Warnings, error) {
    64  	bodyBytes, err := json.Marshal(pkg)
    65  	if err != nil {
    66  		return Package{}, nil, err
    67  	}
    68  
    69  	request, err := client.newHTTPRequest(requestOptions{
    70  		RequestName: internal.PostPackageRequest,
    71  		Body:        bytes.NewReader(bodyBytes),
    72  	})
    73  
    74  	var responsePackage Package
    75  	response := cloudcontroller.Response{
    76  		Result: &responsePackage,
    77  	}
    78  	err = client.connection.Make(request, &response)
    79  
    80  	return responsePackage, response.Warnings, err
    81  }
    82  
    83  // UploadPackage uploads a file to a given package's Upload resource. Note:
    84  // fileToUpload is read entirely into memory prior to sending data to CC.
    85  func (client *Client) UploadPackage(pkg Package, fileToUpload string) (Package, Warnings, error) {
    86  	link, ok := pkg.Links["upload"]
    87  	if !ok {
    88  		return Package{}, nil, ccerror.UploadLinkNotFoundError{PackageGUID: pkg.GUID}
    89  	}
    90  
    91  	body, contentType, err := client.createUploadStream(fileToUpload, "bits")
    92  	if err != nil {
    93  		return Package{}, nil, err
    94  	}
    95  
    96  	request, err := client.newHTTPRequest(requestOptions{
    97  		URL:    link.HREF,
    98  		Method: link.Method,
    99  		Body:   body,
   100  	})
   101  	request.Header.Set("Content-Type", contentType)
   102  
   103  	var responsePackage Package
   104  	response := cloudcontroller.Response{
   105  		Result: &responsePackage,
   106  	}
   107  	err = client.connection.Make(request, &response)
   108  
   109  	return responsePackage, response.Warnings, err
   110  }
   111  
   112  func (_ *Client) createUploadStream(path string, paramName string) (io.ReadSeeker, string, error) {
   113  	file, err := os.Open(path)
   114  	if err != nil {
   115  		return nil, "", err
   116  	}
   117  	defer file.Close()
   118  
   119  	body := &bytes.Buffer{}
   120  	writer := multipart.NewWriter(body)
   121  	part, err := writer.CreateFormFile(paramName, filepath.Base(path))
   122  	if err != nil {
   123  		return nil, "", err
   124  	}
   125  	_, err = io.Copy(part, file)
   126  	if err != nil {
   127  		return nil, "", err
   128  	}
   129  
   130  	err = writer.Close()
   131  
   132  	return bytes.NewReader(body.Bytes()), writer.FormDataContentType(), err
   133  }