github.com/sap/cf-mta-plugin@v2.6.3+incompatible/clients/mtaclient/mta_rest_client.go (about)

     1  package mtaclient
     2  
     3  import (
     4  	"context"
     5  	"net/http"
     6  	"os"
     7  
     8  	"github.com/cloudfoundry-incubator/multiapps-cli-plugin/clients/baseclient"
     9  	"github.com/cloudfoundry-incubator/multiapps-cli-plugin/clients/models"
    10  	"github.com/cloudfoundry-incubator/multiapps-cli-plugin/clients/mtaclient/operations"
    11  	"github.com/go-openapi/runtime"
    12  	"github.com/go-openapi/strfmt"
    13  )
    14  
    15  const spacesURL string = "spaces/"
    16  const restBaseURL string = "api/v1/"
    17  
    18  type MtaRestClient struct {
    19  	baseclient.BaseClient
    20  	client *MtaClient
    21  }
    22  
    23  func NewMtaClient(host, spaceID string, rt http.RoundTripper, tokenFactory baseclient.TokenFactory) MtaClientOperations {
    24  	restURL := restBaseURL + spacesURL + spaceID
    25  	t := baseclient.NewHTTPTransport(host, restURL, restURL, rt)
    26  	httpMtaClient := New(t, strfmt.Default)
    27  	return &MtaRestClient{baseclient.BaseClient{TokenFactory: tokenFactory}, httpMtaClient}
    28  }
    29  
    30  func (c MtaRestClient) ExecuteAction(operationID, actionID string) (ResponseHeader, error) {
    31  	params := &operations.ExecuteOperationActionParams{
    32  		OperationID: operationID,
    33  		ActionID:    actionID,
    34  		Context:     context.TODO(),
    35  	}
    36  	token, err := c.TokenFactory.NewToken()
    37  	if err != nil {
    38  		return ResponseHeader{}, baseclient.NewClientError(err)
    39  	}
    40  	resp, err := c.client.Operations.ExecuteOperationAction(params, token)
    41  	if err != nil {
    42  		return ResponseHeader{}, baseclient.NewClientError(err)
    43  	}
    44  	return ResponseHeader{Location: resp.Location}, nil
    45  }
    46  
    47  func (c MtaRestClient) GetMta(mtaID string) (*models.Mta, error) {
    48  	params := &operations.GetMtaParams{
    49  		Context: context.TODO(),
    50  		MtaID:   mtaID,
    51  	}
    52  
    53  	result, err := executeRestOperation(c.TokenFactory, func(token runtime.ClientAuthInfoWriter) (interface{}, error) {
    54  		return c.client.Operations.GetMta(params, token)
    55  	})
    56  	if err != nil {
    57  		return nil, baseclient.NewClientError(err)
    58  	}
    59  
    60  	return result.(*operations.GetMtaOK).Payload, nil
    61  }
    62  
    63  func (c MtaRestClient) GetMtaFiles(namespace *string) ([]*models.FileMetadata, error) {
    64  	params := &operations.GetMtaFilesParams{
    65  		Context:   context.TODO(),
    66  		Namespace: namespace,
    67  	}
    68  	token, err := c.TokenFactory.NewToken()
    69  	if err != nil {
    70  		return nil, baseclient.NewClientError(err)
    71  	}
    72  	resp, err := c.client.Operations.GetMtaFiles(params, token)
    73  	if err != nil {
    74  		return nil, baseclient.NewClientError(err)
    75  	}
    76  	return resp.Payload, nil
    77  }
    78  
    79  func (c MtaRestClient) GetMtaOperation(operationID, embed string) (*models.Operation, error) {
    80  	params := &operations.GetMtaOperationParams{
    81  		Context:     context.TODO(),
    82  		OperationID: operationID,
    83  		Embed:       &embed,
    84  	}
    85  	token, err := c.TokenFactory.NewToken()
    86  	if err != nil {
    87  		return nil, baseclient.NewClientError(err)
    88  	}
    89  	resp, err := c.client.Operations.GetMtaOperation(params, token)
    90  	if err != nil {
    91  		return nil, baseclient.NewClientError(err)
    92  	}
    93  	return resp.Payload, nil
    94  }
    95  
    96  func (c MtaRestClient) GetMtaOperationLogs(operationID string) ([]*models.Log, error) {
    97  	params := &operations.GetMtaOperationLogsParams{
    98  		Context:     context.TODO(),
    99  		OperationID: operationID,
   100  	}
   101  	token, err := c.TokenFactory.NewToken()
   102  	if err != nil {
   103  		return nil, baseclient.NewClientError(err)
   104  	}
   105  	resp, err := c.client.Operations.GetMtaOperationLogs(params, token)
   106  	if err != nil {
   107  		return nil, baseclient.NewClientError(err)
   108  	}
   109  	return resp.Payload, nil
   110  }
   111  
   112  func (c MtaRestClient) GetMtaOperations(mtaId *string, last *int64, status []string) ([]*models.Operation, error) {
   113  	params := &operations.GetMtaOperationsParams{
   114  		Context: context.TODO(),
   115  		MtaID:   mtaId,
   116  		Last:    last,
   117  		State:   status,
   118  	}
   119  	token, err := c.TokenFactory.NewToken()
   120  	if err != nil {
   121  		return nil, baseclient.NewClientError(err)
   122  	}
   123  	resp, err := c.client.Operations.GetMtaOperations(params, token)
   124  	if err != nil {
   125  		return nil, baseclient.NewClientError(err)
   126  	}
   127  	return resp.Payload, nil
   128  }
   129  
   130  func (c MtaRestClient) GetMtas() ([]*models.Mta, error) {
   131  	token, err := c.TokenFactory.NewToken()
   132  	if err != nil {
   133  		return nil, baseclient.NewClientError(err)
   134  	}
   135  	resp, err := c.client.Operations.GetMtas(nil, token)
   136  	if err != nil {
   137  		return nil, baseclient.NewClientError(err)
   138  	}
   139  	return resp.Payload, nil
   140  }
   141  
   142  func (c MtaRestClient) GetOperationActions(operationID string) ([]string, error) {
   143  	params := &operations.GetOperationActionsParams{
   144  		Context:     context.TODO(),
   145  		OperationID: operationID,
   146  	}
   147  	token, err := c.TokenFactory.NewToken()
   148  	if err != nil {
   149  		return nil, baseclient.NewClientError(err)
   150  	}
   151  	resp, err := c.client.Operations.GetOperationActions(params, token)
   152  	if err != nil {
   153  		return nil, baseclient.NewClientError(err)
   154  	}
   155  	return resp.Payload, nil
   156  }
   157  
   158  func (c MtaRestClient) StartMtaOperation(operation models.Operation) (ResponseHeader, error) {
   159  	params := &operations.StartMtaOperationParams{
   160  		Context:   context.TODO(),
   161  		Operation: &operation,
   162  	}
   163  	token, err := c.TokenFactory.NewToken()
   164  	if err != nil {
   165  		return ResponseHeader{}, baseclient.NewClientError(err)
   166  	}
   167  	resp, err := c.client.Operations.StartMtaOperation(params, token)
   168  	if err != nil {
   169  		return ResponseHeader{}, baseclient.NewClientError(err)
   170  	}
   171  	return ResponseHeader{Location: resp.Location}, nil
   172  }
   173  
   174  func (c MtaRestClient) UploadMtaFile(file os.File, fileSize int64, namespace *string) (*models.FileMetadata, error) {
   175  	params := &operations.UploadMtaFileParams{
   176  		Context:   context.TODO(),
   177  		File:      file,
   178  		FileSize:  fileSize,
   179  		Namespace: namespace,
   180  	}
   181  
   182  	result, err := executeRestOperation(c.TokenFactory, func(token runtime.ClientAuthInfoWriter) (interface{}, error) {
   183  		return c.client.Operations.UploadMtaFile(params, token)
   184  	})
   185  
   186  	if err != nil {
   187  		return nil, baseclient.NewClientError(err)
   188  	}
   189  	return result.(*operations.UploadMtaFileCreated).Payload, nil
   190  }
   191  
   192  func (c MtaRestClient) UploadMtaArchiveFromUrl(fileUrl string, namespace *string) (*models.FileMetadata, error) {
   193  	params := &operations.UploadMtaArchiveFromUrlParams{
   194  		Context:   context.TODO(),
   195  		FileUrl:   fileUrl,
   196  		Namespace: namespace,
   197  	}
   198  
   199  	result, err := executeRestOperation(c.TokenFactory, func(token runtime.ClientAuthInfoWriter) (interface{}, error) {
   200  		return c.client.Operations.UploadMtaArchiveFromUrl(params, token)
   201  	})
   202  
   203  	if err != nil {
   204  		return nil, baseclient.NewClientError(err)
   205  	}
   206  	return result.(*operations.UploadMtaArchiveFromUrlCreated).Payload, nil
   207  }
   208  
   209  func (c MtaRestClient) GetMtaOperationLogContent(operationID, logID string) (string, error) {
   210  	params := &operations.GetMtaOperationLogContentParams{
   211  		Context:     context.TODO(),
   212  		LogID:       logID,
   213  		OperationID: operationID,
   214  	}
   215  
   216  	result, err := executeRestOperation(c.TokenFactory, func(token runtime.ClientAuthInfoWriter) (interface{}, error) {
   217  		return c.client.Operations.GetMtaOperationLogContent(params, token)
   218  	})
   219  
   220  	return result.(*operations.GetMtaOperationLogContentOK).Payload, baseclient.NewClientError(err)
   221  }
   222  
   223  func executeRestOperation(tokenProvider baseclient.TokenFactory, restOperation func(token runtime.ClientAuthInfoWriter) (interface{}, error)) (interface{}, error) {
   224  	token, err := tokenProvider.NewToken()
   225  	if err != nil {
   226  		return nil, baseclient.NewClientError(err)
   227  	}
   228  	return restOperation(token)
   229  }