1// +build go1.13
2
3// Copyright (c) Microsoft Corporation. All rights reserved.
4// Licensed under the MIT License. See License.txt in the project root for license information.
5// Code generated by Microsoft (R) AutoRest Code Generator.
6// Changes may cause incorrect behavior and will be lost if the code is regenerated.
7
8package armcontainerregistry
9
10import (
11	"context"
12	"errors"
13	"fmt"
14	"github.com/Azure/azure-sdk-for-go/sdk/armcore"
15	"github.com/Azure/azure-sdk-for-go/sdk/azcore"
16	"net/http"
17	"net/url"
18	"strconv"
19	"strings"
20	"time"
21)
22
23// RunsClient contains the methods for the Runs group.
24// Don't use this type directly, use NewRunsClient() instead.
25type RunsClient struct {
26	con            *armcore.Connection
27	subscriptionID string
28}
29
30// NewRunsClient creates a new instance of RunsClient with the specified values.
31func NewRunsClient(con *armcore.Connection, subscriptionID string) *RunsClient {
32	return &RunsClient{con: con, subscriptionID: subscriptionID}
33}
34
35// BeginCancel - Cancel an existing run.
36// If the operation fails it returns the *ErrorResponse error type.
37func (client *RunsClient) BeginCancel(ctx context.Context, resourceGroupName string, registryName string, runID string, options *RunsBeginCancelOptions) (HTTPPollerResponse, error) {
38	resp, err := client.cancel(ctx, resourceGroupName, registryName, runID, options)
39	if err != nil {
40		return HTTPPollerResponse{}, err
41	}
42	result := HTTPPollerResponse{
43		RawResponse: resp.Response,
44	}
45	pt, err := armcore.NewLROPoller("RunsClient.Cancel", "", resp, client.con.Pipeline(), client.cancelHandleError)
46	if err != nil {
47		return HTTPPollerResponse{}, err
48	}
49	poller := &httpPoller{
50		pt: pt,
51	}
52	result.Poller = poller
53	result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (*http.Response, error) {
54		return poller.pollUntilDone(ctx, frequency)
55	}
56	return result, nil
57}
58
59// ResumeCancel creates a new HTTPPoller from the specified resume token.
60// token - The value must come from a previous call to HTTPPoller.ResumeToken().
61func (client *RunsClient) ResumeCancel(ctx context.Context, token string) (HTTPPollerResponse, error) {
62	pt, err := armcore.NewLROPollerFromResumeToken("RunsClient.Cancel", token, client.con.Pipeline(), client.cancelHandleError)
63	if err != nil {
64		return HTTPPollerResponse{}, err
65	}
66	poller := &httpPoller{
67		pt: pt,
68	}
69	resp, err := poller.Poll(ctx)
70	if err != nil {
71		return HTTPPollerResponse{}, err
72	}
73	result := HTTPPollerResponse{
74		RawResponse: resp,
75	}
76	result.Poller = poller
77	result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (*http.Response, error) {
78		return poller.pollUntilDone(ctx, frequency)
79	}
80	return result, nil
81}
82
83// Cancel - Cancel an existing run.
84// If the operation fails it returns the *ErrorResponse error type.
85func (client *RunsClient) cancel(ctx context.Context, resourceGroupName string, registryName string, runID string, options *RunsBeginCancelOptions) (*azcore.Response, error) {
86	req, err := client.cancelCreateRequest(ctx, resourceGroupName, registryName, runID, options)
87	if err != nil {
88		return nil, err
89	}
90	resp, err := client.con.Pipeline().Do(req)
91	if err != nil {
92		return nil, err
93	}
94	if !resp.HasStatusCode(http.StatusOK, http.StatusAccepted) {
95		return nil, client.cancelHandleError(resp)
96	}
97	return resp, nil
98}
99
100// cancelCreateRequest creates the Cancel request.
101func (client *RunsClient) cancelCreateRequest(ctx context.Context, resourceGroupName string, registryName string, runID string, options *RunsBeginCancelOptions) (*azcore.Request, error) {
102	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerRegistry/registries/{registryName}/runs/{runId}/cancel"
103	if client.subscriptionID == "" {
104		return nil, errors.New("parameter client.subscriptionID cannot be empty")
105	}
106	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
107	if resourceGroupName == "" {
108		return nil, errors.New("parameter resourceGroupName cannot be empty")
109	}
110	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
111	if registryName == "" {
112		return nil, errors.New("parameter registryName cannot be empty")
113	}
114	urlPath = strings.ReplaceAll(urlPath, "{registryName}", url.PathEscape(registryName))
115	if runID == "" {
116		return nil, errors.New("parameter runID cannot be empty")
117	}
118	urlPath = strings.ReplaceAll(urlPath, "{runId}", url.PathEscape(runID))
119	req, err := azcore.NewRequest(ctx, http.MethodPost, azcore.JoinPaths(client.con.Endpoint(), urlPath))
120	if err != nil {
121		return nil, err
122	}
123	req.Telemetry(telemetryInfo)
124	reqQP := req.URL.Query()
125	reqQP.Set("api-version", "2019-06-01-preview")
126	req.URL.RawQuery = reqQP.Encode()
127	req.Header.Set("Accept", "application/json")
128	return req, nil
129}
130
131// cancelHandleError handles the Cancel error response.
132func (client *RunsClient) cancelHandleError(resp *azcore.Response) error {
133	body, err := resp.Payload()
134	if err != nil {
135		return azcore.NewResponseError(err, resp.Response)
136	}
137	errType := ErrorResponse{raw: string(body)}
138	if err := resp.UnmarshalAsJSON(&errType); err != nil {
139		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
140	}
141	return azcore.NewResponseError(&errType, resp.Response)
142}
143
144// Get - Gets the detailed information for a given run.
145// If the operation fails it returns the *ErrorResponse error type.
146func (client *RunsClient) Get(ctx context.Context, resourceGroupName string, registryName string, runID string, options *RunsGetOptions) (RunResponse, error) {
147	req, err := client.getCreateRequest(ctx, resourceGroupName, registryName, runID, options)
148	if err != nil {
149		return RunResponse{}, err
150	}
151	resp, err := client.con.Pipeline().Do(req)
152	if err != nil {
153		return RunResponse{}, err
154	}
155	if !resp.HasStatusCode(http.StatusOK) {
156		return RunResponse{}, client.getHandleError(resp)
157	}
158	return client.getHandleResponse(resp)
159}
160
161// getCreateRequest creates the Get request.
162func (client *RunsClient) getCreateRequest(ctx context.Context, resourceGroupName string, registryName string, runID string, options *RunsGetOptions) (*azcore.Request, error) {
163	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerRegistry/registries/{registryName}/runs/{runId}"
164	if client.subscriptionID == "" {
165		return nil, errors.New("parameter client.subscriptionID cannot be empty")
166	}
167	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
168	if resourceGroupName == "" {
169		return nil, errors.New("parameter resourceGroupName cannot be empty")
170	}
171	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
172	if registryName == "" {
173		return nil, errors.New("parameter registryName cannot be empty")
174	}
175	urlPath = strings.ReplaceAll(urlPath, "{registryName}", url.PathEscape(registryName))
176	if runID == "" {
177		return nil, errors.New("parameter runID cannot be empty")
178	}
179	urlPath = strings.ReplaceAll(urlPath, "{runId}", url.PathEscape(runID))
180	req, err := azcore.NewRequest(ctx, http.MethodGet, azcore.JoinPaths(client.con.Endpoint(), urlPath))
181	if err != nil {
182		return nil, err
183	}
184	req.Telemetry(telemetryInfo)
185	reqQP := req.URL.Query()
186	reqQP.Set("api-version", "2019-06-01-preview")
187	req.URL.RawQuery = reqQP.Encode()
188	req.Header.Set("Accept", "application/json")
189	return req, nil
190}
191
192// getHandleResponse handles the Get response.
193func (client *RunsClient) getHandleResponse(resp *azcore.Response) (RunResponse, error) {
194	var val *Run
195	if err := resp.UnmarshalAsJSON(&val); err != nil {
196		return RunResponse{}, err
197	}
198	return RunResponse{RawResponse: resp.Response, Run: val}, nil
199}
200
201// getHandleError handles the Get error response.
202func (client *RunsClient) getHandleError(resp *azcore.Response) error {
203	body, err := resp.Payload()
204	if err != nil {
205		return azcore.NewResponseError(err, resp.Response)
206	}
207	errType := ErrorResponse{raw: string(body)}
208	if err := resp.UnmarshalAsJSON(&errType); err != nil {
209		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
210	}
211	return azcore.NewResponseError(&errType, resp.Response)
212}
213
214// GetLogSasURL - Gets a link to download the run logs.
215// If the operation fails it returns the *ErrorResponse error type.
216func (client *RunsClient) GetLogSasURL(ctx context.Context, resourceGroupName string, registryName string, runID string, options *RunsGetLogSasURLOptions) (RunGetLogResultResponse, error) {
217	req, err := client.getLogSasURLCreateRequest(ctx, resourceGroupName, registryName, runID, options)
218	if err != nil {
219		return RunGetLogResultResponse{}, err
220	}
221	resp, err := client.con.Pipeline().Do(req)
222	if err != nil {
223		return RunGetLogResultResponse{}, err
224	}
225	if !resp.HasStatusCode(http.StatusOK) {
226		return RunGetLogResultResponse{}, client.getLogSasURLHandleError(resp)
227	}
228	return client.getLogSasURLHandleResponse(resp)
229}
230
231// getLogSasURLCreateRequest creates the GetLogSasURL request.
232func (client *RunsClient) getLogSasURLCreateRequest(ctx context.Context, resourceGroupName string, registryName string, runID string, options *RunsGetLogSasURLOptions) (*azcore.Request, error) {
233	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerRegistry/registries/{registryName}/runs/{runId}/listLogSasUrl"
234	if client.subscriptionID == "" {
235		return nil, errors.New("parameter client.subscriptionID cannot be empty")
236	}
237	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
238	if resourceGroupName == "" {
239		return nil, errors.New("parameter resourceGroupName cannot be empty")
240	}
241	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
242	if registryName == "" {
243		return nil, errors.New("parameter registryName cannot be empty")
244	}
245	urlPath = strings.ReplaceAll(urlPath, "{registryName}", url.PathEscape(registryName))
246	if runID == "" {
247		return nil, errors.New("parameter runID cannot be empty")
248	}
249	urlPath = strings.ReplaceAll(urlPath, "{runId}", url.PathEscape(runID))
250	req, err := azcore.NewRequest(ctx, http.MethodPost, azcore.JoinPaths(client.con.Endpoint(), urlPath))
251	if err != nil {
252		return nil, err
253	}
254	req.Telemetry(telemetryInfo)
255	reqQP := req.URL.Query()
256	reqQP.Set("api-version", "2019-06-01-preview")
257	req.URL.RawQuery = reqQP.Encode()
258	req.Header.Set("Accept", "application/json")
259	return req, nil
260}
261
262// getLogSasURLHandleResponse handles the GetLogSasURL response.
263func (client *RunsClient) getLogSasURLHandleResponse(resp *azcore.Response) (RunGetLogResultResponse, error) {
264	var val *RunGetLogResult
265	if err := resp.UnmarshalAsJSON(&val); err != nil {
266		return RunGetLogResultResponse{}, err
267	}
268	return RunGetLogResultResponse{RawResponse: resp.Response, RunGetLogResult: val}, nil
269}
270
271// getLogSasURLHandleError handles the GetLogSasURL error response.
272func (client *RunsClient) getLogSasURLHandleError(resp *azcore.Response) error {
273	body, err := resp.Payload()
274	if err != nil {
275		return azcore.NewResponseError(err, resp.Response)
276	}
277	errType := ErrorResponse{raw: string(body)}
278	if err := resp.UnmarshalAsJSON(&errType); err != nil {
279		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
280	}
281	return azcore.NewResponseError(&errType, resp.Response)
282}
283
284// List - Gets all the runs for a registry.
285// If the operation fails it returns the *ErrorResponse error type.
286func (client *RunsClient) List(resourceGroupName string, registryName string, options *RunsListOptions) RunListResultPager {
287	return &runListResultPager{
288		pipeline: client.con.Pipeline(),
289		requester: func(ctx context.Context) (*azcore.Request, error) {
290			return client.listCreateRequest(ctx, resourceGroupName, registryName, options)
291		},
292		responder: client.listHandleResponse,
293		errorer:   client.listHandleError,
294		advancer: func(ctx context.Context, resp RunListResultResponse) (*azcore.Request, error) {
295			return azcore.NewRequest(ctx, http.MethodGet, *resp.RunListResult.NextLink)
296		},
297		statusCodes: []int{http.StatusOK},
298	}
299}
300
301// listCreateRequest creates the List request.
302func (client *RunsClient) listCreateRequest(ctx context.Context, resourceGroupName string, registryName string, options *RunsListOptions) (*azcore.Request, error) {
303	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerRegistry/registries/{registryName}/runs"
304	if client.subscriptionID == "" {
305		return nil, errors.New("parameter client.subscriptionID cannot be empty")
306	}
307	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
308	if resourceGroupName == "" {
309		return nil, errors.New("parameter resourceGroupName cannot be empty")
310	}
311	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
312	if registryName == "" {
313		return nil, errors.New("parameter registryName cannot be empty")
314	}
315	urlPath = strings.ReplaceAll(urlPath, "{registryName}", url.PathEscape(registryName))
316	req, err := azcore.NewRequest(ctx, http.MethodGet, azcore.JoinPaths(client.con.Endpoint(), urlPath))
317	if err != nil {
318		return nil, err
319	}
320	req.Telemetry(telemetryInfo)
321	reqQP := req.URL.Query()
322	reqQP.Set("api-version", "2019-06-01-preview")
323	if options != nil && options.Filter != nil {
324		reqQP.Set("$filter", *options.Filter)
325	}
326	if options != nil && options.Top != nil {
327		reqQP.Set("$top", strconv.FormatInt(int64(*options.Top), 10))
328	}
329	req.URL.RawQuery = reqQP.Encode()
330	req.Header.Set("Accept", "application/json")
331	return req, nil
332}
333
334// listHandleResponse handles the List response.
335func (client *RunsClient) listHandleResponse(resp *azcore.Response) (RunListResultResponse, error) {
336	var val *RunListResult
337	if err := resp.UnmarshalAsJSON(&val); err != nil {
338		return RunListResultResponse{}, err
339	}
340	return RunListResultResponse{RawResponse: resp.Response, RunListResult: val}, nil
341}
342
343// listHandleError handles the List error response.
344func (client *RunsClient) listHandleError(resp *azcore.Response) error {
345	body, err := resp.Payload()
346	if err != nil {
347		return azcore.NewResponseError(err, resp.Response)
348	}
349	errType := ErrorResponse{raw: string(body)}
350	if err := resp.UnmarshalAsJSON(&errType); err != nil {
351		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
352	}
353	return azcore.NewResponseError(&errType, resp.Response)
354}
355
356// BeginUpdate - Patch the run properties.
357// If the operation fails it returns the *ErrorResponse error type.
358func (client *RunsClient) BeginUpdate(ctx context.Context, resourceGroupName string, registryName string, runID string, runUpdateParameters RunUpdateParameters, options *RunsBeginUpdateOptions) (RunPollerResponse, error) {
359	resp, err := client.update(ctx, resourceGroupName, registryName, runID, runUpdateParameters, options)
360	if err != nil {
361		return RunPollerResponse{}, err
362	}
363	result := RunPollerResponse{
364		RawResponse: resp.Response,
365	}
366	pt, err := armcore.NewLROPoller("RunsClient.Update", "", resp, client.con.Pipeline(), client.updateHandleError)
367	if err != nil {
368		return RunPollerResponse{}, err
369	}
370	poller := &runPoller{
371		pt: pt,
372	}
373	result.Poller = poller
374	result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (RunResponse, error) {
375		return poller.pollUntilDone(ctx, frequency)
376	}
377	return result, nil
378}
379
380// ResumeUpdate creates a new RunPoller from the specified resume token.
381// token - The value must come from a previous call to RunPoller.ResumeToken().
382func (client *RunsClient) ResumeUpdate(ctx context.Context, token string) (RunPollerResponse, error) {
383	pt, err := armcore.NewLROPollerFromResumeToken("RunsClient.Update", token, client.con.Pipeline(), client.updateHandleError)
384	if err != nil {
385		return RunPollerResponse{}, err
386	}
387	poller := &runPoller{
388		pt: pt,
389	}
390	resp, err := poller.Poll(ctx)
391	if err != nil {
392		return RunPollerResponse{}, err
393	}
394	result := RunPollerResponse{
395		RawResponse: resp,
396	}
397	result.Poller = poller
398	result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (RunResponse, error) {
399		return poller.pollUntilDone(ctx, frequency)
400	}
401	return result, nil
402}
403
404// Update - Patch the run properties.
405// If the operation fails it returns the *ErrorResponse error type.
406func (client *RunsClient) update(ctx context.Context, resourceGroupName string, registryName string, runID string, runUpdateParameters RunUpdateParameters, options *RunsBeginUpdateOptions) (*azcore.Response, error) {
407	req, err := client.updateCreateRequest(ctx, resourceGroupName, registryName, runID, runUpdateParameters, options)
408	if err != nil {
409		return nil, err
410	}
411	resp, err := client.con.Pipeline().Do(req)
412	if err != nil {
413		return nil, err
414	}
415	if !resp.HasStatusCode(http.StatusOK, http.StatusCreated) {
416		return nil, client.updateHandleError(resp)
417	}
418	return resp, nil
419}
420
421// updateCreateRequest creates the Update request.
422func (client *RunsClient) updateCreateRequest(ctx context.Context, resourceGroupName string, registryName string, runID string, runUpdateParameters RunUpdateParameters, options *RunsBeginUpdateOptions) (*azcore.Request, error) {
423	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerRegistry/registries/{registryName}/runs/{runId}"
424	if client.subscriptionID == "" {
425		return nil, errors.New("parameter client.subscriptionID cannot be empty")
426	}
427	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
428	if resourceGroupName == "" {
429		return nil, errors.New("parameter resourceGroupName cannot be empty")
430	}
431	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
432	if registryName == "" {
433		return nil, errors.New("parameter registryName cannot be empty")
434	}
435	urlPath = strings.ReplaceAll(urlPath, "{registryName}", url.PathEscape(registryName))
436	if runID == "" {
437		return nil, errors.New("parameter runID cannot be empty")
438	}
439	urlPath = strings.ReplaceAll(urlPath, "{runId}", url.PathEscape(runID))
440	req, err := azcore.NewRequest(ctx, http.MethodPatch, azcore.JoinPaths(client.con.Endpoint(), urlPath))
441	if err != nil {
442		return nil, err
443	}
444	req.Telemetry(telemetryInfo)
445	reqQP := req.URL.Query()
446	reqQP.Set("api-version", "2019-06-01-preview")
447	req.URL.RawQuery = reqQP.Encode()
448	req.Header.Set("Accept", "application/json")
449	return req, req.MarshalAsJSON(runUpdateParameters)
450}
451
452// updateHandleError handles the Update error response.
453func (client *RunsClient) updateHandleError(resp *azcore.Response) error {
454	body, err := resp.Payload()
455	if err != nil {
456		return azcore.NewResponseError(err, resp.Response)
457	}
458	errType := ErrorResponse{raw: string(body)}
459	if err := resp.UnmarshalAsJSON(&errType); err != nil {
460		return azcore.NewResponseError(fmt.Errorf("%s\n%s", string(body), err), resp.Response)
461	}
462	return azcore.NewResponseError(&errType, resp.Response)
463}
464