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	"github.com/Azure/azure-sdk-for-go/sdk/armcore"
14	"github.com/Azure/azure-sdk-for-go/sdk/azcore"
15	"net/http"
16	"net/url"
17	"strings"
18	"time"
19)
20
21// PipelineRunsClient contains the methods for the PipelineRuns group.
22// Don't use this type directly, use NewPipelineRunsClient() instead.
23type PipelineRunsClient struct {
24	con            *armcore.Connection
25	subscriptionID string
26}
27
28// NewPipelineRunsClient creates a new instance of PipelineRunsClient with the specified values.
29func NewPipelineRunsClient(con *armcore.Connection, subscriptionID string) *PipelineRunsClient {
30	return &PipelineRunsClient{con: con, subscriptionID: subscriptionID}
31}
32
33// BeginCreate - Creates a pipeline run for a container registry with the specified parameters
34// If the operation fails it returns a generic error.
35func (client *PipelineRunsClient) BeginCreate(ctx context.Context, resourceGroupName string, registryName string, pipelineRunName string, pipelineRunCreateParameters PipelineRun, options *PipelineRunsBeginCreateOptions) (PipelineRunPollerResponse, error) {
36	resp, err := client.create(ctx, resourceGroupName, registryName, pipelineRunName, pipelineRunCreateParameters, options)
37	if err != nil {
38		return PipelineRunPollerResponse{}, err
39	}
40	result := PipelineRunPollerResponse{
41		RawResponse: resp.Response,
42	}
43	pt, err := armcore.NewLROPoller("PipelineRunsClient.Create", "", resp, client.con.Pipeline(), client.createHandleError)
44	if err != nil {
45		return PipelineRunPollerResponse{}, err
46	}
47	poller := &pipelineRunPoller{
48		pt: pt,
49	}
50	result.Poller = poller
51	result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (PipelineRunResponseType, error) {
52		return poller.pollUntilDone(ctx, frequency)
53	}
54	return result, nil
55}
56
57// ResumeCreate creates a new PipelineRunPoller from the specified resume token.
58// token - The value must come from a previous call to PipelineRunPoller.ResumeToken().
59func (client *PipelineRunsClient) ResumeCreate(ctx context.Context, token string) (PipelineRunPollerResponse, error) {
60	pt, err := armcore.NewLROPollerFromResumeToken("PipelineRunsClient.Create", token, client.con.Pipeline(), client.createHandleError)
61	if err != nil {
62		return PipelineRunPollerResponse{}, err
63	}
64	poller := &pipelineRunPoller{
65		pt: pt,
66	}
67	resp, err := poller.Poll(ctx)
68	if err != nil {
69		return PipelineRunPollerResponse{}, err
70	}
71	result := PipelineRunPollerResponse{
72		RawResponse: resp,
73	}
74	result.Poller = poller
75	result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (PipelineRunResponseType, error) {
76		return poller.pollUntilDone(ctx, frequency)
77	}
78	return result, nil
79}
80
81// Create - Creates a pipeline run for a container registry with the specified parameters
82// If the operation fails it returns a generic error.
83func (client *PipelineRunsClient) create(ctx context.Context, resourceGroupName string, registryName string, pipelineRunName string, pipelineRunCreateParameters PipelineRun, options *PipelineRunsBeginCreateOptions) (*azcore.Response, error) {
84	req, err := client.createCreateRequest(ctx, resourceGroupName, registryName, pipelineRunName, pipelineRunCreateParameters, options)
85	if err != nil {
86		return nil, err
87	}
88	resp, err := client.con.Pipeline().Do(req)
89	if err != nil {
90		return nil, err
91	}
92	if !resp.HasStatusCode(http.StatusOK, http.StatusCreated) {
93		return nil, client.createHandleError(resp)
94	}
95	return resp, nil
96}
97
98// createCreateRequest creates the Create request.
99func (client *PipelineRunsClient) createCreateRequest(ctx context.Context, resourceGroupName string, registryName string, pipelineRunName string, pipelineRunCreateParameters PipelineRun, options *PipelineRunsBeginCreateOptions) (*azcore.Request, error) {
100	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerRegistry/registries/{registryName}/pipelineRuns/{pipelineRunName}"
101	if client.subscriptionID == "" {
102		return nil, errors.New("parameter client.subscriptionID cannot be empty")
103	}
104	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
105	if resourceGroupName == "" {
106		return nil, errors.New("parameter resourceGroupName cannot be empty")
107	}
108	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
109	if registryName == "" {
110		return nil, errors.New("parameter registryName cannot be empty")
111	}
112	urlPath = strings.ReplaceAll(urlPath, "{registryName}", url.PathEscape(registryName))
113	if pipelineRunName == "" {
114		return nil, errors.New("parameter pipelineRunName cannot be empty")
115	}
116	urlPath = strings.ReplaceAll(urlPath, "{pipelineRunName}", url.PathEscape(pipelineRunName))
117	req, err := azcore.NewRequest(ctx, http.MethodPut, azcore.JoinPaths(client.con.Endpoint(), urlPath))
118	if err != nil {
119		return nil, err
120	}
121	req.Telemetry(telemetryInfo)
122	reqQP := req.URL.Query()
123	reqQP.Set("api-version", "2021-06-01-preview")
124	req.URL.RawQuery = reqQP.Encode()
125	req.Header.Set("Accept", "application/json")
126	return req, req.MarshalAsJSON(pipelineRunCreateParameters)
127}
128
129// createHandleError handles the Create error response.
130func (client *PipelineRunsClient) createHandleError(resp *azcore.Response) error {
131	body, err := resp.Payload()
132	if err != nil {
133		return azcore.NewResponseError(err, resp.Response)
134	}
135	if len(body) == 0 {
136		return azcore.NewResponseError(errors.New(resp.Status), resp.Response)
137	}
138	return azcore.NewResponseError(errors.New(string(body)), resp.Response)
139}
140
141// BeginDelete - Deletes a pipeline run from a container registry.
142// If the operation fails it returns a generic error.
143func (client *PipelineRunsClient) BeginDelete(ctx context.Context, resourceGroupName string, registryName string, pipelineRunName string, options *PipelineRunsBeginDeleteOptions) (HTTPPollerResponse, error) {
144	resp, err := client.deleteOperation(ctx, resourceGroupName, registryName, pipelineRunName, options)
145	if err != nil {
146		return HTTPPollerResponse{}, err
147	}
148	result := HTTPPollerResponse{
149		RawResponse: resp.Response,
150	}
151	pt, err := armcore.NewLROPoller("PipelineRunsClient.Delete", "", resp, client.con.Pipeline(), client.deleteHandleError)
152	if err != nil {
153		return HTTPPollerResponse{}, err
154	}
155	poller := &httpPoller{
156		pt: pt,
157	}
158	result.Poller = poller
159	result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (*http.Response, error) {
160		return poller.pollUntilDone(ctx, frequency)
161	}
162	return result, nil
163}
164
165// ResumeDelete creates a new HTTPPoller from the specified resume token.
166// token - The value must come from a previous call to HTTPPoller.ResumeToken().
167func (client *PipelineRunsClient) ResumeDelete(ctx context.Context, token string) (HTTPPollerResponse, error) {
168	pt, err := armcore.NewLROPollerFromResumeToken("PipelineRunsClient.Delete", token, client.con.Pipeline(), client.deleteHandleError)
169	if err != nil {
170		return HTTPPollerResponse{}, err
171	}
172	poller := &httpPoller{
173		pt: pt,
174	}
175	resp, err := poller.Poll(ctx)
176	if err != nil {
177		return HTTPPollerResponse{}, err
178	}
179	result := HTTPPollerResponse{
180		RawResponse: resp,
181	}
182	result.Poller = poller
183	result.PollUntilDone = func(ctx context.Context, frequency time.Duration) (*http.Response, error) {
184		return poller.pollUntilDone(ctx, frequency)
185	}
186	return result, nil
187}
188
189// Delete - Deletes a pipeline run from a container registry.
190// If the operation fails it returns a generic error.
191func (client *PipelineRunsClient) deleteOperation(ctx context.Context, resourceGroupName string, registryName string, pipelineRunName string, options *PipelineRunsBeginDeleteOptions) (*azcore.Response, error) {
192	req, err := client.deleteCreateRequest(ctx, resourceGroupName, registryName, pipelineRunName, options)
193	if err != nil {
194		return nil, err
195	}
196	resp, err := client.con.Pipeline().Do(req)
197	if err != nil {
198		return nil, err
199	}
200	if !resp.HasStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent) {
201		return nil, client.deleteHandleError(resp)
202	}
203	return resp, nil
204}
205
206// deleteCreateRequest creates the Delete request.
207func (client *PipelineRunsClient) deleteCreateRequest(ctx context.Context, resourceGroupName string, registryName string, pipelineRunName string, options *PipelineRunsBeginDeleteOptions) (*azcore.Request, error) {
208	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerRegistry/registries/{registryName}/pipelineRuns/{pipelineRunName}"
209	if client.subscriptionID == "" {
210		return nil, errors.New("parameter client.subscriptionID cannot be empty")
211	}
212	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
213	if resourceGroupName == "" {
214		return nil, errors.New("parameter resourceGroupName cannot be empty")
215	}
216	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
217	if registryName == "" {
218		return nil, errors.New("parameter registryName cannot be empty")
219	}
220	urlPath = strings.ReplaceAll(urlPath, "{registryName}", url.PathEscape(registryName))
221	if pipelineRunName == "" {
222		return nil, errors.New("parameter pipelineRunName cannot be empty")
223	}
224	urlPath = strings.ReplaceAll(urlPath, "{pipelineRunName}", url.PathEscape(pipelineRunName))
225	req, err := azcore.NewRequest(ctx, http.MethodDelete, azcore.JoinPaths(client.con.Endpoint(), urlPath))
226	if err != nil {
227		return nil, err
228	}
229	req.Telemetry(telemetryInfo)
230	reqQP := req.URL.Query()
231	reqQP.Set("api-version", "2021-06-01-preview")
232	req.URL.RawQuery = reqQP.Encode()
233	return req, nil
234}
235
236// deleteHandleError handles the Delete error response.
237func (client *PipelineRunsClient) deleteHandleError(resp *azcore.Response) error {
238	body, err := resp.Payload()
239	if err != nil {
240		return azcore.NewResponseError(err, resp.Response)
241	}
242	if len(body) == 0 {
243		return azcore.NewResponseError(errors.New(resp.Status), resp.Response)
244	}
245	return azcore.NewResponseError(errors.New(string(body)), resp.Response)
246}
247
248// Get - Gets the detailed information for a given pipeline run.
249// If the operation fails it returns a generic error.
250func (client *PipelineRunsClient) Get(ctx context.Context, resourceGroupName string, registryName string, pipelineRunName string, options *PipelineRunsGetOptions) (PipelineRunResponseType, error) {
251	req, err := client.getCreateRequest(ctx, resourceGroupName, registryName, pipelineRunName, options)
252	if err != nil {
253		return PipelineRunResponseType{}, err
254	}
255	resp, err := client.con.Pipeline().Do(req)
256	if err != nil {
257		return PipelineRunResponseType{}, err
258	}
259	if !resp.HasStatusCode(http.StatusOK) {
260		return PipelineRunResponseType{}, client.getHandleError(resp)
261	}
262	return client.getHandleResponse(resp)
263}
264
265// getCreateRequest creates the Get request.
266func (client *PipelineRunsClient) getCreateRequest(ctx context.Context, resourceGroupName string, registryName string, pipelineRunName string, options *PipelineRunsGetOptions) (*azcore.Request, error) {
267	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerRegistry/registries/{registryName}/pipelineRuns/{pipelineRunName}"
268	if client.subscriptionID == "" {
269		return nil, errors.New("parameter client.subscriptionID cannot be empty")
270	}
271	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
272	if resourceGroupName == "" {
273		return nil, errors.New("parameter resourceGroupName cannot be empty")
274	}
275	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
276	if registryName == "" {
277		return nil, errors.New("parameter registryName cannot be empty")
278	}
279	urlPath = strings.ReplaceAll(urlPath, "{registryName}", url.PathEscape(registryName))
280	if pipelineRunName == "" {
281		return nil, errors.New("parameter pipelineRunName cannot be empty")
282	}
283	urlPath = strings.ReplaceAll(urlPath, "{pipelineRunName}", url.PathEscape(pipelineRunName))
284	req, err := azcore.NewRequest(ctx, http.MethodGet, azcore.JoinPaths(client.con.Endpoint(), urlPath))
285	if err != nil {
286		return nil, err
287	}
288	req.Telemetry(telemetryInfo)
289	reqQP := req.URL.Query()
290	reqQP.Set("api-version", "2021-06-01-preview")
291	req.URL.RawQuery = reqQP.Encode()
292	req.Header.Set("Accept", "application/json")
293	return req, nil
294}
295
296// getHandleResponse handles the Get response.
297func (client *PipelineRunsClient) getHandleResponse(resp *azcore.Response) (PipelineRunResponseType, error) {
298	var val *PipelineRun
299	if err := resp.UnmarshalAsJSON(&val); err != nil {
300		return PipelineRunResponseType{}, err
301	}
302	return PipelineRunResponseType{RawResponse: resp.Response, PipelineRun: val}, nil
303}
304
305// getHandleError handles the Get error response.
306func (client *PipelineRunsClient) getHandleError(resp *azcore.Response) error {
307	body, err := resp.Payload()
308	if err != nil {
309		return azcore.NewResponseError(err, resp.Response)
310	}
311	if len(body) == 0 {
312		return azcore.NewResponseError(errors.New(resp.Status), resp.Response)
313	}
314	return azcore.NewResponseError(errors.New(string(body)), resp.Response)
315}
316
317// List - Lists all the pipeline runs for the specified container registry.
318// If the operation fails it returns a generic error.
319func (client *PipelineRunsClient) List(resourceGroupName string, registryName string, options *PipelineRunsListOptions) PipelineRunListResultPager {
320	return &pipelineRunListResultPager{
321		pipeline: client.con.Pipeline(),
322		requester: func(ctx context.Context) (*azcore.Request, error) {
323			return client.listCreateRequest(ctx, resourceGroupName, registryName, options)
324		},
325		responder: client.listHandleResponse,
326		errorer:   client.listHandleError,
327		advancer: func(ctx context.Context, resp PipelineRunListResultResponse) (*azcore.Request, error) {
328			return azcore.NewRequest(ctx, http.MethodGet, *resp.PipelineRunListResult.NextLink)
329		},
330		statusCodes: []int{http.StatusOK},
331	}
332}
333
334// listCreateRequest creates the List request.
335func (client *PipelineRunsClient) listCreateRequest(ctx context.Context, resourceGroupName string, registryName string, options *PipelineRunsListOptions) (*azcore.Request, error) {
336	urlPath := "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ContainerRegistry/registries/{registryName}/pipelineRuns"
337	if client.subscriptionID == "" {
338		return nil, errors.New("parameter client.subscriptionID cannot be empty")
339	}
340	urlPath = strings.ReplaceAll(urlPath, "{subscriptionId}", url.PathEscape(client.subscriptionID))
341	if resourceGroupName == "" {
342		return nil, errors.New("parameter resourceGroupName cannot be empty")
343	}
344	urlPath = strings.ReplaceAll(urlPath, "{resourceGroupName}", url.PathEscape(resourceGroupName))
345	if registryName == "" {
346		return nil, errors.New("parameter registryName cannot be empty")
347	}
348	urlPath = strings.ReplaceAll(urlPath, "{registryName}", url.PathEscape(registryName))
349	req, err := azcore.NewRequest(ctx, http.MethodGet, azcore.JoinPaths(client.con.Endpoint(), urlPath))
350	if err != nil {
351		return nil, err
352	}
353	req.Telemetry(telemetryInfo)
354	reqQP := req.URL.Query()
355	reqQP.Set("api-version", "2021-06-01-preview")
356	req.URL.RawQuery = reqQP.Encode()
357	req.Header.Set("Accept", "application/json")
358	return req, nil
359}
360
361// listHandleResponse handles the List response.
362func (client *PipelineRunsClient) listHandleResponse(resp *azcore.Response) (PipelineRunListResultResponse, error) {
363	var val *PipelineRunListResult
364	if err := resp.UnmarshalAsJSON(&val); err != nil {
365		return PipelineRunListResultResponse{}, err
366	}
367	return PipelineRunListResultResponse{RawResponse: resp.Response, PipelineRunListResult: val}, nil
368}
369
370// listHandleError handles the List error response.
371func (client *PipelineRunsClient) listHandleError(resp *azcore.Response) error {
372	body, err := resp.Payload()
373	if err != nil {
374		return azcore.NewResponseError(err, resp.Response)
375	}
376	if len(body) == 0 {
377		return azcore.NewResponseError(errors.New(resp.Status), resp.Response)
378	}
379	return azcore.NewResponseError(errors.New(string(body)), resp.Response)
380}
381