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

     1  package mtaclient
     2  
     3  import (
     4  	"net/http"
     5  	"os"
     6  	"time"
     7  
     8  	"github.com/cloudfoundry-incubator/multiapps-cli-plugin/clients/baseclient"
     9  	"github.com/cloudfoundry-incubator/multiapps-cli-plugin/clients/models"
    10  )
    11  
    12  type RetryableMtaRestClient struct {
    13  	mtaClient       MtaClientOperations
    14  	MaxRetriesCount int
    15  	RetryInterval   time.Duration
    16  }
    17  
    18  func NewRetryableMtaRestClient(host, spaceID string, rt http.RoundTripper, tokenFactory baseclient.TokenFactory) RetryableMtaRestClient {
    19  	mtaClient := NewMtaClient(host, spaceID, rt, tokenFactory)
    20  	return RetryableMtaRestClient{mtaClient: mtaClient, MaxRetriesCount: 3, RetryInterval: time.Second * 3}
    21  }
    22  
    23  func (c RetryableMtaRestClient) ExecuteAction(operationID, actionID string) (ResponseHeader, error) {
    24  	executeActionCb := func() (interface{}, error) {
    25  		return c.mtaClient.ExecuteAction(operationID, actionID)
    26  	}
    27  	resp, err := baseclient.CallWithRetry(executeActionCb, c.MaxRetriesCount, c.RetryInterval)
    28  	if err != nil {
    29  		return ResponseHeader{}, err
    30  	}
    31  	return resp.(ResponseHeader), nil
    32  }
    33  
    34  func (c RetryableMtaRestClient) GetMta(mtaID string) (*models.Mta, error) {
    35  	getMtaCb := func() (interface{}, error) {
    36  		return c.mtaClient.GetMta(mtaID)
    37  	}
    38  	resp, err := baseclient.CallWithRetry(getMtaCb, c.MaxRetriesCount, c.RetryInterval)
    39  	if err != nil {
    40  		return nil, err
    41  	}
    42  	return resp.(*models.Mta), nil
    43  }
    44  
    45  func (c RetryableMtaRestClient) GetMtaFiles(namespace *string) ([]*models.FileMetadata, error) {
    46  	getMtaFilesCb := func() (interface{}, error) {
    47  		return c.mtaClient.GetMtaFiles(namespace)
    48  	}
    49  	resp, err := baseclient.CallWithRetry(getMtaFilesCb, c.MaxRetriesCount, c.RetryInterval)
    50  	if err != nil {
    51  		return nil, err
    52  	}
    53  	return resp.([]*models.FileMetadata), nil
    54  }
    55  
    56  func (c RetryableMtaRestClient) GetMtaOperation(operationID, embed string) (*models.Operation, error) {
    57  	getMtaOperationCb := func() (interface{}, error) {
    58  		return c.mtaClient.GetMtaOperation(operationID, embed)
    59  	}
    60  	resp, err := baseclient.CallWithRetry(getMtaOperationCb, c.MaxRetriesCount, c.RetryInterval)
    61  	if err != nil {
    62  		return nil, err
    63  	}
    64  	return resp.(*models.Operation), err
    65  }
    66  
    67  func (c RetryableMtaRestClient) GetMtaOperationLogs(operationID string) ([]*models.Log, error) {
    68  	getMtaOperationLogsCb := func() (interface{}, error) {
    69  		return c.mtaClient.GetMtaOperationLogs(operationID)
    70  	}
    71  	resp, err := baseclient.CallWithRetry(getMtaOperationLogsCb, c.MaxRetriesCount, c.RetryInterval)
    72  	if err != nil {
    73  		return nil, err
    74  	}
    75  	return resp.([]*models.Log), nil
    76  }
    77  
    78  func (c RetryableMtaRestClient) GetMtaOperations(mtaId *string, last *int64, status []string) ([]*models.Operation, error) {
    79  	getMtaOperationsCb := func() (interface{}, error) {
    80  		return c.mtaClient.GetMtaOperations(mtaId, last, status)
    81  	}
    82  	resp, err := baseclient.CallWithRetry(getMtaOperationsCb, c.MaxRetriesCount, c.RetryInterval)
    83  	if err != nil {
    84  		return nil, err
    85  	}
    86  	return resp.([]*models.Operation), nil
    87  }
    88  
    89  func (c RetryableMtaRestClient) GetMtas() ([]*models.Mta, error) {
    90  	getMtasCb := func() (interface{}, error) {
    91  		return c.mtaClient.GetMtas()
    92  	}
    93  	resp, err := baseclient.CallWithRetry(getMtasCb, c.MaxRetriesCount, c.RetryInterval)
    94  	if err != nil {
    95  		return nil, err
    96  	}
    97  	return resp.([]*models.Mta), nil
    98  }
    99  
   100  func (c RetryableMtaRestClient) GetOperationActions(operationID string) ([]string, error) {
   101  	getOperationActionsCb := func() (interface{}, error) {
   102  		return c.mtaClient.GetOperationActions(operationID)
   103  	}
   104  	resp, err := baseclient.CallWithRetry(getOperationActionsCb, c.MaxRetriesCount, c.RetryInterval)
   105  	if err != nil {
   106  		return nil, err
   107  	}
   108  	return resp.([]string), nil
   109  }
   110  
   111  func (c RetryableMtaRestClient) StartMtaOperation(operation models.Operation) (ResponseHeader, error) {
   112  	startMtaOperationCb := func() (interface{}, error) {
   113  		return c.mtaClient.StartMtaOperation(operation)
   114  	}
   115  	resp, err := baseclient.CallWithRetry(startMtaOperationCb, c.MaxRetriesCount, c.RetryInterval)
   116  	if err != nil {
   117  		return ResponseHeader{}, err
   118  	}
   119  	return resp.(ResponseHeader), nil
   120  }
   121  
   122  func (c RetryableMtaRestClient) UploadMtaFile(file os.File, fileSize int64, namespace *string) (*models.FileMetadata, error) {
   123  	uploadMtaFileCb := func() (interface{}, error) {
   124  		reopenedFile, err := os.Open(file.Name())
   125  		if err != nil {
   126  			return nil, err
   127  		}
   128  
   129  		return c.mtaClient.UploadMtaFile(*reopenedFile, fileSize, namespace)
   130  	}
   131  	resp, err := baseclient.CallWithRetry(uploadMtaFileCb, c.MaxRetriesCount, c.RetryInterval)
   132  	if err != nil {
   133  		return nil, err
   134  	}
   135  	return resp.(*models.FileMetadata), nil
   136  }
   137  
   138  func (c RetryableMtaRestClient) UploadMtaArchiveFromUrl(fileUrl string, namespace *string) (*models.FileMetadata, error) {
   139  	uploadMtaArchiveFromUrlCb := func() (interface{}, error) {
   140  		return c.mtaClient.UploadMtaArchiveFromUrl(fileUrl, namespace)
   141  	}
   142  	resp, err := baseclient.CallWithRetry(uploadMtaArchiveFromUrlCb, c.MaxRetriesCount, c.RetryInterval)
   143  	if err != nil {
   144  		return nil, err
   145  	}
   146  	return resp.(*models.FileMetadata), nil
   147  }
   148  
   149  func (c RetryableMtaRestClient) GetMtaOperationLogContent(operationID, logID string) (string, error) {
   150  	getMtaOperationLogContentCb := func() (interface{}, error) {
   151  		return c.mtaClient.GetMtaOperationLogContent(operationID, logID)
   152  	}
   153  	resp, err := baseclient.CallWithRetry(getMtaOperationLogContentCb, c.MaxRetriesCount, c.RetryInterval)
   154  	if err != nil {
   155  		return "", err
   156  	}
   157  	return resp.(string), nil
   158  }