1 package network
2
3
4
5
6
7
8
9 import (
10 "context"
11 "github.com/Azure/go-autorest/autorest"
12 "github.com/Azure/go-autorest/autorest/azure"
13 "github.com/Azure/go-autorest/tracing"
14 "net/http"
15 )
16
17
18 type LoadBalancerProbesClient struct {
19 BaseClient
20 }
21
22
23 func NewLoadBalancerProbesClient(subscriptionID string) LoadBalancerProbesClient {
24 return NewLoadBalancerProbesClientWithBaseURI(DefaultBaseURI, subscriptionID)
25 }
26
27
28
29
30 func NewLoadBalancerProbesClientWithBaseURI(baseURI string, subscriptionID string) LoadBalancerProbesClient {
31 return LoadBalancerProbesClient{NewWithBaseURI(baseURI, subscriptionID)}
32 }
33
34
35
36
37
38
39 func (client LoadBalancerProbesClient) Get(ctx context.Context, resourceGroupName string, loadBalancerName string, probeName string) (result Probe, err error) {
40 if tracing.IsEnabled() {
41 ctx = tracing.StartSpan(ctx, fqdn+"/LoadBalancerProbesClient.Get")
42 defer func() {
43 sc := -1
44 if result.Response.Response != nil {
45 sc = result.Response.Response.StatusCode
46 }
47 tracing.EndSpan(ctx, sc, err)
48 }()
49 }
50 req, err := client.GetPreparer(ctx, resourceGroupName, loadBalancerName, probeName)
51 if err != nil {
52 err = autorest.NewErrorWithError(err, "network.LoadBalancerProbesClient", "Get", nil, "Failure preparing request")
53 return
54 }
55
56 resp, err := client.GetSender(req)
57 if err != nil {
58 result.Response = autorest.Response{Response: resp}
59 err = autorest.NewErrorWithError(err, "network.LoadBalancerProbesClient", "Get", resp, "Failure sending request")
60 return
61 }
62
63 result, err = client.GetResponder(resp)
64 if err != nil {
65 err = autorest.NewErrorWithError(err, "network.LoadBalancerProbesClient", "Get", resp, "Failure responding to request")
66 return
67 }
68
69 return
70 }
71
72
73 func (client LoadBalancerProbesClient) GetPreparer(ctx context.Context, resourceGroupName string, loadBalancerName string, probeName string) (*http.Request, error) {
74 pathParameters := map[string]interface{}{
75 "loadBalancerName": autorest.Encode("path", loadBalancerName),
76 "probeName": autorest.Encode("path", probeName),
77 "resourceGroupName": autorest.Encode("path", resourceGroupName),
78 "subscriptionId": autorest.Encode("path", client.SubscriptionID),
79 }
80
81 const APIVersion = "2018-08-01"
82 queryParameters := map[string]interface{}{
83 "api-version": APIVersion,
84 }
85
86 preparer := autorest.CreatePreparer(
87 autorest.AsGet(),
88 autorest.WithBaseURL(client.BaseURI),
89 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/loadBalancers/{loadBalancerName}/probes/{probeName}", pathParameters),
90 autorest.WithQueryParameters(queryParameters))
91 return preparer.Prepare((&http.Request{}).WithContext(ctx))
92 }
93
94
95
96 func (client LoadBalancerProbesClient) GetSender(req *http.Request) (*http.Response, error) {
97 return client.Send(req, azure.DoRetryWithRegistration(client.Client))
98 }
99
100
101
102 func (client LoadBalancerProbesClient) GetResponder(resp *http.Response) (result Probe, err error) {
103 err = autorest.Respond(
104 resp,
105 azure.WithErrorUnlessStatusCode(http.StatusOK),
106 autorest.ByUnmarshallingJSON(&result),
107 autorest.ByClosing())
108 result.Response = autorest.Response{Response: resp}
109 return
110 }
111
112
113
114
115
116 func (client LoadBalancerProbesClient) List(ctx context.Context, resourceGroupName string, loadBalancerName string) (result LoadBalancerProbeListResultPage, err error) {
117 if tracing.IsEnabled() {
118 ctx = tracing.StartSpan(ctx, fqdn+"/LoadBalancerProbesClient.List")
119 defer func() {
120 sc := -1
121 if result.lbplr.Response.Response != nil {
122 sc = result.lbplr.Response.Response.StatusCode
123 }
124 tracing.EndSpan(ctx, sc, err)
125 }()
126 }
127 result.fn = client.listNextResults
128 req, err := client.ListPreparer(ctx, resourceGroupName, loadBalancerName)
129 if err != nil {
130 err = autorest.NewErrorWithError(err, "network.LoadBalancerProbesClient", "List", nil, "Failure preparing request")
131 return
132 }
133
134 resp, err := client.ListSender(req)
135 if err != nil {
136 result.lbplr.Response = autorest.Response{Response: resp}
137 err = autorest.NewErrorWithError(err, "network.LoadBalancerProbesClient", "List", resp, "Failure sending request")
138 return
139 }
140
141 result.lbplr, err = client.ListResponder(resp)
142 if err != nil {
143 err = autorest.NewErrorWithError(err, "network.LoadBalancerProbesClient", "List", resp, "Failure responding to request")
144 return
145 }
146 if result.lbplr.hasNextLink() && result.lbplr.IsEmpty() {
147 err = result.NextWithContext(ctx)
148 return
149 }
150
151 return
152 }
153
154
155 func (client LoadBalancerProbesClient) ListPreparer(ctx context.Context, resourceGroupName string, loadBalancerName string) (*http.Request, error) {
156 pathParameters := map[string]interface{}{
157 "loadBalancerName": autorest.Encode("path", loadBalancerName),
158 "resourceGroupName": autorest.Encode("path", resourceGroupName),
159 "subscriptionId": autorest.Encode("path", client.SubscriptionID),
160 }
161
162 const APIVersion = "2018-08-01"
163 queryParameters := map[string]interface{}{
164 "api-version": APIVersion,
165 }
166
167 preparer := autorest.CreatePreparer(
168 autorest.AsGet(),
169 autorest.WithBaseURL(client.BaseURI),
170 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Network/loadBalancers/{loadBalancerName}/probes", pathParameters),
171 autorest.WithQueryParameters(queryParameters))
172 return preparer.Prepare((&http.Request{}).WithContext(ctx))
173 }
174
175
176
177 func (client LoadBalancerProbesClient) ListSender(req *http.Request) (*http.Response, error) {
178 return client.Send(req, azure.DoRetryWithRegistration(client.Client))
179 }
180
181
182
183 func (client LoadBalancerProbesClient) ListResponder(resp *http.Response) (result LoadBalancerProbeListResult, err error) {
184 err = autorest.Respond(
185 resp,
186 azure.WithErrorUnlessStatusCode(http.StatusOK),
187 autorest.ByUnmarshallingJSON(&result),
188 autorest.ByClosing())
189 result.Response = autorest.Response{Response: resp}
190 return
191 }
192
193
194 func (client LoadBalancerProbesClient) listNextResults(ctx context.Context, lastResults LoadBalancerProbeListResult) (result LoadBalancerProbeListResult, err error) {
195 req, err := lastResults.loadBalancerProbeListResultPreparer(ctx)
196 if err != nil {
197 return result, autorest.NewErrorWithError(err, "network.LoadBalancerProbesClient", "listNextResults", nil, "Failure preparing next results request")
198 }
199 if req == nil {
200 return
201 }
202 resp, err := client.ListSender(req)
203 if err != nil {
204 result.Response = autorest.Response{Response: resp}
205 return result, autorest.NewErrorWithError(err, "network.LoadBalancerProbesClient", "listNextResults", resp, "Failure sending next results request")
206 }
207 result, err = client.ListResponder(resp)
208 if err != nil {
209 err = autorest.NewErrorWithError(err, "network.LoadBalancerProbesClient", "listNextResults", resp, "Failure responding to next results request")
210 }
211 return
212 }
213
214
215 func (client LoadBalancerProbesClient) ListComplete(ctx context.Context, resourceGroupName string, loadBalancerName string) (result LoadBalancerProbeListResultIterator, err error) {
216 if tracing.IsEnabled() {
217 ctx = tracing.StartSpan(ctx, fqdn+"/LoadBalancerProbesClient.List")
218 defer func() {
219 sc := -1
220 if result.Response().Response.Response != nil {
221 sc = result.page.Response().Response.Response.StatusCode
222 }
223 tracing.EndSpan(ctx, sc, err)
224 }()
225 }
226 result.page, err = client.List(ctx, resourceGroupName, loadBalancerName)
227 return
228 }
229
View as plain text