1package signalr 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// 6// Code generated by Microsoft (R) AutoRest Code Generator. 7// Changes may cause incorrect behavior and will be lost if the code is regenerated. 8 9import ( 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// PrivateEndpointConnectionsClient is the REST API for Azure SignalR Service 18type PrivateEndpointConnectionsClient struct { 19 BaseClient 20} 21 22// NewPrivateEndpointConnectionsClient creates an instance of the PrivateEndpointConnectionsClient client. 23func NewPrivateEndpointConnectionsClient(subscriptionID string) PrivateEndpointConnectionsClient { 24 return NewPrivateEndpointConnectionsClientWithBaseURI(DefaultBaseURI, subscriptionID) 25} 26 27// NewPrivateEndpointConnectionsClientWithBaseURI creates an instance of the PrivateEndpointConnectionsClient client 28// using a custom endpoint. Use this when interacting with an Azure cloud that uses a non-standard base URI (sovereign 29// clouds, Azure stack). 30func NewPrivateEndpointConnectionsClientWithBaseURI(baseURI string, subscriptionID string) PrivateEndpointConnectionsClient { 31 return PrivateEndpointConnectionsClient{NewWithBaseURI(baseURI, subscriptionID)} 32} 33 34// Delete delete the specified private endpoint connection 35// Parameters: 36// privateEndpointConnectionName - the name of the private endpoint connection 37// resourceGroupName - the name of the resource group that contains the resource. You can obtain this value 38// from the Azure Resource Manager API or the portal. 39// resourceName - the name of the resource. 40func (client PrivateEndpointConnectionsClient) Delete(ctx context.Context, privateEndpointConnectionName string, resourceGroupName string, resourceName string) (result PrivateEndpointConnectionsDeleteFuture, err error) { 41 if tracing.IsEnabled() { 42 ctx = tracing.StartSpan(ctx, fqdn+"/PrivateEndpointConnectionsClient.Delete") 43 defer func() { 44 sc := -1 45 if result.FutureAPI != nil && result.FutureAPI.Response() != nil { 46 sc = result.FutureAPI.Response().StatusCode 47 } 48 tracing.EndSpan(ctx, sc, err) 49 }() 50 } 51 req, err := client.DeletePreparer(ctx, privateEndpointConnectionName, resourceGroupName, resourceName) 52 if err != nil { 53 err = autorest.NewErrorWithError(err, "signalr.PrivateEndpointConnectionsClient", "Delete", nil, "Failure preparing request") 54 return 55 } 56 57 result, err = client.DeleteSender(req) 58 if err != nil { 59 err = autorest.NewErrorWithError(err, "signalr.PrivateEndpointConnectionsClient", "Delete", nil, "Failure sending request") 60 return 61 } 62 63 return 64} 65 66// DeletePreparer prepares the Delete request. 67func (client PrivateEndpointConnectionsClient) DeletePreparer(ctx context.Context, privateEndpointConnectionName string, resourceGroupName string, resourceName string) (*http.Request, error) { 68 pathParameters := map[string]interface{}{ 69 "privateEndpointConnectionName": autorest.Encode("path", privateEndpointConnectionName), 70 "resourceGroupName": autorest.Encode("path", resourceGroupName), 71 "resourceName": autorest.Encode("path", resourceName), 72 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 73 } 74 75 const APIVersion = "2021-06-01-preview" 76 queryParameters := map[string]interface{}{ 77 "api-version": APIVersion, 78 } 79 80 preparer := autorest.CreatePreparer( 81 autorest.AsDelete(), 82 autorest.WithBaseURL(client.BaseURI), 83 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.SignalRService/signalR/{resourceName}/privateEndpointConnections/{privateEndpointConnectionName}", pathParameters), 84 autorest.WithQueryParameters(queryParameters)) 85 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 86} 87 88// DeleteSender sends the Delete request. The method will close the 89// http.Response Body if it receives an error. 90func (client PrivateEndpointConnectionsClient) DeleteSender(req *http.Request) (future PrivateEndpointConnectionsDeleteFuture, err error) { 91 var resp *http.Response 92 resp, err = client.Send(req, azure.DoRetryWithRegistration(client.Client)) 93 if err != nil { 94 return 95 } 96 var azf azure.Future 97 azf, err = azure.NewFutureFromResponse(resp) 98 future.FutureAPI = &azf 99 future.Result = future.result 100 return 101} 102 103// DeleteResponder handles the response to the Delete request. The method always 104// closes the http.Response Body. 105func (client PrivateEndpointConnectionsClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) { 106 err = autorest.Respond( 107 resp, 108 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted, http.StatusNoContent), 109 autorest.ByClosing()) 110 result.Response = resp 111 return 112} 113 114// Get get the specified private endpoint connection 115// Parameters: 116// privateEndpointConnectionName - the name of the private endpoint connection 117// resourceGroupName - the name of the resource group that contains the resource. You can obtain this value 118// from the Azure Resource Manager API or the portal. 119// resourceName - the name of the resource. 120func (client PrivateEndpointConnectionsClient) Get(ctx context.Context, privateEndpointConnectionName string, resourceGroupName string, resourceName string) (result PrivateEndpointConnection, err error) { 121 if tracing.IsEnabled() { 122 ctx = tracing.StartSpan(ctx, fqdn+"/PrivateEndpointConnectionsClient.Get") 123 defer func() { 124 sc := -1 125 if result.Response.Response != nil { 126 sc = result.Response.Response.StatusCode 127 } 128 tracing.EndSpan(ctx, sc, err) 129 }() 130 } 131 req, err := client.GetPreparer(ctx, privateEndpointConnectionName, resourceGroupName, resourceName) 132 if err != nil { 133 err = autorest.NewErrorWithError(err, "signalr.PrivateEndpointConnectionsClient", "Get", nil, "Failure preparing request") 134 return 135 } 136 137 resp, err := client.GetSender(req) 138 if err != nil { 139 result.Response = autorest.Response{Response: resp} 140 err = autorest.NewErrorWithError(err, "signalr.PrivateEndpointConnectionsClient", "Get", resp, "Failure sending request") 141 return 142 } 143 144 result, err = client.GetResponder(resp) 145 if err != nil { 146 err = autorest.NewErrorWithError(err, "signalr.PrivateEndpointConnectionsClient", "Get", resp, "Failure responding to request") 147 return 148 } 149 150 return 151} 152 153// GetPreparer prepares the Get request. 154func (client PrivateEndpointConnectionsClient) GetPreparer(ctx context.Context, privateEndpointConnectionName string, resourceGroupName string, resourceName string) (*http.Request, error) { 155 pathParameters := map[string]interface{}{ 156 "privateEndpointConnectionName": autorest.Encode("path", privateEndpointConnectionName), 157 "resourceGroupName": autorest.Encode("path", resourceGroupName), 158 "resourceName": autorest.Encode("path", resourceName), 159 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 160 } 161 162 const APIVersion = "2021-06-01-preview" 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.SignalRService/signalR/{resourceName}/privateEndpointConnections/{privateEndpointConnectionName}", pathParameters), 171 autorest.WithQueryParameters(queryParameters)) 172 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 173} 174 175// GetSender sends the Get request. The method will close the 176// http.Response Body if it receives an error. 177func (client PrivateEndpointConnectionsClient) GetSender(req *http.Request) (*http.Response, error) { 178 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 179} 180 181// GetResponder handles the response to the Get request. The method always 182// closes the http.Response Body. 183func (client PrivateEndpointConnectionsClient) GetResponder(resp *http.Response) (result PrivateEndpointConnection, 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// List list private endpoint connections 194// Parameters: 195// resourceGroupName - the name of the resource group that contains the resource. You can obtain this value 196// from the Azure Resource Manager API or the portal. 197// resourceName - the name of the resource. 198func (client PrivateEndpointConnectionsClient) List(ctx context.Context, resourceGroupName string, resourceName string) (result PrivateEndpointConnectionListPage, err error) { 199 if tracing.IsEnabled() { 200 ctx = tracing.StartSpan(ctx, fqdn+"/PrivateEndpointConnectionsClient.List") 201 defer func() { 202 sc := -1 203 if result.pecl.Response.Response != nil { 204 sc = result.pecl.Response.Response.StatusCode 205 } 206 tracing.EndSpan(ctx, sc, err) 207 }() 208 } 209 result.fn = client.listNextResults 210 req, err := client.ListPreparer(ctx, resourceGroupName, resourceName) 211 if err != nil { 212 err = autorest.NewErrorWithError(err, "signalr.PrivateEndpointConnectionsClient", "List", nil, "Failure preparing request") 213 return 214 } 215 216 resp, err := client.ListSender(req) 217 if err != nil { 218 result.pecl.Response = autorest.Response{Response: resp} 219 err = autorest.NewErrorWithError(err, "signalr.PrivateEndpointConnectionsClient", "List", resp, "Failure sending request") 220 return 221 } 222 223 result.pecl, err = client.ListResponder(resp) 224 if err != nil { 225 err = autorest.NewErrorWithError(err, "signalr.PrivateEndpointConnectionsClient", "List", resp, "Failure responding to request") 226 return 227 } 228 if result.pecl.hasNextLink() && result.pecl.IsEmpty() { 229 err = result.NextWithContext(ctx) 230 return 231 } 232 233 return 234} 235 236// ListPreparer prepares the List request. 237func (client PrivateEndpointConnectionsClient) ListPreparer(ctx context.Context, resourceGroupName string, resourceName string) (*http.Request, error) { 238 pathParameters := map[string]interface{}{ 239 "resourceGroupName": autorest.Encode("path", resourceGroupName), 240 "resourceName": autorest.Encode("path", resourceName), 241 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 242 } 243 244 const APIVersion = "2021-06-01-preview" 245 queryParameters := map[string]interface{}{ 246 "api-version": APIVersion, 247 } 248 249 preparer := autorest.CreatePreparer( 250 autorest.AsGet(), 251 autorest.WithBaseURL(client.BaseURI), 252 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.SignalRService/signalR/{resourceName}/privateEndpointConnections", pathParameters), 253 autorest.WithQueryParameters(queryParameters)) 254 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 255} 256 257// ListSender sends the List request. The method will close the 258// http.Response Body if it receives an error. 259func (client PrivateEndpointConnectionsClient) ListSender(req *http.Request) (*http.Response, error) { 260 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 261} 262 263// ListResponder handles the response to the List request. The method always 264// closes the http.Response Body. 265func (client PrivateEndpointConnectionsClient) ListResponder(resp *http.Response) (result PrivateEndpointConnectionList, err error) { 266 err = autorest.Respond( 267 resp, 268 azure.WithErrorUnlessStatusCode(http.StatusOK), 269 autorest.ByUnmarshallingJSON(&result), 270 autorest.ByClosing()) 271 result.Response = autorest.Response{Response: resp} 272 return 273} 274 275// listNextResults retrieves the next set of results, if any. 276func (client PrivateEndpointConnectionsClient) listNextResults(ctx context.Context, lastResults PrivateEndpointConnectionList) (result PrivateEndpointConnectionList, err error) { 277 req, err := lastResults.privateEndpointConnectionListPreparer(ctx) 278 if err != nil { 279 return result, autorest.NewErrorWithError(err, "signalr.PrivateEndpointConnectionsClient", "listNextResults", nil, "Failure preparing next results request") 280 } 281 if req == nil { 282 return 283 } 284 resp, err := client.ListSender(req) 285 if err != nil { 286 result.Response = autorest.Response{Response: resp} 287 return result, autorest.NewErrorWithError(err, "signalr.PrivateEndpointConnectionsClient", "listNextResults", resp, "Failure sending next results request") 288 } 289 result, err = client.ListResponder(resp) 290 if err != nil { 291 err = autorest.NewErrorWithError(err, "signalr.PrivateEndpointConnectionsClient", "listNextResults", resp, "Failure responding to next results request") 292 } 293 return 294} 295 296// ListComplete enumerates all values, automatically crossing page boundaries as required. 297func (client PrivateEndpointConnectionsClient) ListComplete(ctx context.Context, resourceGroupName string, resourceName string) (result PrivateEndpointConnectionListIterator, err error) { 298 if tracing.IsEnabled() { 299 ctx = tracing.StartSpan(ctx, fqdn+"/PrivateEndpointConnectionsClient.List") 300 defer func() { 301 sc := -1 302 if result.Response().Response.Response != nil { 303 sc = result.page.Response().Response.Response.StatusCode 304 } 305 tracing.EndSpan(ctx, sc, err) 306 }() 307 } 308 result.page, err = client.List(ctx, resourceGroupName, resourceName) 309 return 310} 311 312// Update update the state of specified private endpoint connection 313// Parameters: 314// privateEndpointConnectionName - the name of the private endpoint connection 315// parameters - the resource of private endpoint and its properties 316// resourceGroupName - the name of the resource group that contains the resource. You can obtain this value 317// from the Azure Resource Manager API or the portal. 318// resourceName - the name of the resource. 319func (client PrivateEndpointConnectionsClient) Update(ctx context.Context, privateEndpointConnectionName string, parameters PrivateEndpointConnection, resourceGroupName string, resourceName string) (result PrivateEndpointConnection, err error) { 320 if tracing.IsEnabled() { 321 ctx = tracing.StartSpan(ctx, fqdn+"/PrivateEndpointConnectionsClient.Update") 322 defer func() { 323 sc := -1 324 if result.Response.Response != nil { 325 sc = result.Response.Response.StatusCode 326 } 327 tracing.EndSpan(ctx, sc, err) 328 }() 329 } 330 req, err := client.UpdatePreparer(ctx, privateEndpointConnectionName, parameters, resourceGroupName, resourceName) 331 if err != nil { 332 err = autorest.NewErrorWithError(err, "signalr.PrivateEndpointConnectionsClient", "Update", nil, "Failure preparing request") 333 return 334 } 335 336 resp, err := client.UpdateSender(req) 337 if err != nil { 338 result.Response = autorest.Response{Response: resp} 339 err = autorest.NewErrorWithError(err, "signalr.PrivateEndpointConnectionsClient", "Update", resp, "Failure sending request") 340 return 341 } 342 343 result, err = client.UpdateResponder(resp) 344 if err != nil { 345 err = autorest.NewErrorWithError(err, "signalr.PrivateEndpointConnectionsClient", "Update", resp, "Failure responding to request") 346 return 347 } 348 349 return 350} 351 352// UpdatePreparer prepares the Update request. 353func (client PrivateEndpointConnectionsClient) UpdatePreparer(ctx context.Context, privateEndpointConnectionName string, parameters PrivateEndpointConnection, resourceGroupName string, resourceName string) (*http.Request, error) { 354 pathParameters := map[string]interface{}{ 355 "privateEndpointConnectionName": autorest.Encode("path", privateEndpointConnectionName), 356 "resourceGroupName": autorest.Encode("path", resourceGroupName), 357 "resourceName": autorest.Encode("path", resourceName), 358 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 359 } 360 361 const APIVersion = "2021-06-01-preview" 362 queryParameters := map[string]interface{}{ 363 "api-version": APIVersion, 364 } 365 366 parameters.SystemData = nil 367 preparer := autorest.CreatePreparer( 368 autorest.AsContentType("application/json; charset=utf-8"), 369 autorest.AsPut(), 370 autorest.WithBaseURL(client.BaseURI), 371 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.SignalRService/signalR/{resourceName}/privateEndpointConnections/{privateEndpointConnectionName}", pathParameters), 372 autorest.WithJSON(parameters), 373 autorest.WithQueryParameters(queryParameters)) 374 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 375} 376 377// UpdateSender sends the Update request. The method will close the 378// http.Response Body if it receives an error. 379func (client PrivateEndpointConnectionsClient) UpdateSender(req *http.Request) (*http.Response, error) { 380 return client.Send(req, azure.DoRetryWithRegistration(client.Client)) 381} 382 383// UpdateResponder handles the response to the Update request. The method always 384// closes the http.Response Body. 385func (client PrivateEndpointConnectionsClient) UpdateResponder(resp *http.Response) (result PrivateEndpointConnection, err error) { 386 err = autorest.Respond( 387 resp, 388 azure.WithErrorUnlessStatusCode(http.StatusOK), 389 autorest.ByUnmarshallingJSON(&result), 390 autorest.ByClosing()) 391 result.Response = autorest.Response{Response: resp} 392 return 393} 394