1package security 2 3// Copyright (c) Microsoft and contributors. All rights reserved. 4// 5// Licensed under the Apache License, Version 2.0 (the "License"); 6// you may not use this file except in compliance with the License. 7// You may obtain a copy of the License at 8// http://www.apache.org/licenses/LICENSE-2.0 9// 10// Unless required by applicable law or agreed to in writing, software 11// distributed under the License is distributed on an "AS IS" BASIS, 12// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13// 14// See the License for the specific language governing permissions and 15// limitations under the License. 16// 17// Code generated by Microsoft (R) AutoRest Code Generator. 18// Changes may cause incorrect behavior and will be lost if the code is regenerated. 19 20import ( 21 "context" 22 "github.com/Azure/go-autorest/autorest" 23 "github.com/Azure/go-autorest/autorest/azure" 24 "github.com/Azure/go-autorest/autorest/validation" 25 "github.com/Azure/go-autorest/tracing" 26 "net/http" 27) 28 29// JitNetworkAccessPoliciesClient is the API spec for Microsoft.Security (Azure Security Center) resource provider 30type JitNetworkAccessPoliciesClient struct { 31 BaseClient 32} 33 34// NewJitNetworkAccessPoliciesClient creates an instance of the JitNetworkAccessPoliciesClient client. 35func NewJitNetworkAccessPoliciesClient(subscriptionID string, ascLocation string) JitNetworkAccessPoliciesClient { 36 return NewJitNetworkAccessPoliciesClientWithBaseURI(DefaultBaseURI, subscriptionID, ascLocation) 37} 38 39// NewJitNetworkAccessPoliciesClientWithBaseURI creates an instance of the JitNetworkAccessPoliciesClient client. 40func NewJitNetworkAccessPoliciesClientWithBaseURI(baseURI string, subscriptionID string, ascLocation string) JitNetworkAccessPoliciesClient { 41 return JitNetworkAccessPoliciesClient{NewWithBaseURI(baseURI, subscriptionID, ascLocation)} 42} 43 44// CreateOrUpdate create a policy for protecting resources using Just-in-Time access control 45// Parameters: 46// resourceGroupName - the name of the resource group within the user's subscription. The name is case 47// insensitive. 48// jitNetworkAccessPolicyName - name of a Just-in-Time access configuration policy. 49func (client JitNetworkAccessPoliciesClient) CreateOrUpdate(ctx context.Context, resourceGroupName string, jitNetworkAccessPolicyName string, body JitNetworkAccessPolicy) (result JitNetworkAccessPolicy, err error) { 50 if tracing.IsEnabled() { 51 ctx = tracing.StartSpan(ctx, fqdn+"/JitNetworkAccessPoliciesClient.CreateOrUpdate") 52 defer func() { 53 sc := -1 54 if result.Response.Response != nil { 55 sc = result.Response.Response.StatusCode 56 } 57 tracing.EndSpan(ctx, sc, err) 58 }() 59 } 60 if err := validation.Validate([]validation.Validation{ 61 {TargetValue: client.SubscriptionID, 62 Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.Pattern, Rule: `^[0-9A-Fa-f]{8}-([0-9A-Fa-f]{4}-){3}[0-9A-Fa-f]{12}$`, Chain: nil}}}, 63 {TargetValue: resourceGroupName, 64 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 65 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 66 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}}, 67 {TargetValue: body, 68 Constraints: []validation.Constraint{{Target: "body.JitNetworkAccessPolicyProperties", Name: validation.Null, Rule: true, 69 Chain: []validation.Constraint{{Target: "body.JitNetworkAccessPolicyProperties.VirtualMachines", Name: validation.Null, Rule: true, Chain: nil}}}}}}); err != nil { 70 return result, validation.NewError("security.JitNetworkAccessPoliciesClient", "CreateOrUpdate", err.Error()) 71 } 72 73 req, err := client.CreateOrUpdatePreparer(ctx, resourceGroupName, jitNetworkAccessPolicyName, body) 74 if err != nil { 75 err = autorest.NewErrorWithError(err, "security.JitNetworkAccessPoliciesClient", "CreateOrUpdate", nil, "Failure preparing request") 76 return 77 } 78 79 resp, err := client.CreateOrUpdateSender(req) 80 if err != nil { 81 result.Response = autorest.Response{Response: resp} 82 err = autorest.NewErrorWithError(err, "security.JitNetworkAccessPoliciesClient", "CreateOrUpdate", resp, "Failure sending request") 83 return 84 } 85 86 result, err = client.CreateOrUpdateResponder(resp) 87 if err != nil { 88 err = autorest.NewErrorWithError(err, "security.JitNetworkAccessPoliciesClient", "CreateOrUpdate", resp, "Failure responding to request") 89 } 90 91 return 92} 93 94// CreateOrUpdatePreparer prepares the CreateOrUpdate request. 95func (client JitNetworkAccessPoliciesClient) CreateOrUpdatePreparer(ctx context.Context, resourceGroupName string, jitNetworkAccessPolicyName string, body JitNetworkAccessPolicy) (*http.Request, error) { 96 pathParameters := map[string]interface{}{ 97 "ascLocation": autorest.Encode("path", client.AscLocation), 98 "jitNetworkAccessPolicyName": autorest.Encode("path", jitNetworkAccessPolicyName), 99 "resourceGroupName": autorest.Encode("path", resourceGroupName), 100 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 101 } 102 103 const APIVersion = "2015-06-01-preview" 104 queryParameters := map[string]interface{}{ 105 "api-version": APIVersion, 106 } 107 108 body.ID = nil 109 body.Name = nil 110 body.Type = nil 111 body.Location = nil 112 preparer := autorest.CreatePreparer( 113 autorest.AsContentType("application/json; charset=utf-8"), 114 autorest.AsPut(), 115 autorest.WithBaseURL(client.BaseURI), 116 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Security/locations/{ascLocation}/jitNetworkAccessPolicies/{jitNetworkAccessPolicyName}", pathParameters), 117 autorest.WithJSON(body), 118 autorest.WithQueryParameters(queryParameters)) 119 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 120} 121 122// CreateOrUpdateSender sends the CreateOrUpdate request. The method will close the 123// http.Response Body if it receives an error. 124func (client JitNetworkAccessPoliciesClient) CreateOrUpdateSender(req *http.Request) (*http.Response, error) { 125 sd := autorest.GetSendDecorators(req.Context(), azure.DoRetryWithRegistration(client.Client)) 126 return autorest.SendWithSender(client, req, sd...) 127} 128 129// CreateOrUpdateResponder handles the response to the CreateOrUpdate request. The method always 130// closes the http.Response Body. 131func (client JitNetworkAccessPoliciesClient) CreateOrUpdateResponder(resp *http.Response) (result JitNetworkAccessPolicy, err error) { 132 err = autorest.Respond( 133 resp, 134 client.ByInspecting(), 135 azure.WithErrorUnlessStatusCode(http.StatusOK), 136 autorest.ByUnmarshallingJSON(&result), 137 autorest.ByClosing()) 138 result.Response = autorest.Response{Response: resp} 139 return 140} 141 142// Delete delete a Just-in-Time access control policy. 143// Parameters: 144// resourceGroupName - the name of the resource group within the user's subscription. The name is case 145// insensitive. 146// jitNetworkAccessPolicyName - name of a Just-in-Time access configuration policy. 147func (client JitNetworkAccessPoliciesClient) Delete(ctx context.Context, resourceGroupName string, jitNetworkAccessPolicyName string) (result autorest.Response, err error) { 148 if tracing.IsEnabled() { 149 ctx = tracing.StartSpan(ctx, fqdn+"/JitNetworkAccessPoliciesClient.Delete") 150 defer func() { 151 sc := -1 152 if result.Response != nil { 153 sc = result.Response.StatusCode 154 } 155 tracing.EndSpan(ctx, sc, err) 156 }() 157 } 158 if err := validation.Validate([]validation.Validation{ 159 {TargetValue: client.SubscriptionID, 160 Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.Pattern, Rule: `^[0-9A-Fa-f]{8}-([0-9A-Fa-f]{4}-){3}[0-9A-Fa-f]{12}$`, Chain: nil}}}, 161 {TargetValue: resourceGroupName, 162 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 163 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 164 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}}}); err != nil { 165 return result, validation.NewError("security.JitNetworkAccessPoliciesClient", "Delete", err.Error()) 166 } 167 168 req, err := client.DeletePreparer(ctx, resourceGroupName, jitNetworkAccessPolicyName) 169 if err != nil { 170 err = autorest.NewErrorWithError(err, "security.JitNetworkAccessPoliciesClient", "Delete", nil, "Failure preparing request") 171 return 172 } 173 174 resp, err := client.DeleteSender(req) 175 if err != nil { 176 result.Response = resp 177 err = autorest.NewErrorWithError(err, "security.JitNetworkAccessPoliciesClient", "Delete", resp, "Failure sending request") 178 return 179 } 180 181 result, err = client.DeleteResponder(resp) 182 if err != nil { 183 err = autorest.NewErrorWithError(err, "security.JitNetworkAccessPoliciesClient", "Delete", resp, "Failure responding to request") 184 } 185 186 return 187} 188 189// DeletePreparer prepares the Delete request. 190func (client JitNetworkAccessPoliciesClient) DeletePreparer(ctx context.Context, resourceGroupName string, jitNetworkAccessPolicyName string) (*http.Request, error) { 191 pathParameters := map[string]interface{}{ 192 "ascLocation": autorest.Encode("path", client.AscLocation), 193 "jitNetworkAccessPolicyName": autorest.Encode("path", jitNetworkAccessPolicyName), 194 "resourceGroupName": autorest.Encode("path", resourceGroupName), 195 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 196 } 197 198 const APIVersion = "2015-06-01-preview" 199 queryParameters := map[string]interface{}{ 200 "api-version": APIVersion, 201 } 202 203 preparer := autorest.CreatePreparer( 204 autorest.AsDelete(), 205 autorest.WithBaseURL(client.BaseURI), 206 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Security/locations/{ascLocation}/jitNetworkAccessPolicies/{jitNetworkAccessPolicyName}", pathParameters), 207 autorest.WithQueryParameters(queryParameters)) 208 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 209} 210 211// DeleteSender sends the Delete request. The method will close the 212// http.Response Body if it receives an error. 213func (client JitNetworkAccessPoliciesClient) DeleteSender(req *http.Request) (*http.Response, error) { 214 sd := autorest.GetSendDecorators(req.Context(), azure.DoRetryWithRegistration(client.Client)) 215 return autorest.SendWithSender(client, req, sd...) 216} 217 218// DeleteResponder handles the response to the Delete request. The method always 219// closes the http.Response Body. 220func (client JitNetworkAccessPoliciesClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) { 221 err = autorest.Respond( 222 resp, 223 client.ByInspecting(), 224 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusNoContent), 225 autorest.ByClosing()) 226 result.Response = resp 227 return 228} 229 230// Get policies for protecting resources using Just-in-Time access control for the subscription, location 231// Parameters: 232// resourceGroupName - the name of the resource group within the user's subscription. The name is case 233// insensitive. 234// jitNetworkAccessPolicyName - name of a Just-in-Time access configuration policy. 235func (client JitNetworkAccessPoliciesClient) Get(ctx context.Context, resourceGroupName string, jitNetworkAccessPolicyName string) (result JitNetworkAccessPolicy, err error) { 236 if tracing.IsEnabled() { 237 ctx = tracing.StartSpan(ctx, fqdn+"/JitNetworkAccessPoliciesClient.Get") 238 defer func() { 239 sc := -1 240 if result.Response.Response != nil { 241 sc = result.Response.Response.StatusCode 242 } 243 tracing.EndSpan(ctx, sc, err) 244 }() 245 } 246 if err := validation.Validate([]validation.Validation{ 247 {TargetValue: client.SubscriptionID, 248 Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.Pattern, Rule: `^[0-9A-Fa-f]{8}-([0-9A-Fa-f]{4}-){3}[0-9A-Fa-f]{12}$`, Chain: nil}}}, 249 {TargetValue: resourceGroupName, 250 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 251 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 252 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}}}); err != nil { 253 return result, validation.NewError("security.JitNetworkAccessPoliciesClient", "Get", err.Error()) 254 } 255 256 req, err := client.GetPreparer(ctx, resourceGroupName, jitNetworkAccessPolicyName) 257 if err != nil { 258 err = autorest.NewErrorWithError(err, "security.JitNetworkAccessPoliciesClient", "Get", nil, "Failure preparing request") 259 return 260 } 261 262 resp, err := client.GetSender(req) 263 if err != nil { 264 result.Response = autorest.Response{Response: resp} 265 err = autorest.NewErrorWithError(err, "security.JitNetworkAccessPoliciesClient", "Get", resp, "Failure sending request") 266 return 267 } 268 269 result, err = client.GetResponder(resp) 270 if err != nil { 271 err = autorest.NewErrorWithError(err, "security.JitNetworkAccessPoliciesClient", "Get", resp, "Failure responding to request") 272 } 273 274 return 275} 276 277// GetPreparer prepares the Get request. 278func (client JitNetworkAccessPoliciesClient) GetPreparer(ctx context.Context, resourceGroupName string, jitNetworkAccessPolicyName string) (*http.Request, error) { 279 pathParameters := map[string]interface{}{ 280 "ascLocation": autorest.Encode("path", client.AscLocation), 281 "jitNetworkAccessPolicyName": autorest.Encode("path", jitNetworkAccessPolicyName), 282 "resourceGroupName": autorest.Encode("path", resourceGroupName), 283 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 284 } 285 286 const APIVersion = "2015-06-01-preview" 287 queryParameters := map[string]interface{}{ 288 "api-version": APIVersion, 289 } 290 291 preparer := autorest.CreatePreparer( 292 autorest.AsGet(), 293 autorest.WithBaseURL(client.BaseURI), 294 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Security/locations/{ascLocation}/jitNetworkAccessPolicies/{jitNetworkAccessPolicyName}", pathParameters), 295 autorest.WithQueryParameters(queryParameters)) 296 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 297} 298 299// GetSender sends the Get request. The method will close the 300// http.Response Body if it receives an error. 301func (client JitNetworkAccessPoliciesClient) GetSender(req *http.Request) (*http.Response, error) { 302 sd := autorest.GetSendDecorators(req.Context(), azure.DoRetryWithRegistration(client.Client)) 303 return autorest.SendWithSender(client, req, sd...) 304} 305 306// GetResponder handles the response to the Get request. The method always 307// closes the http.Response Body. 308func (client JitNetworkAccessPoliciesClient) GetResponder(resp *http.Response) (result JitNetworkAccessPolicy, err error) { 309 err = autorest.Respond( 310 resp, 311 client.ByInspecting(), 312 azure.WithErrorUnlessStatusCode(http.StatusOK), 313 autorest.ByUnmarshallingJSON(&result), 314 autorest.ByClosing()) 315 result.Response = autorest.Response{Response: resp} 316 return 317} 318 319// Initiate initiate a JIT access from a specific Just-in-Time policy configuration. 320// Parameters: 321// resourceGroupName - the name of the resource group within the user's subscription. The name is case 322// insensitive. 323// jitNetworkAccessPolicyName - name of a Just-in-Time access configuration policy. 324func (client JitNetworkAccessPoliciesClient) Initiate(ctx context.Context, resourceGroupName string, jitNetworkAccessPolicyName string, body JitNetworkAccessPolicyInitiateRequest) (result JitNetworkAccessRequest, err error) { 325 if tracing.IsEnabled() { 326 ctx = tracing.StartSpan(ctx, fqdn+"/JitNetworkAccessPoliciesClient.Initiate") 327 defer func() { 328 sc := -1 329 if result.Response.Response != nil { 330 sc = result.Response.Response.StatusCode 331 } 332 tracing.EndSpan(ctx, sc, err) 333 }() 334 } 335 if err := validation.Validate([]validation.Validation{ 336 {TargetValue: client.SubscriptionID, 337 Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.Pattern, Rule: `^[0-9A-Fa-f]{8}-([0-9A-Fa-f]{4}-){3}[0-9A-Fa-f]{12}$`, Chain: nil}}}, 338 {TargetValue: resourceGroupName, 339 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 340 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 341 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}}, 342 {TargetValue: body, 343 Constraints: []validation.Constraint{{Target: "body.VirtualMachines", Name: validation.Null, Rule: true, Chain: nil}}}}); err != nil { 344 return result, validation.NewError("security.JitNetworkAccessPoliciesClient", "Initiate", err.Error()) 345 } 346 347 req, err := client.InitiatePreparer(ctx, resourceGroupName, jitNetworkAccessPolicyName, body) 348 if err != nil { 349 err = autorest.NewErrorWithError(err, "security.JitNetworkAccessPoliciesClient", "Initiate", nil, "Failure preparing request") 350 return 351 } 352 353 resp, err := client.InitiateSender(req) 354 if err != nil { 355 result.Response = autorest.Response{Response: resp} 356 err = autorest.NewErrorWithError(err, "security.JitNetworkAccessPoliciesClient", "Initiate", resp, "Failure sending request") 357 return 358 } 359 360 result, err = client.InitiateResponder(resp) 361 if err != nil { 362 err = autorest.NewErrorWithError(err, "security.JitNetworkAccessPoliciesClient", "Initiate", resp, "Failure responding to request") 363 } 364 365 return 366} 367 368// InitiatePreparer prepares the Initiate request. 369func (client JitNetworkAccessPoliciesClient) InitiatePreparer(ctx context.Context, resourceGroupName string, jitNetworkAccessPolicyName string, body JitNetworkAccessPolicyInitiateRequest) (*http.Request, error) { 370 pathParameters := map[string]interface{}{ 371 "ascLocation": autorest.Encode("path", client.AscLocation), 372 "jitNetworkAccessPolicyInitiateType": autorest.Encode("path", "initiate"), 373 "jitNetworkAccessPolicyName": autorest.Encode("path", jitNetworkAccessPolicyName), 374 "resourceGroupName": autorest.Encode("path", resourceGroupName), 375 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 376 } 377 378 const APIVersion = "2015-06-01-preview" 379 queryParameters := map[string]interface{}{ 380 "api-version": APIVersion, 381 } 382 383 preparer := autorest.CreatePreparer( 384 autorest.AsContentType("application/json; charset=utf-8"), 385 autorest.AsPost(), 386 autorest.WithBaseURL(client.BaseURI), 387 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Security/locations/{ascLocation}/jitNetworkAccessPolicies/{jitNetworkAccessPolicyName}/{jitNetworkAccessPolicyInitiateType}", pathParameters), 388 autorest.WithJSON(body), 389 autorest.WithQueryParameters(queryParameters)) 390 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 391} 392 393// InitiateSender sends the Initiate request. The method will close the 394// http.Response Body if it receives an error. 395func (client JitNetworkAccessPoliciesClient) InitiateSender(req *http.Request) (*http.Response, error) { 396 sd := autorest.GetSendDecorators(req.Context(), azure.DoRetryWithRegistration(client.Client)) 397 return autorest.SendWithSender(client, req, sd...) 398} 399 400// InitiateResponder handles the response to the Initiate request. The method always 401// closes the http.Response Body. 402func (client JitNetworkAccessPoliciesClient) InitiateResponder(resp *http.Response) (result JitNetworkAccessRequest, err error) { 403 err = autorest.Respond( 404 resp, 405 client.ByInspecting(), 406 azure.WithErrorUnlessStatusCode(http.StatusOK, http.StatusAccepted), 407 autorest.ByUnmarshallingJSON(&result), 408 autorest.ByClosing()) 409 result.Response = autorest.Response{Response: resp} 410 return 411} 412 413// List policies for protecting resources using Just-in-Time access control. 414func (client JitNetworkAccessPoliciesClient) List(ctx context.Context) (result JitNetworkAccessPoliciesListPage, err error) { 415 if tracing.IsEnabled() { 416 ctx = tracing.StartSpan(ctx, fqdn+"/JitNetworkAccessPoliciesClient.List") 417 defer func() { 418 sc := -1 419 if result.jnapl.Response.Response != nil { 420 sc = result.jnapl.Response.Response.StatusCode 421 } 422 tracing.EndSpan(ctx, sc, err) 423 }() 424 } 425 if err := validation.Validate([]validation.Validation{ 426 {TargetValue: client.SubscriptionID, 427 Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.Pattern, Rule: `^[0-9A-Fa-f]{8}-([0-9A-Fa-f]{4}-){3}[0-9A-Fa-f]{12}$`, Chain: nil}}}}); err != nil { 428 return result, validation.NewError("security.JitNetworkAccessPoliciesClient", "List", err.Error()) 429 } 430 431 result.fn = client.listNextResults 432 req, err := client.ListPreparer(ctx) 433 if err != nil { 434 err = autorest.NewErrorWithError(err, "security.JitNetworkAccessPoliciesClient", "List", nil, "Failure preparing request") 435 return 436 } 437 438 resp, err := client.ListSender(req) 439 if err != nil { 440 result.jnapl.Response = autorest.Response{Response: resp} 441 err = autorest.NewErrorWithError(err, "security.JitNetworkAccessPoliciesClient", "List", resp, "Failure sending request") 442 return 443 } 444 445 result.jnapl, err = client.ListResponder(resp) 446 if err != nil { 447 err = autorest.NewErrorWithError(err, "security.JitNetworkAccessPoliciesClient", "List", resp, "Failure responding to request") 448 } 449 450 return 451} 452 453// ListPreparer prepares the List request. 454func (client JitNetworkAccessPoliciesClient) ListPreparer(ctx context.Context) (*http.Request, error) { 455 pathParameters := map[string]interface{}{ 456 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 457 } 458 459 const APIVersion = "2015-06-01-preview" 460 queryParameters := map[string]interface{}{ 461 "api-version": APIVersion, 462 } 463 464 preparer := autorest.CreatePreparer( 465 autorest.AsGet(), 466 autorest.WithBaseURL(client.BaseURI), 467 autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Security/jitNetworkAccessPolicies", pathParameters), 468 autorest.WithQueryParameters(queryParameters)) 469 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 470} 471 472// ListSender sends the List request. The method will close the 473// http.Response Body if it receives an error. 474func (client JitNetworkAccessPoliciesClient) ListSender(req *http.Request) (*http.Response, error) { 475 sd := autorest.GetSendDecorators(req.Context(), azure.DoRetryWithRegistration(client.Client)) 476 return autorest.SendWithSender(client, req, sd...) 477} 478 479// ListResponder handles the response to the List request. The method always 480// closes the http.Response Body. 481func (client JitNetworkAccessPoliciesClient) ListResponder(resp *http.Response) (result JitNetworkAccessPoliciesList, err error) { 482 err = autorest.Respond( 483 resp, 484 client.ByInspecting(), 485 azure.WithErrorUnlessStatusCode(http.StatusOK), 486 autorest.ByUnmarshallingJSON(&result), 487 autorest.ByClosing()) 488 result.Response = autorest.Response{Response: resp} 489 return 490} 491 492// listNextResults retrieves the next set of results, if any. 493func (client JitNetworkAccessPoliciesClient) listNextResults(ctx context.Context, lastResults JitNetworkAccessPoliciesList) (result JitNetworkAccessPoliciesList, err error) { 494 req, err := lastResults.jitNetworkAccessPoliciesListPreparer(ctx) 495 if err != nil { 496 return result, autorest.NewErrorWithError(err, "security.JitNetworkAccessPoliciesClient", "listNextResults", nil, "Failure preparing next results request") 497 } 498 if req == nil { 499 return 500 } 501 resp, err := client.ListSender(req) 502 if err != nil { 503 result.Response = autorest.Response{Response: resp} 504 return result, autorest.NewErrorWithError(err, "security.JitNetworkAccessPoliciesClient", "listNextResults", resp, "Failure sending next results request") 505 } 506 result, err = client.ListResponder(resp) 507 if err != nil { 508 err = autorest.NewErrorWithError(err, "security.JitNetworkAccessPoliciesClient", "listNextResults", resp, "Failure responding to next results request") 509 } 510 return 511} 512 513// ListComplete enumerates all values, automatically crossing page boundaries as required. 514func (client JitNetworkAccessPoliciesClient) ListComplete(ctx context.Context) (result JitNetworkAccessPoliciesListIterator, err error) { 515 if tracing.IsEnabled() { 516 ctx = tracing.StartSpan(ctx, fqdn+"/JitNetworkAccessPoliciesClient.List") 517 defer func() { 518 sc := -1 519 if result.Response().Response.Response != nil { 520 sc = result.page.Response().Response.Response.StatusCode 521 } 522 tracing.EndSpan(ctx, sc, err) 523 }() 524 } 525 result.page, err = client.List(ctx) 526 return 527} 528 529// ListByRegion policies for protecting resources using Just-in-Time access control for the subscription, location 530func (client JitNetworkAccessPoliciesClient) ListByRegion(ctx context.Context) (result JitNetworkAccessPoliciesListPage, err error) { 531 if tracing.IsEnabled() { 532 ctx = tracing.StartSpan(ctx, fqdn+"/JitNetworkAccessPoliciesClient.ListByRegion") 533 defer func() { 534 sc := -1 535 if result.jnapl.Response.Response != nil { 536 sc = result.jnapl.Response.Response.StatusCode 537 } 538 tracing.EndSpan(ctx, sc, err) 539 }() 540 } 541 if err := validation.Validate([]validation.Validation{ 542 {TargetValue: client.SubscriptionID, 543 Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.Pattern, Rule: `^[0-9A-Fa-f]{8}-([0-9A-Fa-f]{4}-){3}[0-9A-Fa-f]{12}$`, Chain: nil}}}}); err != nil { 544 return result, validation.NewError("security.JitNetworkAccessPoliciesClient", "ListByRegion", err.Error()) 545 } 546 547 result.fn = client.listByRegionNextResults 548 req, err := client.ListByRegionPreparer(ctx) 549 if err != nil { 550 err = autorest.NewErrorWithError(err, "security.JitNetworkAccessPoliciesClient", "ListByRegion", nil, "Failure preparing request") 551 return 552 } 553 554 resp, err := client.ListByRegionSender(req) 555 if err != nil { 556 result.jnapl.Response = autorest.Response{Response: resp} 557 err = autorest.NewErrorWithError(err, "security.JitNetworkAccessPoliciesClient", "ListByRegion", resp, "Failure sending request") 558 return 559 } 560 561 result.jnapl, err = client.ListByRegionResponder(resp) 562 if err != nil { 563 err = autorest.NewErrorWithError(err, "security.JitNetworkAccessPoliciesClient", "ListByRegion", resp, "Failure responding to request") 564 } 565 566 return 567} 568 569// ListByRegionPreparer prepares the ListByRegion request. 570func (client JitNetworkAccessPoliciesClient) ListByRegionPreparer(ctx context.Context) (*http.Request, error) { 571 pathParameters := map[string]interface{}{ 572 "ascLocation": autorest.Encode("path", client.AscLocation), 573 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 574 } 575 576 const APIVersion = "2015-06-01-preview" 577 queryParameters := map[string]interface{}{ 578 "api-version": APIVersion, 579 } 580 581 preparer := autorest.CreatePreparer( 582 autorest.AsGet(), 583 autorest.WithBaseURL(client.BaseURI), 584 autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Security/locations/{ascLocation}/jitNetworkAccessPolicies", pathParameters), 585 autorest.WithQueryParameters(queryParameters)) 586 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 587} 588 589// ListByRegionSender sends the ListByRegion request. The method will close the 590// http.Response Body if it receives an error. 591func (client JitNetworkAccessPoliciesClient) ListByRegionSender(req *http.Request) (*http.Response, error) { 592 sd := autorest.GetSendDecorators(req.Context(), azure.DoRetryWithRegistration(client.Client)) 593 return autorest.SendWithSender(client, req, sd...) 594} 595 596// ListByRegionResponder handles the response to the ListByRegion request. The method always 597// closes the http.Response Body. 598func (client JitNetworkAccessPoliciesClient) ListByRegionResponder(resp *http.Response) (result JitNetworkAccessPoliciesList, err error) { 599 err = autorest.Respond( 600 resp, 601 client.ByInspecting(), 602 azure.WithErrorUnlessStatusCode(http.StatusOK), 603 autorest.ByUnmarshallingJSON(&result), 604 autorest.ByClosing()) 605 result.Response = autorest.Response{Response: resp} 606 return 607} 608 609// listByRegionNextResults retrieves the next set of results, if any. 610func (client JitNetworkAccessPoliciesClient) listByRegionNextResults(ctx context.Context, lastResults JitNetworkAccessPoliciesList) (result JitNetworkAccessPoliciesList, err error) { 611 req, err := lastResults.jitNetworkAccessPoliciesListPreparer(ctx) 612 if err != nil { 613 return result, autorest.NewErrorWithError(err, "security.JitNetworkAccessPoliciesClient", "listByRegionNextResults", nil, "Failure preparing next results request") 614 } 615 if req == nil { 616 return 617 } 618 resp, err := client.ListByRegionSender(req) 619 if err != nil { 620 result.Response = autorest.Response{Response: resp} 621 return result, autorest.NewErrorWithError(err, "security.JitNetworkAccessPoliciesClient", "listByRegionNextResults", resp, "Failure sending next results request") 622 } 623 result, err = client.ListByRegionResponder(resp) 624 if err != nil { 625 err = autorest.NewErrorWithError(err, "security.JitNetworkAccessPoliciesClient", "listByRegionNextResults", resp, "Failure responding to next results request") 626 } 627 return 628} 629 630// ListByRegionComplete enumerates all values, automatically crossing page boundaries as required. 631func (client JitNetworkAccessPoliciesClient) ListByRegionComplete(ctx context.Context) (result JitNetworkAccessPoliciesListIterator, err error) { 632 if tracing.IsEnabled() { 633 ctx = tracing.StartSpan(ctx, fqdn+"/JitNetworkAccessPoliciesClient.ListByRegion") 634 defer func() { 635 sc := -1 636 if result.Response().Response.Response != nil { 637 sc = result.page.Response().Response.Response.StatusCode 638 } 639 tracing.EndSpan(ctx, sc, err) 640 }() 641 } 642 result.page, err = client.ListByRegion(ctx) 643 return 644} 645 646// ListByResourceGroup policies for protecting resources using Just-in-Time access control for the subscription, 647// location 648// Parameters: 649// resourceGroupName - the name of the resource group within the user's subscription. The name is case 650// insensitive. 651func (client JitNetworkAccessPoliciesClient) ListByResourceGroup(ctx context.Context, resourceGroupName string) (result JitNetworkAccessPoliciesListPage, err error) { 652 if tracing.IsEnabled() { 653 ctx = tracing.StartSpan(ctx, fqdn+"/JitNetworkAccessPoliciesClient.ListByResourceGroup") 654 defer func() { 655 sc := -1 656 if result.jnapl.Response.Response != nil { 657 sc = result.jnapl.Response.Response.StatusCode 658 } 659 tracing.EndSpan(ctx, sc, err) 660 }() 661 } 662 if err := validation.Validate([]validation.Validation{ 663 {TargetValue: client.SubscriptionID, 664 Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.Pattern, Rule: `^[0-9A-Fa-f]{8}-([0-9A-Fa-f]{4}-){3}[0-9A-Fa-f]{12}$`, Chain: nil}}}, 665 {TargetValue: resourceGroupName, 666 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 667 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 668 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}}}); err != nil { 669 return result, validation.NewError("security.JitNetworkAccessPoliciesClient", "ListByResourceGroup", err.Error()) 670 } 671 672 result.fn = client.listByResourceGroupNextResults 673 req, err := client.ListByResourceGroupPreparer(ctx, resourceGroupName) 674 if err != nil { 675 err = autorest.NewErrorWithError(err, "security.JitNetworkAccessPoliciesClient", "ListByResourceGroup", nil, "Failure preparing request") 676 return 677 } 678 679 resp, err := client.ListByResourceGroupSender(req) 680 if err != nil { 681 result.jnapl.Response = autorest.Response{Response: resp} 682 err = autorest.NewErrorWithError(err, "security.JitNetworkAccessPoliciesClient", "ListByResourceGroup", resp, "Failure sending request") 683 return 684 } 685 686 result.jnapl, err = client.ListByResourceGroupResponder(resp) 687 if err != nil { 688 err = autorest.NewErrorWithError(err, "security.JitNetworkAccessPoliciesClient", "ListByResourceGroup", resp, "Failure responding to request") 689 } 690 691 return 692} 693 694// ListByResourceGroupPreparer prepares the ListByResourceGroup request. 695func (client JitNetworkAccessPoliciesClient) ListByResourceGroupPreparer(ctx context.Context, resourceGroupName string) (*http.Request, error) { 696 pathParameters := map[string]interface{}{ 697 "resourceGroupName": autorest.Encode("path", resourceGroupName), 698 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 699 } 700 701 const APIVersion = "2015-06-01-preview" 702 queryParameters := map[string]interface{}{ 703 "api-version": APIVersion, 704 } 705 706 preparer := autorest.CreatePreparer( 707 autorest.AsGet(), 708 autorest.WithBaseURL(client.BaseURI), 709 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Security/jitNetworkAccessPolicies", pathParameters), 710 autorest.WithQueryParameters(queryParameters)) 711 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 712} 713 714// ListByResourceGroupSender sends the ListByResourceGroup request. The method will close the 715// http.Response Body if it receives an error. 716func (client JitNetworkAccessPoliciesClient) ListByResourceGroupSender(req *http.Request) (*http.Response, error) { 717 sd := autorest.GetSendDecorators(req.Context(), azure.DoRetryWithRegistration(client.Client)) 718 return autorest.SendWithSender(client, req, sd...) 719} 720 721// ListByResourceGroupResponder handles the response to the ListByResourceGroup request. The method always 722// closes the http.Response Body. 723func (client JitNetworkAccessPoliciesClient) ListByResourceGroupResponder(resp *http.Response) (result JitNetworkAccessPoliciesList, err error) { 724 err = autorest.Respond( 725 resp, 726 client.ByInspecting(), 727 azure.WithErrorUnlessStatusCode(http.StatusOK), 728 autorest.ByUnmarshallingJSON(&result), 729 autorest.ByClosing()) 730 result.Response = autorest.Response{Response: resp} 731 return 732} 733 734// listByResourceGroupNextResults retrieves the next set of results, if any. 735func (client JitNetworkAccessPoliciesClient) listByResourceGroupNextResults(ctx context.Context, lastResults JitNetworkAccessPoliciesList) (result JitNetworkAccessPoliciesList, err error) { 736 req, err := lastResults.jitNetworkAccessPoliciesListPreparer(ctx) 737 if err != nil { 738 return result, autorest.NewErrorWithError(err, "security.JitNetworkAccessPoliciesClient", "listByResourceGroupNextResults", nil, "Failure preparing next results request") 739 } 740 if req == nil { 741 return 742 } 743 resp, err := client.ListByResourceGroupSender(req) 744 if err != nil { 745 result.Response = autorest.Response{Response: resp} 746 return result, autorest.NewErrorWithError(err, "security.JitNetworkAccessPoliciesClient", "listByResourceGroupNextResults", resp, "Failure sending next results request") 747 } 748 result, err = client.ListByResourceGroupResponder(resp) 749 if err != nil { 750 err = autorest.NewErrorWithError(err, "security.JitNetworkAccessPoliciesClient", "listByResourceGroupNextResults", resp, "Failure responding to next results request") 751 } 752 return 753} 754 755// ListByResourceGroupComplete enumerates all values, automatically crossing page boundaries as required. 756func (client JitNetworkAccessPoliciesClient) ListByResourceGroupComplete(ctx context.Context, resourceGroupName string) (result JitNetworkAccessPoliciesListIterator, err error) { 757 if tracing.IsEnabled() { 758 ctx = tracing.StartSpan(ctx, fqdn+"/JitNetworkAccessPoliciesClient.ListByResourceGroup") 759 defer func() { 760 sc := -1 761 if result.Response().Response.Response != nil { 762 sc = result.page.Response().Response.Response.StatusCode 763 } 764 tracing.EndSpan(ctx, sc, err) 765 }() 766 } 767 result.page, err = client.ListByResourceGroup(ctx, resourceGroupName) 768 return 769} 770 771// ListByResourceGroupAndRegion policies for protecting resources using Just-in-Time access control for the 772// subscription, location 773// Parameters: 774// resourceGroupName - the name of the resource group within the user's subscription. The name is case 775// insensitive. 776func (client JitNetworkAccessPoliciesClient) ListByResourceGroupAndRegion(ctx context.Context, resourceGroupName string) (result JitNetworkAccessPoliciesListPage, err error) { 777 if tracing.IsEnabled() { 778 ctx = tracing.StartSpan(ctx, fqdn+"/JitNetworkAccessPoliciesClient.ListByResourceGroupAndRegion") 779 defer func() { 780 sc := -1 781 if result.jnapl.Response.Response != nil { 782 sc = result.jnapl.Response.Response.StatusCode 783 } 784 tracing.EndSpan(ctx, sc, err) 785 }() 786 } 787 if err := validation.Validate([]validation.Validation{ 788 {TargetValue: client.SubscriptionID, 789 Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.Pattern, Rule: `^[0-9A-Fa-f]{8}-([0-9A-Fa-f]{4}-){3}[0-9A-Fa-f]{12}$`, Chain: nil}}}, 790 {TargetValue: resourceGroupName, 791 Constraints: []validation.Constraint{{Target: "resourceGroupName", Name: validation.MaxLength, Rule: 90, Chain: nil}, 792 {Target: "resourceGroupName", Name: validation.MinLength, Rule: 1, Chain: nil}, 793 {Target: "resourceGroupName", Name: validation.Pattern, Rule: `^[-\w\._\(\)]+$`, Chain: nil}}}}); err != nil { 794 return result, validation.NewError("security.JitNetworkAccessPoliciesClient", "ListByResourceGroupAndRegion", err.Error()) 795 } 796 797 result.fn = client.listByResourceGroupAndRegionNextResults 798 req, err := client.ListByResourceGroupAndRegionPreparer(ctx, resourceGroupName) 799 if err != nil { 800 err = autorest.NewErrorWithError(err, "security.JitNetworkAccessPoliciesClient", "ListByResourceGroupAndRegion", nil, "Failure preparing request") 801 return 802 } 803 804 resp, err := client.ListByResourceGroupAndRegionSender(req) 805 if err != nil { 806 result.jnapl.Response = autorest.Response{Response: resp} 807 err = autorest.NewErrorWithError(err, "security.JitNetworkAccessPoliciesClient", "ListByResourceGroupAndRegion", resp, "Failure sending request") 808 return 809 } 810 811 result.jnapl, err = client.ListByResourceGroupAndRegionResponder(resp) 812 if err != nil { 813 err = autorest.NewErrorWithError(err, "security.JitNetworkAccessPoliciesClient", "ListByResourceGroupAndRegion", resp, "Failure responding to request") 814 } 815 816 return 817} 818 819// ListByResourceGroupAndRegionPreparer prepares the ListByResourceGroupAndRegion request. 820func (client JitNetworkAccessPoliciesClient) ListByResourceGroupAndRegionPreparer(ctx context.Context, resourceGroupName string) (*http.Request, error) { 821 pathParameters := map[string]interface{}{ 822 "ascLocation": autorest.Encode("path", client.AscLocation), 823 "resourceGroupName": autorest.Encode("path", resourceGroupName), 824 "subscriptionId": autorest.Encode("path", client.SubscriptionID), 825 } 826 827 const APIVersion = "2015-06-01-preview" 828 queryParameters := map[string]interface{}{ 829 "api-version": APIVersion, 830 } 831 832 preparer := autorest.CreatePreparer( 833 autorest.AsGet(), 834 autorest.WithBaseURL(client.BaseURI), 835 autorest.WithPathParameters("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Security/locations/{ascLocation}/jitNetworkAccessPolicies", pathParameters), 836 autorest.WithQueryParameters(queryParameters)) 837 return preparer.Prepare((&http.Request{}).WithContext(ctx)) 838} 839 840// ListByResourceGroupAndRegionSender sends the ListByResourceGroupAndRegion request. The method will close the 841// http.Response Body if it receives an error. 842func (client JitNetworkAccessPoliciesClient) ListByResourceGroupAndRegionSender(req *http.Request) (*http.Response, error) { 843 sd := autorest.GetSendDecorators(req.Context(), azure.DoRetryWithRegistration(client.Client)) 844 return autorest.SendWithSender(client, req, sd...) 845} 846 847// ListByResourceGroupAndRegionResponder handles the response to the ListByResourceGroupAndRegion request. The method always 848// closes the http.Response Body. 849func (client JitNetworkAccessPoliciesClient) ListByResourceGroupAndRegionResponder(resp *http.Response) (result JitNetworkAccessPoliciesList, err error) { 850 err = autorest.Respond( 851 resp, 852 client.ByInspecting(), 853 azure.WithErrorUnlessStatusCode(http.StatusOK), 854 autorest.ByUnmarshallingJSON(&result), 855 autorest.ByClosing()) 856 result.Response = autorest.Response{Response: resp} 857 return 858} 859 860// listByResourceGroupAndRegionNextResults retrieves the next set of results, if any. 861func (client JitNetworkAccessPoliciesClient) listByResourceGroupAndRegionNextResults(ctx context.Context, lastResults JitNetworkAccessPoliciesList) (result JitNetworkAccessPoliciesList, err error) { 862 req, err := lastResults.jitNetworkAccessPoliciesListPreparer(ctx) 863 if err != nil { 864 return result, autorest.NewErrorWithError(err, "security.JitNetworkAccessPoliciesClient", "listByResourceGroupAndRegionNextResults", nil, "Failure preparing next results request") 865 } 866 if req == nil { 867 return 868 } 869 resp, err := client.ListByResourceGroupAndRegionSender(req) 870 if err != nil { 871 result.Response = autorest.Response{Response: resp} 872 return result, autorest.NewErrorWithError(err, "security.JitNetworkAccessPoliciesClient", "listByResourceGroupAndRegionNextResults", resp, "Failure sending next results request") 873 } 874 result, err = client.ListByResourceGroupAndRegionResponder(resp) 875 if err != nil { 876 err = autorest.NewErrorWithError(err, "security.JitNetworkAccessPoliciesClient", "listByResourceGroupAndRegionNextResults", resp, "Failure responding to next results request") 877 } 878 return 879} 880 881// ListByResourceGroupAndRegionComplete enumerates all values, automatically crossing page boundaries as required. 882func (client JitNetworkAccessPoliciesClient) ListByResourceGroupAndRegionComplete(ctx context.Context, resourceGroupName string) (result JitNetworkAccessPoliciesListIterator, err error) { 883 if tracing.IsEnabled() { 884 ctx = tracing.StartSpan(ctx, fqdn+"/JitNetworkAccessPoliciesClient.ListByResourceGroupAndRegion") 885 defer func() { 886 sc := -1 887 if result.Response().Response.Response != nil { 888 sc = result.page.Response().Response.Response.StatusCode 889 } 890 tracing.EndSpan(ctx, sc, err) 891 }() 892 } 893 result.page, err = client.ListByResourceGroupAndRegion(ctx, resourceGroupName) 894 return 895} 896