github.com/jfrog/jfrog-cli-core/v2@v2.51.0/artifactory/commands/transferfiles/srcpluginservice.go (about)

     1  package transferfiles
     2  
     3  import (
     4  	"encoding/json"
     5  	"github.com/jfrog/jfrog-cli-core/v2/artifactory/commands/transferfiles/api"
     6  	commandsUtils "github.com/jfrog/jfrog-cli-core/v2/artifactory/commands/utils"
     7  	"github.com/jfrog/jfrog-client-go/artifactory/services/utils"
     8  	"github.com/jfrog/jfrog-client-go/auth"
     9  	"github.com/jfrog/jfrog-client-go/http/jfroghttpclient"
    10  	"github.com/jfrog/jfrog-client-go/utils/errorutils"
    11  	"net/http"
    12  )
    13  
    14  const (
    15  	syncChunks  = "syncChunks"
    16  	uploadChunk = "uploadChunk"
    17  )
    18  
    19  type VerifyCompatibilityResponse struct {
    20  	Version string `json:"version,omitempty"`
    21  	Message string `json:"message,omitempty"`
    22  }
    23  
    24  type srcUserPluginService struct {
    25  	client     *jfroghttpclient.JfrogHttpClient
    26  	artDetails *auth.ServiceDetails
    27  }
    28  
    29  func NewSrcUserPluginService(artDetails auth.ServiceDetails, client *jfroghttpclient.JfrogHttpClient) *srcUserPluginService {
    30  	return &srcUserPluginService{artDetails: &artDetails, client: client}
    31  }
    32  
    33  func (sup *srcUserPluginService) GetArtifactoryDetails() auth.ServiceDetails {
    34  	return *sup.artDetails
    35  }
    36  
    37  func (sup *srcUserPluginService) GetJfrogHttpClient() *jfroghttpclient.JfrogHttpClient {
    38  	return sup.client
    39  }
    40  
    41  func (sup *srcUserPluginService) IsDryRun() bool {
    42  	return false
    43  }
    44  
    45  func (sup *srcUserPluginService) syncChunks(ucStatus api.UploadChunksStatusBody) (api.UploadChunksStatusResponse, error) {
    46  	content, err := json.Marshal(ucStatus)
    47  	if err != nil {
    48  		return api.UploadChunksStatusResponse{}, errorutils.CheckError(err)
    49  	}
    50  
    51  	httpDetails := sup.GetArtifactoryDetails().CreateHttpClientDetails()
    52  	utils.SetContentType("application/json", &httpDetails.Headers)
    53  	resp, body, err := sup.client.SendPost(sup.GetArtifactoryDetails().GetUrl()+commandsUtils.PluginsExecuteRestApi+syncChunks, content, &httpDetails)
    54  	if err != nil {
    55  		return api.UploadChunksStatusResponse{}, err
    56  	}
    57  
    58  	if err = errorutils.CheckResponseStatusWithBody(resp, body, http.StatusOK); err != nil {
    59  		return api.UploadChunksStatusResponse{}, err
    60  	}
    61  
    62  	var statusResponse api.UploadChunksStatusResponse
    63  	err = json.Unmarshal(body, &statusResponse)
    64  	if err != nil {
    65  		return api.UploadChunksStatusResponse{}, errorutils.CheckError(err)
    66  	}
    67  	return statusResponse, nil
    68  }
    69  
    70  // Uploads a chunk of files.
    71  // If no error occurred, returns an uuid token to get chunk status with.
    72  func (sup *srcUserPluginService) uploadChunk(chunk api.UploadChunk) (uploadChunkResponse api.UploadChunkResponse, err error) {
    73  	content, err := json.Marshal(chunk)
    74  	if err != nil {
    75  		return api.UploadChunkResponse{}, errorutils.CheckError(err)
    76  	}
    77  
    78  	httpDetails := sup.GetArtifactoryDetails().CreateHttpClientDetails()
    79  	utils.SetContentType("application/json", &httpDetails.Headers)
    80  	resp, body, err := sup.client.SendPost(sup.GetArtifactoryDetails().GetUrl()+commandsUtils.PluginsExecuteRestApi+uploadChunk, content, &httpDetails)
    81  	if err != nil {
    82  		return api.UploadChunkResponse{}, err
    83  	}
    84  
    85  	if err = errorutils.CheckResponseStatusWithBody(resp, body, http.StatusAccepted); err != nil {
    86  		return api.UploadChunkResponse{}, err
    87  	}
    88  
    89  	var uploadResponse api.UploadChunkResponse
    90  	err = json.Unmarshal(body, &uploadResponse)
    91  	if err != nil {
    92  		return api.UploadChunkResponse{}, errorutils.CheckError(err)
    93  	}
    94  	if uploadResponse.UuidToken == "" {
    95  		return api.UploadChunkResponse{}, errorutils.CheckErrorf("unexpected empty token returned for chunk upload")
    96  	}
    97  	if uploadResponse.NodeId == "" {
    98  		return api.UploadChunkResponse{}, errorutils.CheckErrorf("unexpected empty node id returned for chunk upload")
    99  	}
   100  	return uploadResponse, nil
   101  }
   102  
   103  func (sup *srcUserPluginService) version() (string, error) {
   104  	dataTransferVersionUrl := sup.GetArtifactoryDetails().GetUrl() + commandsUtils.PluginsExecuteRestApi + "dataTransferVersion"
   105  	httpDetails := sup.GetArtifactoryDetails().CreateHttpClientDetails()
   106  	return commandsUtils.GetTransferPluginVersion(sup.client, dataTransferVersionUrl, "data-transfer", commandsUtils.Source, &httpDetails)
   107  }
   108  
   109  func (sup *srcUserPluginService) verifyCompatibilityRequest() (*VerifyCompatibilityResponse, error) {
   110  	httpDetails := sup.GetArtifactoryDetails().CreateHttpClientDetails()
   111  	utils.SetContentType("application/json", &httpDetails.Headers)
   112  	resp, body, err := sup.client.SendPost(sup.GetArtifactoryDetails().GetUrl()+commandsUtils.PluginsExecuteRestApi+"verifyCompatibility", []byte("{}"), &httpDetails)
   113  	if err != nil {
   114  		return nil, err
   115  	}
   116  
   117  	err = errorutils.CheckResponseStatusWithBody(resp, body, http.StatusOK)
   118  	if err != nil {
   119  		return nil, err
   120  	}
   121  
   122  	var result VerifyCompatibilityResponse
   123  	err = json.Unmarshal(body, &result)
   124  	if err != nil {
   125  		return nil, errorutils.CheckError(err)
   126  	}
   127  
   128  	return &result, nil
   129  }
   130  
   131  func (sup *srcUserPluginService) verifyConnectivityRequest(targetAuth api.TargetAuth) error {
   132  	httpDetails := sup.GetArtifactoryDetails().CreateHttpClientDetails()
   133  	utils.SetContentType("application/json", &httpDetails.Headers)
   134  	content, err := json.Marshal(targetAuth)
   135  	if err != nil {
   136  		return errorutils.CheckError(err)
   137  	}
   138  	resp, body, err := sup.client.SendPost(sup.GetArtifactoryDetails().GetUrl()+commandsUtils.PluginsExecuteRestApi+"verifySourceTargetConnectivity", content, &httpDetails)
   139  	if err != nil {
   140  		return err
   141  	}
   142  
   143  	return errorutils.CheckResponseStatusWithBody(resp, body, http.StatusOK)
   144  }
   145  
   146  func (sup *srcUserPluginService) stop() (nodeId string, err error) {
   147  	httpDetails := sup.GetArtifactoryDetails().CreateHttpClientDetails()
   148  	resp, body, err := sup.client.SendPost(sup.GetArtifactoryDetails().GetUrl()+commandsUtils.PluginsExecuteRestApi+"stop", []byte{}, &httpDetails)
   149  	if err != nil {
   150  		return "", err
   151  	}
   152  
   153  	if err = errorutils.CheckResponseStatus(resp, http.StatusOK); err != nil {
   154  		return "", err
   155  	}
   156  
   157  	var result api.NodeIdResponse
   158  	err = json.Unmarshal(body, &result)
   159  	if err != nil {
   160  		return "", errorutils.CheckError(err)
   161  	}
   162  	return result.NodeId, nil
   163  }