github.com/vmware/go-vmware-nsxt@v0.0.0-20230223012718-d31b8a1ca05e/logical_switching_api.go (about) 1 /* Copyright © 2017 VMware, Inc. All Rights Reserved. 2 SPDX-License-Identifier: BSD-2-Clause 3 4 Generated by: https://github.com/swagger-api/swagger-codegen.git */ 5 6 package nsxt 7 8 import ( 9 "context" 10 "encoding/json" 11 "fmt" 12 "github.com/vmware/go-vmware-nsxt/manager" 13 "net/http" 14 "net/url" 15 "strings" 16 ) 17 18 // Linger please 19 var ( 20 _ context.Context 21 ) 22 23 type LogicalSwitchingApiService service 24 25 /* LogicalSwitchingApiService Create a Logical Port 26 Creates a new logical switch port. The required parameters are the associated logical_switch_id and admin_state (UP or DOWN). Optional parameters are the attachment and switching_profile_ids. If you don't specify switching_profile_ids, default switching profiles are assigned to the port. If you don't specify an attachment, the switch port remains empty. To configure an attachment, you must specify an id, and optionally you can specify an attachment_type (VIF or LOGICALROUTER). The attachment_type is VIF by default. 27 * @param ctx context.Context Authentication Context 28 @param logicalPort 29 @return manager.LogicalPort*/ 30 func (a *LogicalSwitchingApiService) CreateLogicalPort(ctx context.Context, logicalPort manager.LogicalPort) (manager.LogicalPort, *http.Response, error) { 31 var ( 32 localVarHttpMethod = strings.ToUpper("Post") 33 localVarPostBody interface{} 34 localVarFileName string 35 localVarFileBytes []byte 36 successPayload manager.LogicalPort 37 ) 38 39 // create path and map variables 40 localVarPath := a.client.cfg.BasePath + "/logical-ports" 41 42 localVarHeaderParams := make(map[string]string) 43 localVarQueryParams := url.Values{} 44 localVarFormParams := url.Values{} 45 46 // to determine the Content-Type header 47 localVarHttpContentTypes := []string{"application/json"} 48 49 // set Content-Type header 50 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 51 if localVarHttpContentType != "" { 52 localVarHeaderParams["Content-Type"] = localVarHttpContentType 53 } 54 55 // to determine the Accept header 56 localVarHttpHeaderAccepts := []string{ 57 "application/json", 58 } 59 60 // set Accept header 61 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 62 if localVarHttpHeaderAccept != "" { 63 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 64 } 65 // body params 66 localVarPostBody = &logicalPort 67 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 68 if err != nil { 69 return successPayload, nil, err 70 } 71 72 localVarHttpResponse, err := a.client.callAPI(r) 73 if err != nil || localVarHttpResponse == nil { 74 return successPayload, localVarHttpResponse, err 75 } 76 defer localVarHttpResponse.Body.Close() 77 if localVarHttpResponse.StatusCode >= 300 { 78 return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status) 79 } 80 81 if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil { 82 return successPayload, localVarHttpResponse, err 83 } 84 85 return successPayload, localVarHttpResponse, err 86 } 87 88 /* LogicalSwitchingApiService Create a Logical Switch 89 Creates a new logical switch. The request must include the transport_zone_id, display_name, and admin_state (UP or DOWN). The replication_mode (MTEP or SOURCE) is required for overlay logical switches, but not for VLAN-based logical switches. A vlan needs to be provided for VLAN-based logical switches 90 * @param ctx context.Context Authentication Context 91 @param logicalSwitch 92 @return manager.LogicalSwitch*/ 93 func (a *LogicalSwitchingApiService) CreateLogicalSwitch(ctx context.Context, logicalSwitch manager.LogicalSwitch) (manager.LogicalSwitch, *http.Response, error) { 94 var ( 95 localVarHttpMethod = strings.ToUpper("Post") 96 localVarPostBody interface{} 97 localVarFileName string 98 localVarFileBytes []byte 99 successPayload manager.LogicalSwitch 100 ) 101 102 // create path and map variables 103 localVarPath := a.client.cfg.BasePath + "/logical-switches" 104 105 localVarHeaderParams := make(map[string]string) 106 localVarQueryParams := url.Values{} 107 localVarFormParams := url.Values{} 108 109 // to determine the Content-Type header 110 localVarHttpContentTypes := []string{"application/json"} 111 112 // set Content-Type header 113 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 114 if localVarHttpContentType != "" { 115 localVarHeaderParams["Content-Type"] = localVarHttpContentType 116 } 117 118 // to determine the Accept header 119 localVarHttpHeaderAccepts := []string{ 120 "application/json", 121 } 122 123 // set Accept header 124 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 125 if localVarHttpHeaderAccept != "" { 126 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 127 } 128 // body params 129 localVarPostBody = &logicalSwitch 130 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 131 if err != nil { 132 return successPayload, nil, err 133 } 134 135 localVarHttpResponse, err := a.client.callAPI(r) 136 if err != nil || localVarHttpResponse == nil { 137 return successPayload, localVarHttpResponse, err 138 } 139 defer localVarHttpResponse.Body.Close() 140 if localVarHttpResponse.StatusCode >= 300 { 141 return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status) 142 } 143 144 if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil { 145 return successPayload, localVarHttpResponse, err 146 } 147 148 return successPayload, localVarHttpResponse, err 149 } 150 151 /* LogicalSwitchingApiService Create a Switching Profile 152 Creates a new, custom qos, port-mirroring, spoof-guard or port-security switching profile. You can override their default switching profile assignments by creating a new switching profile and assigning it to one or more logical switches. You cannot override the default ipfix or ip_discovery switching profiles. 153 * @param ctx context.Context Authentication Context 154 @param baseSwitchingProfile 155 @return manager.BaseSwitchingProfile*/ 156 func (a *LogicalSwitchingApiService) CreateSwitchingProfile(ctx context.Context, baseSwitchingProfile manager.BaseSwitchingProfile) (manager.BaseSwitchingProfile, *http.Response, error) { 157 var ( 158 localVarHttpMethod = strings.ToUpper("Post") 159 localVarPostBody interface{} 160 localVarFileName string 161 localVarFileBytes []byte 162 successPayload manager.BaseSwitchingProfile 163 ) 164 165 // create path and map variables 166 localVarPath := a.client.cfg.BasePath + "/switching-profiles" 167 168 localVarHeaderParams := make(map[string]string) 169 localVarQueryParams := url.Values{} 170 localVarFormParams := url.Values{} 171 172 // to determine the Content-Type header 173 localVarHttpContentTypes := []string{"application/json"} 174 175 // set Content-Type header 176 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 177 if localVarHttpContentType != "" { 178 localVarHeaderParams["Content-Type"] = localVarHttpContentType 179 } 180 181 // to determine the Accept header 182 localVarHttpHeaderAccepts := []string{ 183 "application/json", 184 } 185 186 // set Accept header 187 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 188 if localVarHttpHeaderAccept != "" { 189 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 190 } 191 // body params 192 localVarPostBody = &baseSwitchingProfile 193 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 194 if err != nil { 195 return successPayload, nil, err 196 } 197 198 localVarHttpResponse, err := a.client.callAPI(r) 199 if err != nil || localVarHttpResponse == nil { 200 return successPayload, localVarHttpResponse, err 201 } 202 defer localVarHttpResponse.Body.Close() 203 if localVarHttpResponse.StatusCode >= 300 { 204 return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status) 205 } 206 207 if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil { 208 return successPayload, localVarHttpResponse, err 209 } 210 211 return successPayload, localVarHttpResponse, err 212 } 213 214 /* LogicalSwitchingApiService Create a Switching Profile 215 Creates a new, custom qos, port-mirroring, spoof-guard or port-security switching profile. You can override their default switching profile assignments by creating a new switching profile and assigning it to one or more logical switches. You cannot override the default ipfix or ip_discovery switching profiles. 216 * @param ctx context.Context Authentication Context 217 @param baseSwitchingProfile 218 @return manager.SwitchSecuritySwitchingProfile*/ 219 func (a *LogicalSwitchingApiService) CreateSwitchSecuritySwitchingProfile(ctx context.Context, baseSwitchingProfile manager.SwitchSecuritySwitchingProfile) (manager.SwitchSecuritySwitchingProfile, *http.Response, error) { 220 var ( 221 localVarHttpMethod = strings.ToUpper("Post") 222 localVarPostBody interface{} 223 localVarFileName string 224 localVarFileBytes []byte 225 successPayload manager.SwitchSecuritySwitchingProfile 226 ) 227 228 baseSwitchingProfile.ResourceType = "SwitchSecuritySwitchingProfile" 229 230 // create path and map variables 231 localVarPath := a.client.cfg.BasePath + "/switching-profiles" 232 233 localVarHeaderParams := make(map[string]string) 234 localVarQueryParams := url.Values{} 235 localVarFormParams := url.Values{} 236 237 // to determine the Content-Type header 238 localVarHttpContentTypes := []string{"application/json"} 239 240 // set Content-Type header 241 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 242 if localVarHttpContentType != "" { 243 localVarHeaderParams["Content-Type"] = localVarHttpContentType 244 } 245 246 // to determine the Accept header 247 localVarHttpHeaderAccepts := []string{ 248 "application/json", 249 } 250 251 // set Accept header 252 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 253 if localVarHttpHeaderAccept != "" { 254 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 255 } 256 // body params 257 localVarPostBody = &baseSwitchingProfile 258 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 259 if err != nil { 260 return successPayload, nil, err 261 } 262 263 localVarHttpResponse, err := a.client.callAPI(r) 264 if err != nil || localVarHttpResponse == nil { 265 return successPayload, localVarHttpResponse, err 266 } 267 defer localVarHttpResponse.Body.Close() 268 if localVarHttpResponse.StatusCode >= 300 { 269 return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status) 270 } 271 272 if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil { 273 return successPayload, localVarHttpResponse, err 274 } 275 276 return successPayload, localVarHttpResponse, err 277 } 278 279 /* LogicalSwitchingApiService Create a Switching Profile 280 Creates a new, custom qos, port-mirroring, spoof-guard or port-security switching profile. You can override their default switching profile assignments by creating a new switching profile and assigning it to one or more logical switches. You cannot override the default ipfix or ip_discovery switching profiles. 281 * @param ctx context.Context Authentication Context 282 @param baseSwitchingProfile 283 @return manager.MacManagementSwitchingProfile*/ 284 func (a *LogicalSwitchingApiService) CreateMacManagementSwitchingProfile(ctx context.Context, baseSwitchingProfile manager.MacManagementSwitchingProfile) (manager.MacManagementSwitchingProfile, *http.Response, error) { 285 var ( 286 localVarHttpMethod = strings.ToUpper("Post") 287 localVarPostBody interface{} 288 localVarFileName string 289 localVarFileBytes []byte 290 successPayload manager.MacManagementSwitchingProfile 291 ) 292 293 baseSwitchingProfile.ResourceType = "MacManagementSwitchingProfile" 294 295 // create path and map variables 296 localVarPath := a.client.cfg.BasePath + "/switching-profiles" 297 298 localVarHeaderParams := make(map[string]string) 299 localVarQueryParams := url.Values{} 300 localVarFormParams := url.Values{} 301 302 // to determine the Content-Type header 303 localVarHttpContentTypes := []string{"application/json"} 304 305 // set Content-Type header 306 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 307 if localVarHttpContentType != "" { 308 localVarHeaderParams["Content-Type"] = localVarHttpContentType 309 } 310 311 // to determine the Accept header 312 localVarHttpHeaderAccepts := []string{ 313 "application/json", 314 } 315 316 // set Accept header 317 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 318 if localVarHttpHeaderAccept != "" { 319 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 320 } 321 // body params 322 localVarPostBody = &baseSwitchingProfile 323 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 324 if err != nil { 325 return successPayload, nil, err 326 } 327 328 localVarHttpResponse, err := a.client.callAPI(r) 329 if err != nil || localVarHttpResponse == nil { 330 return successPayload, localVarHttpResponse, err 331 } 332 defer localVarHttpResponse.Body.Close() 333 if localVarHttpResponse.StatusCode >= 300 { 334 return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status) 335 } 336 337 if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil { 338 return successPayload, localVarHttpResponse, err 339 } 340 341 return successPayload, localVarHttpResponse, err 342 } 343 344 /* LogicalSwitchingApiService Create a Switching Profile 345 Creates a new, custom qos, port-mirroring, spoof-guard or port-security switching profile. You can override their default switching profile assignments by creating a new switching profile and assigning it to one or more logical switches. You cannot override the default ipfix or ip_discovery switching profiles. 346 * @param ctx context.Context Authentication Context 347 @param baseSwitchingProfile 348 @return manager.IpDiscoverySwitchingProfile*/ 349 func (a *LogicalSwitchingApiService) CreateIpDiscoverySwitchingProfile(ctx context.Context, baseSwitchingProfile manager.IpDiscoverySwitchingProfile) (manager.IpDiscoverySwitchingProfile, *http.Response, error) { 350 var ( 351 localVarHttpMethod = strings.ToUpper("Post") 352 localVarPostBody interface{} 353 localVarFileName string 354 localVarFileBytes []byte 355 successPayload manager.IpDiscoverySwitchingProfile 356 ) 357 358 baseSwitchingProfile.ResourceType = "IpDiscoverySwitchingProfile" 359 360 // create path and map variables 361 localVarPath := a.client.cfg.BasePath + "/switching-profiles" 362 363 localVarHeaderParams := make(map[string]string) 364 localVarQueryParams := url.Values{} 365 localVarFormParams := url.Values{} 366 367 // to determine the Content-Type header 368 localVarHttpContentTypes := []string{"application/json"} 369 370 // set Content-Type header 371 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 372 if localVarHttpContentType != "" { 373 localVarHeaderParams["Content-Type"] = localVarHttpContentType 374 } 375 376 // to determine the Accept header 377 localVarHttpHeaderAccepts := []string{ 378 "application/json", 379 } 380 381 // set Accept header 382 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 383 if localVarHttpHeaderAccept != "" { 384 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 385 } 386 // body params 387 localVarPostBody = &baseSwitchingProfile 388 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 389 if err != nil { 390 return successPayload, nil, err 391 } 392 393 localVarHttpResponse, err := a.client.callAPI(r) 394 if err != nil || localVarHttpResponse == nil { 395 return successPayload, localVarHttpResponse, err 396 } 397 defer localVarHttpResponse.Body.Close() 398 if localVarHttpResponse.StatusCode >= 300 { 399 return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status) 400 } 401 402 if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil { 403 return successPayload, localVarHttpResponse, err 404 } 405 406 return successPayload, localVarHttpResponse, err 407 } 408 409 /* LogicalSwitchingApiService Create a Switching Profile 410 Creates a new, custom qos, port-mirroring, spoof-guard or port-security switching profile. You can override their default switching profile assignments by creating a new switching profile and assigning it to one or more logical switches. You cannot override the default ipfix or ip_discovery switching profiles. 411 * @param ctx context.Context Authentication Context 412 @param baseSwitchingProfile 413 @return manager.PortMirroringSwitchingProfile*/ 414 func (a *LogicalSwitchingApiService) CreatePortMirroringSwitchingProfile(ctx context.Context, baseSwitchingProfile manager.PortMirroringSwitchingProfile) (manager.PortMirroringSwitchingProfile, *http.Response, error) { 415 var ( 416 localVarHttpMethod = strings.ToUpper("Post") 417 localVarPostBody interface{} 418 localVarFileName string 419 localVarFileBytes []byte 420 successPayload manager.PortMirroringSwitchingProfile 421 ) 422 423 baseSwitchingProfile.ResourceType = "PortMirroringSwitchingProfile" 424 425 // create path and map variables 426 localVarPath := a.client.cfg.BasePath + "/switching-profiles" 427 428 localVarHeaderParams := make(map[string]string) 429 localVarQueryParams := url.Values{} 430 localVarFormParams := url.Values{} 431 432 // to determine the Content-Type header 433 localVarHttpContentTypes := []string{"application/json"} 434 435 // set Content-Type header 436 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 437 if localVarHttpContentType != "" { 438 localVarHeaderParams["Content-Type"] = localVarHttpContentType 439 } 440 441 // to determine the Accept header 442 localVarHttpHeaderAccepts := []string{ 443 "application/json", 444 } 445 446 // set Accept header 447 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 448 if localVarHttpHeaderAccept != "" { 449 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 450 } 451 // body params 452 localVarPostBody = &baseSwitchingProfile 453 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 454 if err != nil { 455 return successPayload, nil, err 456 } 457 458 localVarHttpResponse, err := a.client.callAPI(r) 459 if err != nil || localVarHttpResponse == nil { 460 return successPayload, localVarHttpResponse, err 461 } 462 defer localVarHttpResponse.Body.Close() 463 if localVarHttpResponse.StatusCode >= 300 { 464 return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status) 465 } 466 467 if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil { 468 return successPayload, localVarHttpResponse, err 469 } 470 471 return successPayload, localVarHttpResponse, err 472 } 473 474 /* LogicalSwitchingApiService Create a Switching Profile 475 Creates a new, custom qos, port-mirroring, spoof-guard or port-security switching profile. You can override their default switching profile assignments by creating a new switching profile and assigning it to one or more logical switches. You cannot override the default ipfix or ip_discovery switching profiles. 476 * @param ctx context.Context Authentication Context 477 @param baseSwitchingProfile 478 @return manager.SpoofGuardSwitchingProfile*/ 479 func (a *LogicalSwitchingApiService) CreateSpoofGuardSwitchingProfile(ctx context.Context, baseSwitchingProfile manager.SpoofGuardSwitchingProfile) (manager.SpoofGuardSwitchingProfile, *http.Response, error) { 480 var ( 481 localVarHttpMethod = strings.ToUpper("Post") 482 localVarPostBody interface{} 483 localVarFileName string 484 localVarFileBytes []byte 485 successPayload manager.SpoofGuardSwitchingProfile 486 ) 487 488 baseSwitchingProfile.ResourceType = "SpoofGuardSwitchingProfile" 489 490 // create path and map variables 491 localVarPath := a.client.cfg.BasePath + "/switching-profiles" 492 493 localVarHeaderParams := make(map[string]string) 494 localVarQueryParams := url.Values{} 495 localVarFormParams := url.Values{} 496 497 // to determine the Content-Type header 498 localVarHttpContentTypes := []string{"application/json"} 499 500 // set Content-Type header 501 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 502 if localVarHttpContentType != "" { 503 localVarHeaderParams["Content-Type"] = localVarHttpContentType 504 } 505 506 // to determine the Accept header 507 localVarHttpHeaderAccepts := []string{ 508 "application/json", 509 } 510 511 // set Accept header 512 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 513 if localVarHttpHeaderAccept != "" { 514 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 515 } 516 // body params 517 localVarPostBody = &baseSwitchingProfile 518 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 519 if err != nil { 520 return successPayload, nil, err 521 } 522 523 localVarHttpResponse, err := a.client.callAPI(r) 524 if err != nil || localVarHttpResponse == nil { 525 return successPayload, localVarHttpResponse, err 526 } 527 defer localVarHttpResponse.Body.Close() 528 if localVarHttpResponse.StatusCode >= 300 { 529 return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status) 530 } 531 532 if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil { 533 return successPayload, localVarHttpResponse, err 534 } 535 536 return successPayload, localVarHttpResponse, err 537 } 538 539 /* LogicalSwitchingApiService Create a Switching Profile 540 Creates a new, custom qos, port-mirroring, spoof-guard or port-security switching profile. You can override their default switching profile assignments by creating a new switching profile and assigning it to one or more logical switches. You cannot override the default ipfix or ip_discovery switching profiles. 541 * @param ctx context.Context Authentication Context 542 @param baseSwitchingProfile 543 @return manager.QosSwitchingProfile*/ 544 func (a *LogicalSwitchingApiService) CreateQosSwitchingProfile(ctx context.Context, baseSwitchingProfile manager.QosSwitchingProfile) (manager.QosSwitchingProfile, *http.Response, error) { 545 var ( 546 localVarHttpMethod = strings.ToUpper("Post") 547 localVarPostBody interface{} 548 localVarFileName string 549 localVarFileBytes []byte 550 successPayload manager.QosSwitchingProfile 551 ) 552 553 baseSwitchingProfile.ResourceType = "QosSwitchingProfile" 554 555 // create path and map variables 556 localVarPath := a.client.cfg.BasePath + "/switching-profiles" 557 558 localVarHeaderParams := make(map[string]string) 559 localVarQueryParams := url.Values{} 560 localVarFormParams := url.Values{} 561 562 // to determine the Content-Type header 563 localVarHttpContentTypes := []string{"application/json"} 564 565 // set Content-Type header 566 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 567 if localVarHttpContentType != "" { 568 localVarHeaderParams["Content-Type"] = localVarHttpContentType 569 } 570 571 // to determine the Accept header 572 localVarHttpHeaderAccepts := []string{ 573 "application/json", 574 } 575 576 // set Accept header 577 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 578 if localVarHttpHeaderAccept != "" { 579 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 580 } 581 // body params 582 localVarPostBody = &baseSwitchingProfile 583 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 584 if err != nil { 585 return successPayload, nil, err 586 } 587 588 localVarHttpResponse, err := a.client.callAPI(r) 589 if err != nil || localVarHttpResponse == nil { 590 return successPayload, localVarHttpResponse, err 591 } 592 defer localVarHttpResponse.Body.Close() 593 if localVarHttpResponse.StatusCode >= 300 { 594 return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status) 595 } 596 597 if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil { 598 return successPayload, localVarHttpResponse, err 599 } 600 601 return successPayload, localVarHttpResponse, err 602 } 603 604 /* LogicalSwitchingApiService Delete a Logical Port 605 Deletes the specified logical switch port. By default, if logical port has attachments, or it is added to any NSGroup, the deletion will be failed. Option detach could be used for deleting logical port forcibly. 606 * @param ctx context.Context Authentication Context 607 @param lportId 608 @param optional (nil or map[string]interface{}) with one or more of: 609 @param "detach" (bool) force delete even if attached or referenced by a group 610 @return */ 611 func (a *LogicalSwitchingApiService) DeleteLogicalPort(ctx context.Context, lportId string, localVarOptionals map[string]interface{}) (*http.Response, error) { 612 var ( 613 localVarHttpMethod = strings.ToUpper("Delete") 614 localVarPostBody interface{} 615 localVarFileName string 616 localVarFileBytes []byte 617 ) 618 619 // create path and map variables 620 localVarPath := a.client.cfg.BasePath + "/logical-ports/{lport-id}" 621 localVarPath = strings.Replace(localVarPath, "{"+"lport-id"+"}", fmt.Sprintf("%v", lportId), -1) 622 623 localVarHeaderParams := make(map[string]string) 624 localVarQueryParams := url.Values{} 625 localVarFormParams := url.Values{} 626 627 if err := typeCheckParameter(localVarOptionals["detach"], "bool", "detach"); err != nil { 628 return nil, err 629 } 630 631 if localVarTempParam, localVarOk := localVarOptionals["detach"].(bool); localVarOk { 632 localVarQueryParams.Add("detach", parameterToString(localVarTempParam, "")) 633 } 634 // to determine the Content-Type header 635 localVarHttpContentTypes := []string{"application/json"} 636 637 // set Content-Type header 638 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 639 if localVarHttpContentType != "" { 640 localVarHeaderParams["Content-Type"] = localVarHttpContentType 641 } 642 643 // to determine the Accept header 644 localVarHttpHeaderAccepts := []string{ 645 "application/json", 646 } 647 648 // set Accept header 649 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 650 if localVarHttpHeaderAccept != "" { 651 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 652 } 653 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 654 if err != nil { 655 return nil, err 656 } 657 658 localVarHttpResponse, err := a.client.callAPI(r) 659 if err != nil || localVarHttpResponse == nil { 660 return localVarHttpResponse, err 661 } 662 defer localVarHttpResponse.Body.Close() 663 if localVarHttpResponse.StatusCode >= 300 { 664 return localVarHttpResponse, reportError(localVarHttpResponse.Status) 665 } 666 667 return localVarHttpResponse, err 668 } 669 670 /* LogicalSwitchingApiService Delete a Logical Switch 671 Removes a logical switch from the associated overlay or VLAN transport zone. By default, a logical switch cannot be deleted if there are logical ports on the switch, or it is added to a NSGroup. Cascade option can be used to delete all ports and the logical switch. Detach option can be used to delete the logical switch forcibly. 672 * @param ctx context.Context Authentication Context 673 @param lswitchId 674 @param optional (nil or map[string]interface{}) with one or more of: 675 @param "cascade" (bool) Delete a Logical Switch and all the logical ports in it, if none of the logical ports have any attachment. 676 @param "detach" (bool) Force delete a logical switch 677 @return */ 678 func (a *LogicalSwitchingApiService) DeleteLogicalSwitch(ctx context.Context, lswitchId string, localVarOptionals map[string]interface{}) (*http.Response, error) { 679 var ( 680 localVarHttpMethod = strings.ToUpper("Delete") 681 localVarPostBody interface{} 682 localVarFileName string 683 localVarFileBytes []byte 684 ) 685 686 // create path and map variables 687 localVarPath := a.client.cfg.BasePath + "/logical-switches/{lswitch-id}" 688 localVarPath = strings.Replace(localVarPath, "{"+"lswitch-id"+"}", fmt.Sprintf("%v", lswitchId), -1) 689 690 localVarHeaderParams := make(map[string]string) 691 localVarQueryParams := url.Values{} 692 localVarFormParams := url.Values{} 693 694 if err := typeCheckParameter(localVarOptionals["cascade"], "bool", "cascade"); err != nil { 695 return nil, err 696 } 697 if err := typeCheckParameter(localVarOptionals["detach"], "bool", "detach"); err != nil { 698 return nil, err 699 } 700 701 if localVarTempParam, localVarOk := localVarOptionals["cascade"].(bool); localVarOk { 702 localVarQueryParams.Add("cascade", parameterToString(localVarTempParam, "")) 703 } 704 if localVarTempParam, localVarOk := localVarOptionals["detach"].(bool); localVarOk { 705 localVarQueryParams.Add("detach", parameterToString(localVarTempParam, "")) 706 } 707 // to determine the Content-Type header 708 localVarHttpContentTypes := []string{"application/json"} 709 710 // set Content-Type header 711 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 712 if localVarHttpContentType != "" { 713 localVarHeaderParams["Content-Type"] = localVarHttpContentType 714 } 715 716 // to determine the Accept header 717 localVarHttpHeaderAccepts := []string{ 718 "application/json", 719 } 720 721 // set Accept header 722 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 723 if localVarHttpHeaderAccept != "" { 724 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 725 } 726 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 727 if err != nil { 728 return nil, err 729 } 730 731 localVarHttpResponse, err := a.client.callAPI(r) 732 if err != nil || localVarHttpResponse == nil { 733 return localVarHttpResponse, err 734 } 735 defer localVarHttpResponse.Body.Close() 736 if localVarHttpResponse.StatusCode >= 300 { 737 return localVarHttpResponse, reportError(localVarHttpResponse.Status) 738 } 739 740 return localVarHttpResponse, err 741 } 742 743 /* LogicalSwitchingApiService Delete a Switching Profile 744 Deletes the specified switching profile. 745 * @param ctx context.Context Authentication Context 746 @param switchingProfileId 747 @param optional (nil or map[string]interface{}) with one or more of: 748 @param "unbind" (bool) force unbinding of logical switches and ports from a switching profile 749 @return */ 750 func (a *LogicalSwitchingApiService) DeleteSwitchingProfile(ctx context.Context, switchingProfileId string, localVarOptionals map[string]interface{}) (*http.Response, error) { 751 var ( 752 localVarHttpMethod = strings.ToUpper("Delete") 753 localVarPostBody interface{} 754 localVarFileName string 755 localVarFileBytes []byte 756 ) 757 758 // create path and map variables 759 localVarPath := a.client.cfg.BasePath + "/switching-profiles/{switching-profile-id}" 760 localVarPath = strings.Replace(localVarPath, "{"+"switching-profile-id"+"}", fmt.Sprintf("%v", switchingProfileId), -1) 761 762 localVarHeaderParams := make(map[string]string) 763 localVarQueryParams := url.Values{} 764 localVarFormParams := url.Values{} 765 766 if err := typeCheckParameter(localVarOptionals["unbind"], "bool", "unbind"); err != nil { 767 return nil, err 768 } 769 770 if localVarTempParam, localVarOk := localVarOptionals["unbind"].(bool); localVarOk { 771 localVarQueryParams.Add("unbind", parameterToString(localVarTempParam, "")) 772 } 773 // to determine the Content-Type header 774 localVarHttpContentTypes := []string{"application/json"} 775 776 // set Content-Type header 777 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 778 if localVarHttpContentType != "" { 779 localVarHeaderParams["Content-Type"] = localVarHttpContentType 780 } 781 782 // to determine the Accept header 783 localVarHttpHeaderAccepts := []string{ 784 "application/json", 785 } 786 787 // set Accept header 788 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 789 if localVarHttpHeaderAccept != "" { 790 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 791 } 792 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 793 if err != nil { 794 return nil, err 795 } 796 797 localVarHttpResponse, err := a.client.callAPI(r) 798 if err != nil || localVarHttpResponse == nil { 799 return localVarHttpResponse, err 800 } 801 defer localVarHttpResponse.Body.Close() 802 if localVarHttpResponse.StatusCode >= 300 { 803 return localVarHttpResponse, reportError(localVarHttpResponse.Status) 804 } 805 806 return localVarHttpResponse, err 807 } 808 809 /* LogicalSwitchingApiService Get Information About a Logical Port 810 Returns information about a specified logical port. 811 * @param ctx context.Context Authentication Context 812 @param lportId 813 @return manager.LogicalPort*/ 814 func (a *LogicalSwitchingApiService) GetLogicalPort(ctx context.Context, lportId string) (manager.LogicalPort, *http.Response, error) { 815 var ( 816 localVarHttpMethod = strings.ToUpper("Get") 817 localVarPostBody interface{} 818 localVarFileName string 819 localVarFileBytes []byte 820 successPayload manager.LogicalPort 821 ) 822 823 // create path and map variables 824 localVarPath := a.client.cfg.BasePath + "/logical-ports/{lport-id}" 825 localVarPath = strings.Replace(localVarPath, "{"+"lport-id"+"}", fmt.Sprintf("%v", lportId), -1) 826 827 localVarHeaderParams := make(map[string]string) 828 localVarQueryParams := url.Values{} 829 localVarFormParams := url.Values{} 830 831 // to determine the Content-Type header 832 localVarHttpContentTypes := []string{"application/json"} 833 834 // set Content-Type header 835 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 836 if localVarHttpContentType != "" { 837 localVarHeaderParams["Content-Type"] = localVarHttpContentType 838 } 839 840 // to determine the Accept header 841 localVarHttpHeaderAccepts := []string{ 842 "application/json", 843 } 844 845 // set Accept header 846 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 847 if localVarHttpHeaderAccept != "" { 848 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 849 } 850 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 851 if err != nil { 852 return successPayload, nil, err 853 } 854 855 localVarHttpResponse, err := a.client.callAPI(r) 856 if err != nil || localVarHttpResponse == nil { 857 return successPayload, localVarHttpResponse, err 858 } 859 defer localVarHttpResponse.Body.Close() 860 if localVarHttpResponse.StatusCode >= 300 { 861 return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status) 862 } 863 864 if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil { 865 return successPayload, localVarHttpResponse, err 866 } 867 868 return successPayload, localVarHttpResponse, err 869 } 870 871 /* LogicalSwitchingApiService Get MAC table of a logical port with a given port id (lport-id) 872 Returns MAC table of a specified logical port. If the target transport node id is not provided, the NSX manager will ask the controller for the transport node where the logical port is located. The query parameter \"source=cached\" is not supported. 873 * @param ctx context.Context Authentication Context 874 @param lportId 875 @param optional (nil or map[string]interface{}) with one or more of: 876 @param "cursor" (string) Opaque cursor to be used for getting next page of records (supplied by current result page) 877 @param "includedFields" (string) Comma separated list of fields that should be included to result of query 878 @param "pageSize" (int64) Maximum number of results to return in this page (server may return fewer) 879 @param "sortAscending" (bool) 880 @param "sortBy" (string) Field by which records are sorted 881 @param "source" (string) Data source type. 882 @param "transportNodeId" (string) TransportNode Id 883 @return manager.LogicalPortMacAddressListResult*/ 884 func (a *LogicalSwitchingApiService) GetLogicalPortMacTable(ctx context.Context, lportId string, localVarOptionals map[string]interface{}) (manager.LogicalPortMacAddressListResult, *http.Response, error) { 885 var ( 886 localVarHttpMethod = strings.ToUpper("Get") 887 localVarPostBody interface{} 888 localVarFileName string 889 localVarFileBytes []byte 890 successPayload manager.LogicalPortMacAddressListResult 891 ) 892 893 // create path and map variables 894 localVarPath := a.client.cfg.BasePath + "/logical-ports/{lport-id}/mac-table" 895 localVarPath = strings.Replace(localVarPath, "{"+"lport-id"+"}", fmt.Sprintf("%v", lportId), -1) 896 897 localVarHeaderParams := make(map[string]string) 898 localVarQueryParams := url.Values{} 899 localVarFormParams := url.Values{} 900 901 if err := typeCheckParameter(localVarOptionals["cursor"], "string", "cursor"); err != nil { 902 return successPayload, nil, err 903 } 904 if err := typeCheckParameter(localVarOptionals["includedFields"], "string", "includedFields"); err != nil { 905 return successPayload, nil, err 906 } 907 if err := typeCheckParameter(localVarOptionals["pageSize"], "int64", "pageSize"); err != nil { 908 return successPayload, nil, err 909 } 910 if err := typeCheckParameter(localVarOptionals["sortAscending"], "bool", "sortAscending"); err != nil { 911 return successPayload, nil, err 912 } 913 if err := typeCheckParameter(localVarOptionals["sortBy"], "string", "sortBy"); err != nil { 914 return successPayload, nil, err 915 } 916 if err := typeCheckParameter(localVarOptionals["source"], "string", "source"); err != nil { 917 return successPayload, nil, err 918 } 919 if err := typeCheckParameter(localVarOptionals["transportNodeId"], "string", "transportNodeId"); err != nil { 920 return successPayload, nil, err 921 } 922 923 if localVarTempParam, localVarOk := localVarOptionals["cursor"].(string); localVarOk { 924 localVarQueryParams.Add("cursor", parameterToString(localVarTempParam, "")) 925 } 926 if localVarTempParam, localVarOk := localVarOptionals["includedFields"].(string); localVarOk { 927 localVarQueryParams.Add("included_fields", parameterToString(localVarTempParam, "")) 928 } 929 if localVarTempParam, localVarOk := localVarOptionals["pageSize"].(int64); localVarOk { 930 localVarQueryParams.Add("page_size", parameterToString(localVarTempParam, "")) 931 } 932 if localVarTempParam, localVarOk := localVarOptionals["sortAscending"].(bool); localVarOk { 933 localVarQueryParams.Add("sort_ascending", parameterToString(localVarTempParam, "")) 934 } 935 if localVarTempParam, localVarOk := localVarOptionals["sortBy"].(string); localVarOk { 936 localVarQueryParams.Add("sort_by", parameterToString(localVarTempParam, "")) 937 } 938 if localVarTempParam, localVarOk := localVarOptionals["source"].(string); localVarOk { 939 localVarQueryParams.Add("source", parameterToString(localVarTempParam, "")) 940 } 941 if localVarTempParam, localVarOk := localVarOptionals["transportNodeId"].(string); localVarOk { 942 localVarQueryParams.Add("transport_node_id", parameterToString(localVarTempParam, "")) 943 } 944 // to determine the Content-Type header 945 localVarHttpContentTypes := []string{"application/json"} 946 947 // set Content-Type header 948 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 949 if localVarHttpContentType != "" { 950 localVarHeaderParams["Content-Type"] = localVarHttpContentType 951 } 952 953 // to determine the Accept header 954 localVarHttpHeaderAccepts := []string{ 955 "application/json", 956 } 957 958 // set Accept header 959 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 960 if localVarHttpHeaderAccept != "" { 961 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 962 } 963 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 964 if err != nil { 965 return successPayload, nil, err 966 } 967 968 localVarHttpResponse, err := a.client.callAPI(r) 969 if err != nil || localVarHttpResponse == nil { 970 return successPayload, localVarHttpResponse, err 971 } 972 defer localVarHttpResponse.Body.Close() 973 if localVarHttpResponse.StatusCode >= 300 { 974 return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status) 975 } 976 977 if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil { 978 return successPayload, localVarHttpResponse, err 979 } 980 981 return successPayload, localVarHttpResponse, err 982 } 983 984 /* LogicalSwitchingApiService Get MAC table of a logical port with a given port id (lport-id) 985 Returns MAC table in CSV format of a specified logical port. If the target transport node id is not provided, the NSX manager will ask the controller for the transport node where the logical port is located. The query parameter \"source=cached\" is not supported. 986 * @param ctx context.Context Authentication Context 987 @param lportId 988 @param optional (nil or map[string]interface{}) with one or more of: 989 @param "cursor" (string) Opaque cursor to be used for getting next page of records (supplied by current result page) 990 @param "includedFields" (string) Comma separated list of fields that should be included to result of query 991 @param "pageSize" (int64) Maximum number of results to return in this page (server may return fewer) 992 @param "sortAscending" (bool) 993 @param "sortBy" (string) Field by which records are sorted 994 @param "source" (string) Data source type. 995 @param "transportNodeId" (string) TransportNode Id 996 @return manager.LogicalPortMacAddressCsvListResult*/ 997 func (a *LogicalSwitchingApiService) GetLogicalPortMacTableInCsvFormatCsv(ctx context.Context, lportId string, localVarOptionals map[string]interface{}) (manager.LogicalPortMacAddressCsvListResult, *http.Response, error) { 998 var ( 999 localVarHttpMethod = strings.ToUpper("Get") 1000 localVarPostBody interface{} 1001 localVarFileName string 1002 localVarFileBytes []byte 1003 successPayload manager.LogicalPortMacAddressCsvListResult 1004 ) 1005 1006 // create path and map variables 1007 localVarPath := a.client.cfg.BasePath + "/logical-ports/{lport-id}/mac-table?format=csv" 1008 localVarPath = strings.Replace(localVarPath, "{"+"lport-id"+"}", fmt.Sprintf("%v", lportId), -1) 1009 1010 localVarHeaderParams := make(map[string]string) 1011 localVarQueryParams := url.Values{} 1012 localVarFormParams := url.Values{} 1013 1014 if err := typeCheckParameter(localVarOptionals["cursor"], "string", "cursor"); err != nil { 1015 return successPayload, nil, err 1016 } 1017 if err := typeCheckParameter(localVarOptionals["includedFields"], "string", "includedFields"); err != nil { 1018 return successPayload, nil, err 1019 } 1020 if err := typeCheckParameter(localVarOptionals["pageSize"], "int64", "pageSize"); err != nil { 1021 return successPayload, nil, err 1022 } 1023 if err := typeCheckParameter(localVarOptionals["sortAscending"], "bool", "sortAscending"); err != nil { 1024 return successPayload, nil, err 1025 } 1026 if err := typeCheckParameter(localVarOptionals["sortBy"], "string", "sortBy"); err != nil { 1027 return successPayload, nil, err 1028 } 1029 if err := typeCheckParameter(localVarOptionals["source"], "string", "source"); err != nil { 1030 return successPayload, nil, err 1031 } 1032 if err := typeCheckParameter(localVarOptionals["transportNodeId"], "string", "transportNodeId"); err != nil { 1033 return successPayload, nil, err 1034 } 1035 1036 if localVarTempParam, localVarOk := localVarOptionals["cursor"].(string); localVarOk { 1037 localVarQueryParams.Add("cursor", parameterToString(localVarTempParam, "")) 1038 } 1039 if localVarTempParam, localVarOk := localVarOptionals["includedFields"].(string); localVarOk { 1040 localVarQueryParams.Add("included_fields", parameterToString(localVarTempParam, "")) 1041 } 1042 if localVarTempParam, localVarOk := localVarOptionals["pageSize"].(int64); localVarOk { 1043 localVarQueryParams.Add("page_size", parameterToString(localVarTempParam, "")) 1044 } 1045 if localVarTempParam, localVarOk := localVarOptionals["sortAscending"].(bool); localVarOk { 1046 localVarQueryParams.Add("sort_ascending", parameterToString(localVarTempParam, "")) 1047 } 1048 if localVarTempParam, localVarOk := localVarOptionals["sortBy"].(string); localVarOk { 1049 localVarQueryParams.Add("sort_by", parameterToString(localVarTempParam, "")) 1050 } 1051 if localVarTempParam, localVarOk := localVarOptionals["source"].(string); localVarOk { 1052 localVarQueryParams.Add("source", parameterToString(localVarTempParam, "")) 1053 } 1054 if localVarTempParam, localVarOk := localVarOptionals["transportNodeId"].(string); localVarOk { 1055 localVarQueryParams.Add("transport_node_id", parameterToString(localVarTempParam, "")) 1056 } 1057 // to determine the Content-Type header 1058 localVarHttpContentTypes := []string{"application/json"} 1059 1060 // set Content-Type header 1061 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 1062 if localVarHttpContentType != "" { 1063 localVarHeaderParams["Content-Type"] = localVarHttpContentType 1064 } 1065 1066 // to determine the Accept header 1067 localVarHttpHeaderAccepts := []string{ 1068 "text/csv", 1069 } 1070 1071 // set Accept header 1072 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 1073 if localVarHttpHeaderAccept != "" { 1074 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 1075 } 1076 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 1077 if err != nil { 1078 return successPayload, nil, err 1079 } 1080 1081 localVarHttpResponse, err := a.client.callAPI(r) 1082 if err != nil || localVarHttpResponse == nil { 1083 return successPayload, localVarHttpResponse, err 1084 } 1085 defer localVarHttpResponse.Body.Close() 1086 if localVarHttpResponse.StatusCode >= 300 { 1087 return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status) 1088 } 1089 1090 if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil { 1091 return successPayload, localVarHttpResponse, err 1092 } 1093 1094 return successPayload, localVarHttpResponse, err 1095 } 1096 1097 /* LogicalSwitchingApiService Get Operational Status for Logical Port of a Given Port ID (lport-id) 1098 Returns operational status of a specified logical port. 1099 * @param ctx context.Context Authentication Context 1100 @param lportId 1101 @param optional (nil or map[string]interface{}) with one or more of: 1102 @param "source" (string) Data source type. 1103 @return manager.LogicalPortOperationalStatus*/ 1104 func (a *LogicalSwitchingApiService) GetLogicalPortOperationalStatus(ctx context.Context, lportId string, localVarOptionals map[string]interface{}) (manager.LogicalPortOperationalStatus, *http.Response, error) { 1105 var ( 1106 localVarHttpMethod = strings.ToUpper("Get") 1107 localVarPostBody interface{} 1108 localVarFileName string 1109 localVarFileBytes []byte 1110 successPayload manager.LogicalPortOperationalStatus 1111 ) 1112 1113 // create path and map variables 1114 localVarPath := a.client.cfg.BasePath + "/logical-ports/{lport-id}/status" 1115 localVarPath = strings.Replace(localVarPath, "{"+"lport-id"+"}", fmt.Sprintf("%v", lportId), -1) 1116 1117 localVarHeaderParams := make(map[string]string) 1118 localVarQueryParams := url.Values{} 1119 localVarFormParams := url.Values{} 1120 1121 if err := typeCheckParameter(localVarOptionals["source"], "string", "source"); err != nil { 1122 return successPayload, nil, err 1123 } 1124 1125 if localVarTempParam, localVarOk := localVarOptionals["source"].(string); localVarOk { 1126 localVarQueryParams.Add("source", parameterToString(localVarTempParam, "")) 1127 } 1128 // to determine the Content-Type header 1129 localVarHttpContentTypes := []string{"application/json"} 1130 1131 // set Content-Type header 1132 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 1133 if localVarHttpContentType != "" { 1134 localVarHeaderParams["Content-Type"] = localVarHttpContentType 1135 } 1136 1137 // to determine the Accept header 1138 localVarHttpHeaderAccepts := []string{ 1139 "application/json", 1140 } 1141 1142 // set Accept header 1143 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 1144 if localVarHttpHeaderAccept != "" { 1145 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 1146 } 1147 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 1148 if err != nil { 1149 return successPayload, nil, err 1150 } 1151 1152 localVarHttpResponse, err := a.client.callAPI(r) 1153 if err != nil || localVarHttpResponse == nil { 1154 return successPayload, localVarHttpResponse, err 1155 } 1156 defer localVarHttpResponse.Body.Close() 1157 if localVarHttpResponse.StatusCode >= 300 { 1158 return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status) 1159 } 1160 1161 if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil { 1162 return successPayload, localVarHttpResponse, err 1163 } 1164 1165 return successPayload, localVarHttpResponse, err 1166 } 1167 1168 /* LogicalSwitchingApiService Get realized state & location of a logical port 1169 Returns transport node id for a specified logical port. Also returns information about all address bindings of the specified logical port. This includes address bindings discovered via various snooping methods like ARP snooping, DHCP snooping etc. and addressing bindings that are realized based on user configuration. 1170 * @param ctx context.Context Authentication Context 1171 @param lportId 1172 @return manager.LogicalPortState*/ 1173 func (a *LogicalSwitchingApiService) GetLogicalPortState(ctx context.Context, lportId string) (manager.LogicalPortState, *http.Response, error) { 1174 var ( 1175 localVarHttpMethod = strings.ToUpper("Get") 1176 localVarPostBody interface{} 1177 localVarFileName string 1178 localVarFileBytes []byte 1179 successPayload manager.LogicalPortState 1180 ) 1181 1182 // create path and map variables 1183 localVarPath := a.client.cfg.BasePath + "/logical-ports/{lport-id}/state" 1184 localVarPath = strings.Replace(localVarPath, "{"+"lport-id"+"}", fmt.Sprintf("%v", lportId), -1) 1185 1186 localVarHeaderParams := make(map[string]string) 1187 localVarQueryParams := url.Values{} 1188 localVarFormParams := url.Values{} 1189 1190 // to determine the Content-Type header 1191 localVarHttpContentTypes := []string{"application/json"} 1192 1193 // set Content-Type header 1194 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 1195 if localVarHttpContentType != "" { 1196 localVarHeaderParams["Content-Type"] = localVarHttpContentType 1197 } 1198 1199 // to determine the Accept header 1200 localVarHttpHeaderAccepts := []string{ 1201 "application/json", 1202 } 1203 1204 // set Accept header 1205 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 1206 if localVarHttpHeaderAccept != "" { 1207 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 1208 } 1209 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 1210 if err != nil { 1211 return successPayload, nil, err 1212 } 1213 1214 localVarHttpResponse, err := a.client.callAPI(r) 1215 if err != nil || localVarHttpResponse == nil { 1216 return successPayload, localVarHttpResponse, err 1217 } 1218 defer localVarHttpResponse.Body.Close() 1219 if localVarHttpResponse.StatusCode >= 300 { 1220 return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status) 1221 } 1222 1223 if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil { 1224 return successPayload, localVarHttpResponse, err 1225 } 1226 1227 return successPayload, localVarHttpResponse, err 1228 } 1229 1230 /* LogicalSwitchingApiService Get Statistics for Logical Port of a Given Port ID (lport-id) 1231 Returns statistics of a specified logical port. If the logical port is attached to a logical router port, query parameter \"source=realtime\" is not supported. 1232 * @param ctx context.Context Authentication Context 1233 @param lportId 1234 @param optional (nil or map[string]interface{}) with one or more of: 1235 @param "source" (string) Data source type. 1236 @return manager.LogicalPortStatistics*/ 1237 func (a *LogicalSwitchingApiService) GetLogicalPortStatistics(ctx context.Context, lportId string, localVarOptionals map[string]interface{}) (manager.LogicalPortStatistics, *http.Response, error) { 1238 var ( 1239 localVarHttpMethod = strings.ToUpper("Get") 1240 localVarPostBody interface{} 1241 localVarFileName string 1242 localVarFileBytes []byte 1243 successPayload manager.LogicalPortStatistics 1244 ) 1245 1246 // create path and map variables 1247 localVarPath := a.client.cfg.BasePath + "/logical-ports/{lport-id}/statistics" 1248 localVarPath = strings.Replace(localVarPath, "{"+"lport-id"+"}", fmt.Sprintf("%v", lportId), -1) 1249 1250 localVarHeaderParams := make(map[string]string) 1251 localVarQueryParams := url.Values{} 1252 localVarFormParams := url.Values{} 1253 1254 if err := typeCheckParameter(localVarOptionals["source"], "string", "source"); err != nil { 1255 return successPayload, nil, err 1256 } 1257 1258 if localVarTempParam, localVarOk := localVarOptionals["source"].(string); localVarOk { 1259 localVarQueryParams.Add("source", parameterToString(localVarTempParam, "")) 1260 } 1261 // to determine the Content-Type header 1262 localVarHttpContentTypes := []string{"application/json"} 1263 1264 // set Content-Type header 1265 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 1266 if localVarHttpContentType != "" { 1267 localVarHeaderParams["Content-Type"] = localVarHttpContentType 1268 } 1269 1270 // to determine the Accept header 1271 localVarHttpHeaderAccepts := []string{ 1272 "application/json", 1273 } 1274 1275 // set Accept header 1276 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 1277 if localVarHttpHeaderAccept != "" { 1278 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 1279 } 1280 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 1281 if err != nil { 1282 return successPayload, nil, err 1283 } 1284 1285 localVarHttpResponse, err := a.client.callAPI(r) 1286 if err != nil || localVarHttpResponse == nil { 1287 return successPayload, localVarHttpResponse, err 1288 } 1289 defer localVarHttpResponse.Body.Close() 1290 if localVarHttpResponse.StatusCode >= 300 { 1291 return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status) 1292 } 1293 1294 if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil { 1295 return successPayload, localVarHttpResponse, err 1296 } 1297 1298 return successPayload, localVarHttpResponse, err 1299 } 1300 1301 /* LogicalSwitchingApiService Get Operational Status Summary of All Logical Ports in the System 1302 Returns operational status of all logical ports. The query parameter \"source=realtime\" is not supported. 1303 * @param ctx context.Context Authentication Context 1304 @param optional (nil or map[string]interface{}) with one or more of: 1305 @param "attachmentId" (string) Logical Port attachment Id 1306 @param "attachmentType" (string) Type of attachment for logical port; for query only. 1307 @param "bridgeClusterId" (string) Bridge Cluster identifier 1308 @param "cursor" (string) Opaque cursor to be used for getting next page of records (supplied by current result page) 1309 @param "diagnostic" (bool) Flag to enable showing of transit logical port. 1310 @param "includedFields" (string) Comma separated list of fields that should be included to result of query 1311 @param "logicalSwitchId" (string) Logical Switch identifier 1312 @param "pageSize" (int64) Maximum number of results to return in this page (server may return fewer) 1313 @param "parentVifId" (string) ID of the VIF of type PARENT 1314 @param "sortAscending" (bool) 1315 @param "sortBy" (string) Field by which records are sorted 1316 @param "source" (string) Data source type. 1317 @param "switchingProfileId" (string) Network Profile identifier 1318 @param "transportNodeId" (string) Transport node identifier 1319 @param "transportZoneId" (string) Transport zone identifier 1320 @return manager.LogicalPortStatusSummary*/ 1321 func (a *LogicalSwitchingApiService) GetLogicalPortStatusSummary(ctx context.Context, localVarOptionals map[string]interface{}) (manager.LogicalPortStatusSummary, *http.Response, error) { 1322 var ( 1323 localVarHttpMethod = strings.ToUpper("Get") 1324 localVarPostBody interface{} 1325 localVarFileName string 1326 localVarFileBytes []byte 1327 successPayload manager.LogicalPortStatusSummary 1328 ) 1329 1330 // create path and map variables 1331 localVarPath := a.client.cfg.BasePath + "/logical-ports/status" 1332 1333 localVarHeaderParams := make(map[string]string) 1334 localVarQueryParams := url.Values{} 1335 localVarFormParams := url.Values{} 1336 1337 if err := typeCheckParameter(localVarOptionals["attachmentId"], "string", "attachmentId"); err != nil { 1338 return successPayload, nil, err 1339 } 1340 if err := typeCheckParameter(localVarOptionals["attachmentType"], "string", "attachmentType"); err != nil { 1341 return successPayload, nil, err 1342 } 1343 if err := typeCheckParameter(localVarOptionals["bridgeClusterId"], "string", "bridgeClusterId"); err != nil { 1344 return successPayload, nil, err 1345 } 1346 if err := typeCheckParameter(localVarOptionals["cursor"], "string", "cursor"); err != nil { 1347 return successPayload, nil, err 1348 } 1349 if err := typeCheckParameter(localVarOptionals["diagnostic"], "bool", "diagnostic"); err != nil { 1350 return successPayload, nil, err 1351 } 1352 if err := typeCheckParameter(localVarOptionals["includedFields"], "string", "includedFields"); err != nil { 1353 return successPayload, nil, err 1354 } 1355 if err := typeCheckParameter(localVarOptionals["logicalSwitchId"], "string", "logicalSwitchId"); err != nil { 1356 return successPayload, nil, err 1357 } 1358 if err := typeCheckParameter(localVarOptionals["pageSize"], "int64", "pageSize"); err != nil { 1359 return successPayload, nil, err 1360 } 1361 if err := typeCheckParameter(localVarOptionals["parentVifId"], "string", "parentVifId"); err != nil { 1362 return successPayload, nil, err 1363 } 1364 if err := typeCheckParameter(localVarOptionals["sortAscending"], "bool", "sortAscending"); err != nil { 1365 return successPayload, nil, err 1366 } 1367 if err := typeCheckParameter(localVarOptionals["sortBy"], "string", "sortBy"); err != nil { 1368 return successPayload, nil, err 1369 } 1370 if err := typeCheckParameter(localVarOptionals["source"], "string", "source"); err != nil { 1371 return successPayload, nil, err 1372 } 1373 if err := typeCheckParameter(localVarOptionals["switchingProfileId"], "string", "switchingProfileId"); err != nil { 1374 return successPayload, nil, err 1375 } 1376 if err := typeCheckParameter(localVarOptionals["transportNodeId"], "string", "transportNodeId"); err != nil { 1377 return successPayload, nil, err 1378 } 1379 if err := typeCheckParameter(localVarOptionals["transportZoneId"], "string", "transportZoneId"); err != nil { 1380 return successPayload, nil, err 1381 } 1382 1383 if localVarTempParam, localVarOk := localVarOptionals["attachmentId"].(string); localVarOk { 1384 localVarQueryParams.Add("attachment_id", parameterToString(localVarTempParam, "")) 1385 } 1386 if localVarTempParam, localVarOk := localVarOptionals["attachmentType"].(string); localVarOk { 1387 localVarQueryParams.Add("attachment_type", parameterToString(localVarTempParam, "")) 1388 } 1389 if localVarTempParam, localVarOk := localVarOptionals["bridgeClusterId"].(string); localVarOk { 1390 localVarQueryParams.Add("bridge_cluster_id", parameterToString(localVarTempParam, "")) 1391 } 1392 if localVarTempParam, localVarOk := localVarOptionals["cursor"].(string); localVarOk { 1393 localVarQueryParams.Add("cursor", parameterToString(localVarTempParam, "")) 1394 } 1395 if localVarTempParam, localVarOk := localVarOptionals["diagnostic"].(bool); localVarOk { 1396 localVarQueryParams.Add("diagnostic", parameterToString(localVarTempParam, "")) 1397 } 1398 if localVarTempParam, localVarOk := localVarOptionals["includedFields"].(string); localVarOk { 1399 localVarQueryParams.Add("included_fields", parameterToString(localVarTempParam, "")) 1400 } 1401 if localVarTempParam, localVarOk := localVarOptionals["logicalSwitchId"].(string); localVarOk { 1402 localVarQueryParams.Add("logical_switch_id", parameterToString(localVarTempParam, "")) 1403 } 1404 if localVarTempParam, localVarOk := localVarOptionals["pageSize"].(int64); localVarOk { 1405 localVarQueryParams.Add("page_size", parameterToString(localVarTempParam, "")) 1406 } 1407 if localVarTempParam, localVarOk := localVarOptionals["parentVifId"].(string); localVarOk { 1408 localVarQueryParams.Add("parent_vif_id", parameterToString(localVarTempParam, "")) 1409 } 1410 if localVarTempParam, localVarOk := localVarOptionals["sortAscending"].(bool); localVarOk { 1411 localVarQueryParams.Add("sort_ascending", parameterToString(localVarTempParam, "")) 1412 } 1413 if localVarTempParam, localVarOk := localVarOptionals["sortBy"].(string); localVarOk { 1414 localVarQueryParams.Add("sort_by", parameterToString(localVarTempParam, "")) 1415 } 1416 if localVarTempParam, localVarOk := localVarOptionals["source"].(string); localVarOk { 1417 localVarQueryParams.Add("source", parameterToString(localVarTempParam, "")) 1418 } 1419 if localVarTempParam, localVarOk := localVarOptionals["switchingProfileId"].(string); localVarOk { 1420 localVarQueryParams.Add("switching_profile_id", parameterToString(localVarTempParam, "")) 1421 } 1422 if localVarTempParam, localVarOk := localVarOptionals["transportNodeId"].(string); localVarOk { 1423 localVarQueryParams.Add("transport_node_id", parameterToString(localVarTempParam, "")) 1424 } 1425 if localVarTempParam, localVarOk := localVarOptionals["transportZoneId"].(string); localVarOk { 1426 localVarQueryParams.Add("transport_zone_id", parameterToString(localVarTempParam, "")) 1427 } 1428 // to determine the Content-Type header 1429 localVarHttpContentTypes := []string{"application/json"} 1430 1431 // set Content-Type header 1432 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 1433 if localVarHttpContentType != "" { 1434 localVarHeaderParams["Content-Type"] = localVarHttpContentType 1435 } 1436 1437 // to determine the Accept header 1438 localVarHttpHeaderAccepts := []string{ 1439 "application/json", 1440 } 1441 1442 // set Accept header 1443 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 1444 if localVarHttpHeaderAccept != "" { 1445 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 1446 } 1447 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 1448 if err != nil { 1449 return successPayload, nil, err 1450 } 1451 1452 localVarHttpResponse, err := a.client.callAPI(r) 1453 if err != nil || localVarHttpResponse == nil { 1454 return successPayload, localVarHttpResponse, err 1455 } 1456 defer localVarHttpResponse.Body.Close() 1457 if localVarHttpResponse.StatusCode >= 300 { 1458 return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status) 1459 } 1460 1461 if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil { 1462 return successPayload, localVarHttpResponse, err 1463 } 1464 1465 return successPayload, localVarHttpResponse, err 1466 } 1467 1468 /* LogicalSwitchingApiService Get Logical Switch associated with the provided id (lswitch-id) 1469 Returns information about the specified logical switch Id. 1470 * @param ctx context.Context Authentication Context 1471 @param lswitchId 1472 @return manager.LogicalSwitch*/ 1473 func (a *LogicalSwitchingApiService) GetLogicalSwitch(ctx context.Context, lswitchId string) (manager.LogicalSwitch, *http.Response, error) { 1474 var ( 1475 localVarHttpMethod = strings.ToUpper("Get") 1476 localVarPostBody interface{} 1477 localVarFileName string 1478 localVarFileBytes []byte 1479 successPayload manager.LogicalSwitch 1480 ) 1481 1482 // create path and map variables 1483 localVarPath := a.client.cfg.BasePath + "/logical-switches/{lswitch-id}" 1484 localVarPath = strings.Replace(localVarPath, "{"+"lswitch-id"+"}", fmt.Sprintf("%v", lswitchId), -1) 1485 1486 localVarHeaderParams := make(map[string]string) 1487 localVarQueryParams := url.Values{} 1488 localVarFormParams := url.Values{} 1489 1490 // to determine the Content-Type header 1491 localVarHttpContentTypes := []string{"application/json"} 1492 1493 // set Content-Type header 1494 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 1495 if localVarHttpContentType != "" { 1496 localVarHeaderParams["Content-Type"] = localVarHttpContentType 1497 } 1498 1499 // to determine the Accept header 1500 localVarHttpHeaderAccepts := []string{ 1501 "application/json", 1502 } 1503 1504 // set Accept header 1505 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 1506 if localVarHttpHeaderAccept != "" { 1507 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 1508 } 1509 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 1510 if err != nil { 1511 return successPayload, nil, err 1512 } 1513 1514 localVarHttpResponse, err := a.client.callAPI(r) 1515 if err != nil || localVarHttpResponse == nil { 1516 return successPayload, localVarHttpResponse, err 1517 } 1518 defer localVarHttpResponse.Body.Close() 1519 if localVarHttpResponse.StatusCode >= 300 { 1520 return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status) 1521 } 1522 1523 if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil { 1524 return successPayload, localVarHttpResponse, err 1525 } 1526 1527 return successPayload, localVarHttpResponse, err 1528 } 1529 1530 /* LogicalSwitchingApiService Get MAC Table for Logical Switch of the Given ID (lswitch-id) 1531 Returns MAC table of a specified logical switch from the given transport node if a transport node id is given in the query parameter, from the Central Controller Plane otherwise The query parameter \"source=cached\" is not supported. 1532 * @param ctx context.Context Authentication Context 1533 @param lswitchId 1534 @param optional (nil or map[string]interface{}) with one or more of: 1535 @param "cursor" (string) Opaque cursor to be used for getting next page of records (supplied by current result page) 1536 @param "includedFields" (string) Comma separated list of fields that should be included to result of query 1537 @param "pageSize" (int64) Maximum number of results to return in this page (server may return fewer) 1538 @param "sortAscending" (bool) 1539 @param "sortBy" (string) Field by which records are sorted 1540 @param "source" (string) Data source type. 1541 @param "transportNodeId" (string) TransportNode Id 1542 @return manager.MacAddressListResult*/ 1543 func (a *LogicalSwitchingApiService) GetLogicalSwitchMacTable(ctx context.Context, lswitchId string, localVarOptionals map[string]interface{}) (manager.MacAddressListResult, *http.Response, error) { 1544 var ( 1545 localVarHttpMethod = strings.ToUpper("Get") 1546 localVarPostBody interface{} 1547 localVarFileName string 1548 localVarFileBytes []byte 1549 successPayload manager.MacAddressListResult 1550 ) 1551 1552 // create path and map variables 1553 localVarPath := a.client.cfg.BasePath + "/logical-switches/{lswitch-id}/mac-table" 1554 localVarPath = strings.Replace(localVarPath, "{"+"lswitch-id"+"}", fmt.Sprintf("%v", lswitchId), -1) 1555 1556 localVarHeaderParams := make(map[string]string) 1557 localVarQueryParams := url.Values{} 1558 localVarFormParams := url.Values{} 1559 1560 if err := typeCheckParameter(localVarOptionals["cursor"], "string", "cursor"); err != nil { 1561 return successPayload, nil, err 1562 } 1563 if err := typeCheckParameter(localVarOptionals["includedFields"], "string", "includedFields"); err != nil { 1564 return successPayload, nil, err 1565 } 1566 if err := typeCheckParameter(localVarOptionals["pageSize"], "int64", "pageSize"); err != nil { 1567 return successPayload, nil, err 1568 } 1569 if err := typeCheckParameter(localVarOptionals["sortAscending"], "bool", "sortAscending"); err != nil { 1570 return successPayload, nil, err 1571 } 1572 if err := typeCheckParameter(localVarOptionals["sortBy"], "string", "sortBy"); err != nil { 1573 return successPayload, nil, err 1574 } 1575 if err := typeCheckParameter(localVarOptionals["source"], "string", "source"); err != nil { 1576 return successPayload, nil, err 1577 } 1578 if err := typeCheckParameter(localVarOptionals["transportNodeId"], "string", "transportNodeId"); err != nil { 1579 return successPayload, nil, err 1580 } 1581 1582 if localVarTempParam, localVarOk := localVarOptionals["cursor"].(string); localVarOk { 1583 localVarQueryParams.Add("cursor", parameterToString(localVarTempParam, "")) 1584 } 1585 if localVarTempParam, localVarOk := localVarOptionals["includedFields"].(string); localVarOk { 1586 localVarQueryParams.Add("included_fields", parameterToString(localVarTempParam, "")) 1587 } 1588 if localVarTempParam, localVarOk := localVarOptionals["pageSize"].(int64); localVarOk { 1589 localVarQueryParams.Add("page_size", parameterToString(localVarTempParam, "")) 1590 } 1591 if localVarTempParam, localVarOk := localVarOptionals["sortAscending"].(bool); localVarOk { 1592 localVarQueryParams.Add("sort_ascending", parameterToString(localVarTempParam, "")) 1593 } 1594 if localVarTempParam, localVarOk := localVarOptionals["sortBy"].(string); localVarOk { 1595 localVarQueryParams.Add("sort_by", parameterToString(localVarTempParam, "")) 1596 } 1597 if localVarTempParam, localVarOk := localVarOptionals["source"].(string); localVarOk { 1598 localVarQueryParams.Add("source", parameterToString(localVarTempParam, "")) 1599 } 1600 if localVarTempParam, localVarOk := localVarOptionals["transportNodeId"].(string); localVarOk { 1601 localVarQueryParams.Add("transport_node_id", parameterToString(localVarTempParam, "")) 1602 } 1603 // to determine the Content-Type header 1604 localVarHttpContentTypes := []string{"application/json"} 1605 1606 // set Content-Type header 1607 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 1608 if localVarHttpContentType != "" { 1609 localVarHeaderParams["Content-Type"] = localVarHttpContentType 1610 } 1611 1612 // to determine the Accept header 1613 localVarHttpHeaderAccepts := []string{ 1614 "application/json", 1615 } 1616 1617 // set Accept header 1618 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 1619 if localVarHttpHeaderAccept != "" { 1620 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 1621 } 1622 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 1623 if err != nil { 1624 return successPayload, nil, err 1625 } 1626 1627 localVarHttpResponse, err := a.client.callAPI(r) 1628 if err != nil || localVarHttpResponse == nil { 1629 return successPayload, localVarHttpResponse, err 1630 } 1631 defer localVarHttpResponse.Body.Close() 1632 if localVarHttpResponse.StatusCode >= 300 { 1633 return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status) 1634 } 1635 1636 if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil { 1637 return successPayload, localVarHttpResponse, err 1638 } 1639 1640 return successPayload, localVarHttpResponse, err 1641 } 1642 1643 /* LogicalSwitchingApiService Get MAC Table for Logical Switch of the Given ID (lswitch-id) 1644 Returns MAC table of a specified logical switch in CSV format from the given transport node if a transport node id is given in the query parameter, from the Central Controller Plane otherwise The query parameter \"source=cached\" is not supported. 1645 * @param ctx context.Context Authentication Context 1646 @param lswitchId 1647 @param optional (nil or map[string]interface{}) with one or more of: 1648 @param "source" (string) Data source type. 1649 @param "transportNodeId" (string) TransportNode Id 1650 @return manager.MacAddressCsvListResult*/ 1651 func (a *LogicalSwitchingApiService) GetLogicalSwitchMacTableInCsvFormatCsv(ctx context.Context, lswitchId string, localVarOptionals map[string]interface{}) (manager.MacAddressCsvListResult, *http.Response, error) { 1652 var ( 1653 localVarHttpMethod = strings.ToUpper("Get") 1654 localVarPostBody interface{} 1655 localVarFileName string 1656 localVarFileBytes []byte 1657 successPayload manager.MacAddressCsvListResult 1658 ) 1659 1660 // create path and map variables 1661 localVarPath := a.client.cfg.BasePath + "/logical-switches/{lswitch-id}/mac-table?format=csv" 1662 localVarPath = strings.Replace(localVarPath, "{"+"lswitch-id"+"}", fmt.Sprintf("%v", lswitchId), -1) 1663 1664 localVarHeaderParams := make(map[string]string) 1665 localVarQueryParams := url.Values{} 1666 localVarFormParams := url.Values{} 1667 1668 if err := typeCheckParameter(localVarOptionals["source"], "string", "source"); err != nil { 1669 return successPayload, nil, err 1670 } 1671 if err := typeCheckParameter(localVarOptionals["transportNodeId"], "string", "transportNodeId"); err != nil { 1672 return successPayload, nil, err 1673 } 1674 1675 if localVarTempParam, localVarOk := localVarOptionals["source"].(string); localVarOk { 1676 localVarQueryParams.Add("source", parameterToString(localVarTempParam, "")) 1677 } 1678 if localVarTempParam, localVarOk := localVarOptionals["transportNodeId"].(string); localVarOk { 1679 localVarQueryParams.Add("transport_node_id", parameterToString(localVarTempParam, "")) 1680 } 1681 // to determine the Content-Type header 1682 localVarHttpContentTypes := []string{"application/json"} 1683 1684 // set Content-Type header 1685 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 1686 if localVarHttpContentType != "" { 1687 localVarHeaderParams["Content-Type"] = localVarHttpContentType 1688 } 1689 1690 // to determine the Accept header 1691 localVarHttpHeaderAccepts := []string{ 1692 "text/csv", 1693 } 1694 1695 // set Accept header 1696 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 1697 if localVarHttpHeaderAccept != "" { 1698 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 1699 } 1700 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 1701 if err != nil { 1702 return successPayload, nil, err 1703 } 1704 1705 localVarHttpResponse, err := a.client.callAPI(r) 1706 if err != nil || localVarHttpResponse == nil { 1707 return successPayload, localVarHttpResponse, err 1708 } 1709 defer localVarHttpResponse.Body.Close() 1710 if localVarHttpResponse.StatusCode >= 300 { 1711 return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status) 1712 } 1713 1714 if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil { 1715 return successPayload, localVarHttpResponse, err 1716 } 1717 1718 return successPayload, localVarHttpResponse, err 1719 } 1720 1721 /* LogicalSwitchingApiService Get the realized state associated with provided logical switch id 1722 Returns current state of the logical switch configuration and details of only out-of-sync transport nodes. 1723 * @param ctx context.Context Authentication Context 1724 @param lswitchId 1725 @return manager.LogicalSwitchState*/ 1726 func (a *LogicalSwitchingApiService) GetLogicalSwitchState(ctx context.Context, lswitchId string) (manager.LogicalSwitchState, *http.Response, error) { 1727 var ( 1728 localVarHttpMethod = strings.ToUpper("Get") 1729 localVarPostBody interface{} 1730 localVarFileName string 1731 localVarFileBytes []byte 1732 successPayload manager.LogicalSwitchState 1733 ) 1734 1735 // create path and map variables 1736 localVarPath := a.client.cfg.BasePath + "/logical-switches/{lswitch-id}/state" 1737 localVarPath = strings.Replace(localVarPath, "{"+"lswitch-id"+"}", fmt.Sprintf("%v", lswitchId), -1) 1738 1739 localVarHeaderParams := make(map[string]string) 1740 localVarQueryParams := url.Values{} 1741 localVarFormParams := url.Values{} 1742 1743 // to determine the Content-Type header 1744 localVarHttpContentTypes := []string{"application/json"} 1745 1746 // set Content-Type header 1747 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 1748 if localVarHttpContentType != "" { 1749 localVarHeaderParams["Content-Type"] = localVarHttpContentType 1750 } 1751 1752 // to determine the Accept header 1753 localVarHttpHeaderAccepts := []string{ 1754 "application/json", 1755 } 1756 1757 // set Accept header 1758 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 1759 if localVarHttpHeaderAccept != "" { 1760 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 1761 } 1762 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 1763 if err != nil { 1764 return successPayload, nil, err 1765 } 1766 1767 localVarHttpResponse, err := a.client.callAPI(r) 1768 if err != nil || localVarHttpResponse == nil { 1769 return successPayload, localVarHttpResponse, err 1770 } 1771 defer localVarHttpResponse.Body.Close() 1772 if localVarHttpResponse.StatusCode >= 300 { 1773 return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status) 1774 } 1775 1776 if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil { 1777 return successPayload, localVarHttpResponse, err 1778 } 1779 1780 return successPayload, localVarHttpResponse, err 1781 } 1782 1783 /* LogicalSwitchingApiService Get Statistics for Logical Switch of the Given ID (lswitch-id) 1784 Returns statistics of a specified logical switch. The query parameter \"source=realtime\" is not supported. 1785 * @param ctx context.Context Authentication Context 1786 @param lswitchId 1787 @param optional (nil or map[string]interface{}) with one or more of: 1788 @param "source" (string) Data source type. 1789 @return manager.LogicalSwitchStatistics*/ 1790 func (a *LogicalSwitchingApiService) GetLogicalSwitchStatistics(ctx context.Context, lswitchId string, localVarOptionals map[string]interface{}) (manager.LogicalSwitchStatistics, *http.Response, error) { 1791 var ( 1792 localVarHttpMethod = strings.ToUpper("Get") 1793 localVarPostBody interface{} 1794 localVarFileName string 1795 localVarFileBytes []byte 1796 successPayload manager.LogicalSwitchStatistics 1797 ) 1798 1799 // create path and map variables 1800 localVarPath := a.client.cfg.BasePath + "/logical-switches/{lswitch-id}/statistics" 1801 localVarPath = strings.Replace(localVarPath, "{"+"lswitch-id"+"}", fmt.Sprintf("%v", lswitchId), -1) 1802 1803 localVarHeaderParams := make(map[string]string) 1804 localVarQueryParams := url.Values{} 1805 localVarFormParams := url.Values{} 1806 1807 if err := typeCheckParameter(localVarOptionals["source"], "string", "source"); err != nil { 1808 return successPayload, nil, err 1809 } 1810 1811 if localVarTempParam, localVarOk := localVarOptionals["source"].(string); localVarOk { 1812 localVarQueryParams.Add("source", parameterToString(localVarTempParam, "")) 1813 } 1814 // to determine the Content-Type header 1815 localVarHttpContentTypes := []string{"application/json"} 1816 1817 // set Content-Type header 1818 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 1819 if localVarHttpContentType != "" { 1820 localVarHeaderParams["Content-Type"] = localVarHttpContentType 1821 } 1822 1823 // to determine the Accept header 1824 localVarHttpHeaderAccepts := []string{ 1825 "application/json", 1826 } 1827 1828 // set Accept header 1829 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 1830 if localVarHttpHeaderAccept != "" { 1831 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 1832 } 1833 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 1834 if err != nil { 1835 return successPayload, nil, err 1836 } 1837 1838 localVarHttpResponse, err := a.client.callAPI(r) 1839 if err != nil || localVarHttpResponse == nil { 1840 return successPayload, localVarHttpResponse, err 1841 } 1842 defer localVarHttpResponse.Body.Close() 1843 if localVarHttpResponse.StatusCode >= 300 { 1844 return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status) 1845 } 1846 1847 if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil { 1848 return successPayload, localVarHttpResponse, err 1849 } 1850 1851 return successPayload, localVarHttpResponse, err 1852 } 1853 1854 /* LogicalSwitchingApiService Get Logical Switch runtime status info for a given logical switch 1855 Returns the number of ports assigned to a logical switch. 1856 * @param ctx context.Context Authentication Context 1857 @param lswitchId 1858 @return manager.LogicalSwitchStatus*/ 1859 func (a *LogicalSwitchingApiService) GetLogicalSwitchStatus(ctx context.Context, lswitchId string) (manager.LogicalSwitchStatus, *http.Response, error) { 1860 var ( 1861 localVarHttpMethod = strings.ToUpper("Get") 1862 localVarPostBody interface{} 1863 localVarFileName string 1864 localVarFileBytes []byte 1865 successPayload manager.LogicalSwitchStatus 1866 ) 1867 1868 // create path and map variables 1869 localVarPath := a.client.cfg.BasePath + "/logical-switches/{lswitch-id}/summary" 1870 localVarPath = strings.Replace(localVarPath, "{"+"lswitch-id"+"}", fmt.Sprintf("%v", lswitchId), -1) 1871 1872 localVarHeaderParams := make(map[string]string) 1873 localVarQueryParams := url.Values{} 1874 localVarFormParams := url.Values{} 1875 1876 // to determine the Content-Type header 1877 localVarHttpContentTypes := []string{"application/json"} 1878 1879 // set Content-Type header 1880 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 1881 if localVarHttpContentType != "" { 1882 localVarHeaderParams["Content-Type"] = localVarHttpContentType 1883 } 1884 1885 // to determine the Accept header 1886 localVarHttpHeaderAccepts := []string{ 1887 "application/json", 1888 } 1889 1890 // set Accept header 1891 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 1892 if localVarHttpHeaderAccept != "" { 1893 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 1894 } 1895 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 1896 if err != nil { 1897 return successPayload, nil, err 1898 } 1899 1900 localVarHttpResponse, err := a.client.callAPI(r) 1901 if err != nil || localVarHttpResponse == nil { 1902 return successPayload, localVarHttpResponse, err 1903 } 1904 defer localVarHttpResponse.Body.Close() 1905 if localVarHttpResponse.StatusCode >= 300 { 1906 return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status) 1907 } 1908 1909 if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil { 1910 return successPayload, localVarHttpResponse, err 1911 } 1912 1913 return successPayload, localVarHttpResponse, err 1914 } 1915 1916 /* LogicalSwitchingApiService Get Status Summary of All Logical Switches in the System 1917 Returns Operational status of all logical switches. The query parameter \"source=realtime\" is not supported. 1918 * @param ctx context.Context Authentication Context 1919 @param optional (nil or map[string]interface{}) with one or more of: 1920 @param "cursor" (string) Opaque cursor to be used for getting next page of records (supplied by current result page) 1921 @param "diagnostic" (bool) Flag to enable showing of transit logical switch. 1922 @param "includedFields" (string) Comma separated list of fields that should be included to result of query 1923 @param "pageSize" (int64) Maximum number of results to return in this page (server may return fewer) 1924 @param "sortAscending" (bool) 1925 @param "sortBy" (string) Field by which records are sorted 1926 @param "source" (string) Data source type. 1927 @param "switchingProfileId" (string) Switching Profile identifier 1928 @param "transportType" (string) Mode of transport supported in the transport zone for this logical switch 1929 @param "transportZoneId" (string) Transport zone identifier 1930 @return manager.LogicalSwitchStatusSummary*/ 1931 func (a *LogicalSwitchingApiService) GetLogicalSwitchStatusSummary(ctx context.Context, localVarOptionals map[string]interface{}) (manager.LogicalSwitchStatusSummary, *http.Response, error) { 1932 var ( 1933 localVarHttpMethod = strings.ToUpper("Get") 1934 localVarPostBody interface{} 1935 localVarFileName string 1936 localVarFileBytes []byte 1937 successPayload manager.LogicalSwitchStatusSummary 1938 ) 1939 1940 // create path and map variables 1941 localVarPath := a.client.cfg.BasePath + "/logical-switches/status" 1942 1943 localVarHeaderParams := make(map[string]string) 1944 localVarQueryParams := url.Values{} 1945 localVarFormParams := url.Values{} 1946 1947 if err := typeCheckParameter(localVarOptionals["cursor"], "string", "cursor"); err != nil { 1948 return successPayload, nil, err 1949 } 1950 if err := typeCheckParameter(localVarOptionals["diagnostic"], "bool", "diagnostic"); err != nil { 1951 return successPayload, nil, err 1952 } 1953 if err := typeCheckParameter(localVarOptionals["includedFields"], "string", "includedFields"); err != nil { 1954 return successPayload, nil, err 1955 } 1956 if err := typeCheckParameter(localVarOptionals["pageSize"], "int64", "pageSize"); err != nil { 1957 return successPayload, nil, err 1958 } 1959 if err := typeCheckParameter(localVarOptionals["sortAscending"], "bool", "sortAscending"); err != nil { 1960 return successPayload, nil, err 1961 } 1962 if err := typeCheckParameter(localVarOptionals["sortBy"], "string", "sortBy"); err != nil { 1963 return successPayload, nil, err 1964 } 1965 if err := typeCheckParameter(localVarOptionals["source"], "string", "source"); err != nil { 1966 return successPayload, nil, err 1967 } 1968 if err := typeCheckParameter(localVarOptionals["switchingProfileId"], "string", "switchingProfileId"); err != nil { 1969 return successPayload, nil, err 1970 } 1971 if err := typeCheckParameter(localVarOptionals["transportType"], "string", "transportType"); err != nil { 1972 return successPayload, nil, err 1973 } 1974 if err := typeCheckParameter(localVarOptionals["transportZoneId"], "string", "transportZoneId"); err != nil { 1975 return successPayload, nil, err 1976 } 1977 1978 if localVarTempParam, localVarOk := localVarOptionals["cursor"].(string); localVarOk { 1979 localVarQueryParams.Add("cursor", parameterToString(localVarTempParam, "")) 1980 } 1981 if localVarTempParam, localVarOk := localVarOptionals["diagnostic"].(bool); localVarOk { 1982 localVarQueryParams.Add("diagnostic", parameterToString(localVarTempParam, "")) 1983 } 1984 if localVarTempParam, localVarOk := localVarOptionals["includedFields"].(string); localVarOk { 1985 localVarQueryParams.Add("included_fields", parameterToString(localVarTempParam, "")) 1986 } 1987 if localVarTempParam, localVarOk := localVarOptionals["pageSize"].(int64); localVarOk { 1988 localVarQueryParams.Add("page_size", parameterToString(localVarTempParam, "")) 1989 } 1990 if localVarTempParam, localVarOk := localVarOptionals["sortAscending"].(bool); localVarOk { 1991 localVarQueryParams.Add("sort_ascending", parameterToString(localVarTempParam, "")) 1992 } 1993 if localVarTempParam, localVarOk := localVarOptionals["sortBy"].(string); localVarOk { 1994 localVarQueryParams.Add("sort_by", parameterToString(localVarTempParam, "")) 1995 } 1996 if localVarTempParam, localVarOk := localVarOptionals["source"].(string); localVarOk { 1997 localVarQueryParams.Add("source", parameterToString(localVarTempParam, "")) 1998 } 1999 if localVarTempParam, localVarOk := localVarOptionals["switchingProfileId"].(string); localVarOk { 2000 localVarQueryParams.Add("switching_profile_id", parameterToString(localVarTempParam, "")) 2001 } 2002 if localVarTempParam, localVarOk := localVarOptionals["transportType"].(string); localVarOk { 2003 localVarQueryParams.Add("transport_type", parameterToString(localVarTempParam, "")) 2004 } 2005 if localVarTempParam, localVarOk := localVarOptionals["transportZoneId"].(string); localVarOk { 2006 localVarQueryParams.Add("transport_zone_id", parameterToString(localVarTempParam, "")) 2007 } 2008 // to determine the Content-Type header 2009 localVarHttpContentTypes := []string{"application/json"} 2010 2011 // set Content-Type header 2012 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 2013 if localVarHttpContentType != "" { 2014 localVarHeaderParams["Content-Type"] = localVarHttpContentType 2015 } 2016 2017 // to determine the Accept header 2018 localVarHttpHeaderAccepts := []string{ 2019 "application/json", 2020 } 2021 2022 // set Accept header 2023 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 2024 if localVarHttpHeaderAccept != "" { 2025 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 2026 } 2027 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 2028 if err != nil { 2029 return successPayload, nil, err 2030 } 2031 2032 localVarHttpResponse, err := a.client.callAPI(r) 2033 if err != nil || localVarHttpResponse == nil { 2034 return successPayload, localVarHttpResponse, err 2035 } 2036 defer localVarHttpResponse.Body.Close() 2037 if localVarHttpResponse.StatusCode >= 300 { 2038 return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status) 2039 } 2040 2041 if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil { 2042 return successPayload, localVarHttpResponse, err 2043 } 2044 2045 return successPayload, localVarHttpResponse, err 2046 } 2047 2048 /* LogicalSwitchingApiService Get virtual tunnel endpoint table for logical switch of the given ID (lswitch-id) 2049 Returns the virtual tunnel endpoint table of a specified logical switch from the given transport node if a transport node id is given in the query parameter, from the Central Controller Plane otherwise. The query parameter \"source=cached\" is not supported. 2050 * @param ctx context.Context Authentication Context 2051 @param lswitchId 2052 @param optional (nil or map[string]interface{}) with one or more of: 2053 @param "cursor" (string) Opaque cursor to be used for getting next page of records (supplied by current result page) 2054 @param "includedFields" (string) Comma separated list of fields that should be included to result of query 2055 @param "pageSize" (int64) Maximum number of results to return in this page (server may return fewer) 2056 @param "sortAscending" (bool) 2057 @param "sortBy" (string) Field by which records are sorted 2058 @param "source" (string) Data source type. 2059 @param "transportNodeId" (string) TransportNode Id 2060 @return manager.VtepListResult*/ 2061 func (a *LogicalSwitchingApiService) GetLogicalSwitchVtepTable(ctx context.Context, lswitchId string, localVarOptionals map[string]interface{}) (manager.VtepListResult, *http.Response, error) { 2062 var ( 2063 localVarHttpMethod = strings.ToUpper("Get") 2064 localVarPostBody interface{} 2065 localVarFileName string 2066 localVarFileBytes []byte 2067 successPayload manager.VtepListResult 2068 ) 2069 2070 // create path and map variables 2071 localVarPath := a.client.cfg.BasePath + "/logical-switches/{lswitch-id}/vtep-table" 2072 localVarPath = strings.Replace(localVarPath, "{"+"lswitch-id"+"}", fmt.Sprintf("%v", lswitchId), -1) 2073 2074 localVarHeaderParams := make(map[string]string) 2075 localVarQueryParams := url.Values{} 2076 localVarFormParams := url.Values{} 2077 2078 if err := typeCheckParameter(localVarOptionals["cursor"], "string", "cursor"); err != nil { 2079 return successPayload, nil, err 2080 } 2081 if err := typeCheckParameter(localVarOptionals["includedFields"], "string", "includedFields"); err != nil { 2082 return successPayload, nil, err 2083 } 2084 if err := typeCheckParameter(localVarOptionals["pageSize"], "int64", "pageSize"); err != nil { 2085 return successPayload, nil, err 2086 } 2087 if err := typeCheckParameter(localVarOptionals["sortAscending"], "bool", "sortAscending"); err != nil { 2088 return successPayload, nil, err 2089 } 2090 if err := typeCheckParameter(localVarOptionals["sortBy"], "string", "sortBy"); err != nil { 2091 return successPayload, nil, err 2092 } 2093 if err := typeCheckParameter(localVarOptionals["source"], "string", "source"); err != nil { 2094 return successPayload, nil, err 2095 } 2096 if err := typeCheckParameter(localVarOptionals["transportNodeId"], "string", "transportNodeId"); err != nil { 2097 return successPayload, nil, err 2098 } 2099 2100 if localVarTempParam, localVarOk := localVarOptionals["cursor"].(string); localVarOk { 2101 localVarQueryParams.Add("cursor", parameterToString(localVarTempParam, "")) 2102 } 2103 if localVarTempParam, localVarOk := localVarOptionals["includedFields"].(string); localVarOk { 2104 localVarQueryParams.Add("included_fields", parameterToString(localVarTempParam, "")) 2105 } 2106 if localVarTempParam, localVarOk := localVarOptionals["pageSize"].(int64); localVarOk { 2107 localVarQueryParams.Add("page_size", parameterToString(localVarTempParam, "")) 2108 } 2109 if localVarTempParam, localVarOk := localVarOptionals["sortAscending"].(bool); localVarOk { 2110 localVarQueryParams.Add("sort_ascending", parameterToString(localVarTempParam, "")) 2111 } 2112 if localVarTempParam, localVarOk := localVarOptionals["sortBy"].(string); localVarOk { 2113 localVarQueryParams.Add("sort_by", parameterToString(localVarTempParam, "")) 2114 } 2115 if localVarTempParam, localVarOk := localVarOptionals["source"].(string); localVarOk { 2116 localVarQueryParams.Add("source", parameterToString(localVarTempParam, "")) 2117 } 2118 if localVarTempParam, localVarOk := localVarOptionals["transportNodeId"].(string); localVarOk { 2119 localVarQueryParams.Add("transport_node_id", parameterToString(localVarTempParam, "")) 2120 } 2121 // to determine the Content-Type header 2122 localVarHttpContentTypes := []string{"application/json"} 2123 2124 // set Content-Type header 2125 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 2126 if localVarHttpContentType != "" { 2127 localVarHeaderParams["Content-Type"] = localVarHttpContentType 2128 } 2129 2130 // to determine the Accept header 2131 localVarHttpHeaderAccepts := []string{ 2132 "application/json", 2133 } 2134 2135 // set Accept header 2136 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 2137 if localVarHttpHeaderAccept != "" { 2138 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 2139 } 2140 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 2141 if err != nil { 2142 return successPayload, nil, err 2143 } 2144 2145 localVarHttpResponse, err := a.client.callAPI(r) 2146 if err != nil || localVarHttpResponse == nil { 2147 return successPayload, localVarHttpResponse, err 2148 } 2149 defer localVarHttpResponse.Body.Close() 2150 if localVarHttpResponse.StatusCode >= 300 { 2151 return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status) 2152 } 2153 2154 if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil { 2155 return successPayload, localVarHttpResponse, err 2156 } 2157 2158 return successPayload, localVarHttpResponse, err 2159 } 2160 2161 /* LogicalSwitchingApiService Get virtual tunnel endpoint table for logical switch of the given ID (lswitch-id) 2162 Returns virtual tunnel endpoint table of a specified logical switch in CSV format from the given transport node if a transport node id is given in the query parameter, from the Central Controller Plane otherwise. The query parameter \"source=cached\" is not supported. 2163 * @param ctx context.Context Authentication Context 2164 @param lswitchId 2165 @param optional (nil or map[string]interface{}) with one or more of: 2166 @param "source" (string) Data source type. 2167 @param "transportNodeId" (string) TransportNode Id 2168 @return manager.VtepCsvListResult*/ 2169 func (a *LogicalSwitchingApiService) GetLogicalSwitchVtepTableInCsvFormatCsv(ctx context.Context, lswitchId string, localVarOptionals map[string]interface{}) (manager.VtepCsvListResult, *http.Response, error) { 2170 var ( 2171 localVarHttpMethod = strings.ToUpper("Get") 2172 localVarPostBody interface{} 2173 localVarFileName string 2174 localVarFileBytes []byte 2175 successPayload manager.VtepCsvListResult 2176 ) 2177 2178 // create path and map variables 2179 localVarPath := a.client.cfg.BasePath + "/logical-switches/{lswitch-id}/vtep-table?format=csv" 2180 localVarPath = strings.Replace(localVarPath, "{"+"lswitch-id"+"}", fmt.Sprintf("%v", lswitchId), -1) 2181 2182 localVarHeaderParams := make(map[string]string) 2183 localVarQueryParams := url.Values{} 2184 localVarFormParams := url.Values{} 2185 2186 if err := typeCheckParameter(localVarOptionals["source"], "string", "source"); err != nil { 2187 return successPayload, nil, err 2188 } 2189 if err := typeCheckParameter(localVarOptionals["transportNodeId"], "string", "transportNodeId"); err != nil { 2190 return successPayload, nil, err 2191 } 2192 2193 if localVarTempParam, localVarOk := localVarOptionals["source"].(string); localVarOk { 2194 localVarQueryParams.Add("source", parameterToString(localVarTempParam, "")) 2195 } 2196 if localVarTempParam, localVarOk := localVarOptionals["transportNodeId"].(string); localVarOk { 2197 localVarQueryParams.Add("transport_node_id", parameterToString(localVarTempParam, "")) 2198 } 2199 // to determine the Content-Type header 2200 localVarHttpContentTypes := []string{"application/json"} 2201 2202 // set Content-Type header 2203 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 2204 if localVarHttpContentType != "" { 2205 localVarHeaderParams["Content-Type"] = localVarHttpContentType 2206 } 2207 2208 // to determine the Accept header 2209 localVarHttpHeaderAccepts := []string{ 2210 "text/csv", 2211 } 2212 2213 // set Accept header 2214 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 2215 if localVarHttpHeaderAccept != "" { 2216 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 2217 } 2218 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 2219 if err != nil { 2220 return successPayload, nil, err 2221 } 2222 2223 localVarHttpResponse, err := a.client.callAPI(r) 2224 if err != nil || localVarHttpResponse == nil { 2225 return successPayload, localVarHttpResponse, err 2226 } 2227 defer localVarHttpResponse.Body.Close() 2228 if localVarHttpResponse.StatusCode >= 300 { 2229 return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status) 2230 } 2231 2232 if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil { 2233 return successPayload, localVarHttpResponse, err 2234 } 2235 2236 return successPayload, localVarHttpResponse, err 2237 } 2238 2239 /* LogicalSwitchingApiService Get Switching Profile by ID 2240 Returns information about a specified switching profile. 2241 * @param ctx context.Context Authentication Context 2242 @param switchingProfileId 2243 @return manager.BaseSwitchingProfile*/ 2244 func (a *LogicalSwitchingApiService) GetSwitchingProfile(ctx context.Context, switchingProfileId string) (manager.BaseSwitchingProfile, *http.Response, error) { 2245 var ( 2246 localVarHttpMethod = strings.ToUpper("Get") 2247 localVarPostBody interface{} 2248 localVarFileName string 2249 localVarFileBytes []byte 2250 successPayload manager.BaseSwitchingProfile 2251 ) 2252 2253 // create path and map variables 2254 localVarPath := a.client.cfg.BasePath + "/switching-profiles/{switching-profile-id}" 2255 localVarPath = strings.Replace(localVarPath, "{"+"switching-profile-id"+"}", fmt.Sprintf("%v", switchingProfileId), -1) 2256 2257 localVarHeaderParams := make(map[string]string) 2258 localVarQueryParams := url.Values{} 2259 localVarFormParams := url.Values{} 2260 2261 // to determine the Content-Type header 2262 localVarHttpContentTypes := []string{"application/json"} 2263 2264 // set Content-Type header 2265 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 2266 if localVarHttpContentType != "" { 2267 localVarHeaderParams["Content-Type"] = localVarHttpContentType 2268 } 2269 2270 // to determine the Accept header 2271 localVarHttpHeaderAccepts := []string{ 2272 "application/json", 2273 } 2274 2275 // set Accept header 2276 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 2277 if localVarHttpHeaderAccept != "" { 2278 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 2279 } 2280 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 2281 if err != nil { 2282 return successPayload, nil, err 2283 } 2284 2285 localVarHttpResponse, err := a.client.callAPI(r) 2286 if err != nil || localVarHttpResponse == nil { 2287 return successPayload, localVarHttpResponse, err 2288 } 2289 defer localVarHttpResponse.Body.Close() 2290 if localVarHttpResponse.StatusCode >= 300 { 2291 return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status) 2292 } 2293 2294 if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil { 2295 return successPayload, localVarHttpResponse, err 2296 } 2297 2298 return successPayload, localVarHttpResponse, err 2299 } 2300 2301 /* LogicalSwitchingApiService Get Switching Profile by ID 2302 Returns information about a specified switching profile. 2303 * @param ctx context.Context Authentication Context 2304 @param switchingProfileId 2305 @return manager.SwitchSecuritySwitchingProfile*/ 2306 func (a *LogicalSwitchingApiService) GetSwitchSecuritySwitchingProfile(ctx context.Context, switchingProfileId string) (manager.SwitchSecuritySwitchingProfile, *http.Response, error) { 2307 var ( 2308 localVarHttpMethod = strings.ToUpper("Get") 2309 localVarPostBody interface{} 2310 localVarFileName string 2311 localVarFileBytes []byte 2312 successPayload manager.SwitchSecuritySwitchingProfile 2313 ) 2314 2315 // create path and map variables 2316 localVarPath := a.client.cfg.BasePath + "/switching-profiles/{switching-profile-id}" 2317 localVarPath = strings.Replace(localVarPath, "{"+"switching-profile-id"+"}", fmt.Sprintf("%v", switchingProfileId), -1) 2318 2319 localVarHeaderParams := make(map[string]string) 2320 localVarQueryParams := url.Values{} 2321 localVarFormParams := url.Values{} 2322 2323 // to determine the Content-Type header 2324 localVarHttpContentTypes := []string{"application/json"} 2325 2326 // set Content-Type header 2327 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 2328 if localVarHttpContentType != "" { 2329 localVarHeaderParams["Content-Type"] = localVarHttpContentType 2330 } 2331 2332 // to determine the Accept header 2333 localVarHttpHeaderAccepts := []string{ 2334 "application/json", 2335 } 2336 2337 // set Accept header 2338 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 2339 if localVarHttpHeaderAccept != "" { 2340 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 2341 } 2342 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 2343 if err != nil { 2344 return successPayload, nil, err 2345 } 2346 2347 localVarHttpResponse, err := a.client.callAPI(r) 2348 if err != nil || localVarHttpResponse == nil { 2349 return successPayload, localVarHttpResponse, err 2350 } 2351 defer localVarHttpResponse.Body.Close() 2352 if localVarHttpResponse.StatusCode >= 300 { 2353 return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status) 2354 } 2355 2356 if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil { 2357 return successPayload, localVarHttpResponse, err 2358 } 2359 2360 return successPayload, localVarHttpResponse, err 2361 } 2362 2363 /* LogicalSwitchingApiService Get Switching Profile by ID 2364 Returns information about a specified switching profile. 2365 * @param ctx context.Context Authentication Context 2366 @param switchingProfileId 2367 @return manager.MacManagementSwitchingProfile*/ 2368 func (a *LogicalSwitchingApiService) GetMacManagementSwitchingProfile(ctx context.Context, switchingProfileId string) (manager.MacManagementSwitchingProfile, *http.Response, error) { 2369 var ( 2370 localVarHttpMethod = strings.ToUpper("Get") 2371 localVarPostBody interface{} 2372 localVarFileName string 2373 localVarFileBytes []byte 2374 successPayload manager.MacManagementSwitchingProfile 2375 ) 2376 2377 // create path and map variables 2378 localVarPath := a.client.cfg.BasePath + "/switching-profiles/{switching-profile-id}" 2379 localVarPath = strings.Replace(localVarPath, "{"+"switching-profile-id"+"}", fmt.Sprintf("%v", switchingProfileId), -1) 2380 2381 localVarHeaderParams := make(map[string]string) 2382 localVarQueryParams := url.Values{} 2383 localVarFormParams := url.Values{} 2384 2385 // to determine the Content-Type header 2386 localVarHttpContentTypes := []string{"application/json"} 2387 2388 // set Content-Type header 2389 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 2390 if localVarHttpContentType != "" { 2391 localVarHeaderParams["Content-Type"] = localVarHttpContentType 2392 } 2393 2394 // to determine the Accept header 2395 localVarHttpHeaderAccepts := []string{ 2396 "application/json", 2397 } 2398 2399 // set Accept header 2400 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 2401 if localVarHttpHeaderAccept != "" { 2402 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 2403 } 2404 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 2405 if err != nil { 2406 return successPayload, nil, err 2407 } 2408 2409 localVarHttpResponse, err := a.client.callAPI(r) 2410 if err != nil || localVarHttpResponse == nil { 2411 return successPayload, localVarHttpResponse, err 2412 } 2413 defer localVarHttpResponse.Body.Close() 2414 if localVarHttpResponse.StatusCode >= 300 { 2415 return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status) 2416 } 2417 2418 if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil { 2419 return successPayload, localVarHttpResponse, err 2420 } 2421 2422 return successPayload, localVarHttpResponse, err 2423 } 2424 2425 /* LogicalSwitchingApiService Get Switching Profile by ID 2426 Returns information about a specified switching profile. 2427 * @param ctx context.Context Authentication Context 2428 @param switchingProfileId 2429 @return manager.IpDiscoverySwitchingProfile*/ 2430 func (a *LogicalSwitchingApiService) GetIpDiscoverySwitchingProfile(ctx context.Context, switchingProfileId string) (manager.IpDiscoverySwitchingProfile, *http.Response, error) { 2431 var ( 2432 localVarHttpMethod = strings.ToUpper("Get") 2433 localVarPostBody interface{} 2434 localVarFileName string 2435 localVarFileBytes []byte 2436 successPayload manager.IpDiscoverySwitchingProfile 2437 ) 2438 2439 // create path and map variables 2440 localVarPath := a.client.cfg.BasePath + "/switching-profiles/{switching-profile-id}" 2441 localVarPath = strings.Replace(localVarPath, "{"+"switching-profile-id"+"}", fmt.Sprintf("%v", switchingProfileId), -1) 2442 2443 localVarHeaderParams := make(map[string]string) 2444 localVarQueryParams := url.Values{} 2445 localVarFormParams := url.Values{} 2446 2447 // to determine the Content-Type header 2448 localVarHttpContentTypes := []string{"application/json"} 2449 2450 // set Content-Type header 2451 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 2452 if localVarHttpContentType != "" { 2453 localVarHeaderParams["Content-Type"] = localVarHttpContentType 2454 } 2455 2456 // to determine the Accept header 2457 localVarHttpHeaderAccepts := []string{ 2458 "application/json", 2459 } 2460 2461 // set Accept header 2462 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 2463 if localVarHttpHeaderAccept != "" { 2464 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 2465 } 2466 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 2467 if err != nil { 2468 return successPayload, nil, err 2469 } 2470 2471 localVarHttpResponse, err := a.client.callAPI(r) 2472 if err != nil || localVarHttpResponse == nil { 2473 return successPayload, localVarHttpResponse, err 2474 } 2475 defer localVarHttpResponse.Body.Close() 2476 if localVarHttpResponse.StatusCode >= 300 { 2477 return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status) 2478 } 2479 2480 if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil { 2481 return successPayload, localVarHttpResponse, err 2482 } 2483 2484 return successPayload, localVarHttpResponse, err 2485 } 2486 2487 /* LogicalSwitchingApiService Get Switching Profile by ID 2488 Returns information about a specified switching profile. 2489 * @param ctx context.Context Authentication Context 2490 @param switchingProfileId 2491 @return manager.PortMirroringSwitchingProfile*/ 2492 func (a *LogicalSwitchingApiService) GetPortMirroringSwitchingProfile(ctx context.Context, switchingProfileId string) (manager.PortMirroringSwitchingProfile, *http.Response, error) { 2493 var ( 2494 localVarHttpMethod = strings.ToUpper("Get") 2495 localVarPostBody interface{} 2496 localVarFileName string 2497 localVarFileBytes []byte 2498 successPayload manager.PortMirroringSwitchingProfile 2499 ) 2500 2501 // create path and map variables 2502 localVarPath := a.client.cfg.BasePath + "/switching-profiles/{switching-profile-id}" 2503 localVarPath = strings.Replace(localVarPath, "{"+"switching-profile-id"+"}", fmt.Sprintf("%v", switchingProfileId), -1) 2504 2505 localVarHeaderParams := make(map[string]string) 2506 localVarQueryParams := url.Values{} 2507 localVarFormParams := url.Values{} 2508 2509 // to determine the Content-Type header 2510 localVarHttpContentTypes := []string{"application/json"} 2511 2512 // set Content-Type header 2513 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 2514 if localVarHttpContentType != "" { 2515 localVarHeaderParams["Content-Type"] = localVarHttpContentType 2516 } 2517 2518 // to determine the Accept header 2519 localVarHttpHeaderAccepts := []string{ 2520 "application/json", 2521 } 2522 2523 // set Accept header 2524 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 2525 if localVarHttpHeaderAccept != "" { 2526 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 2527 } 2528 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 2529 if err != nil { 2530 return successPayload, nil, err 2531 } 2532 2533 localVarHttpResponse, err := a.client.callAPI(r) 2534 if err != nil || localVarHttpResponse == nil { 2535 return successPayload, localVarHttpResponse, err 2536 } 2537 defer localVarHttpResponse.Body.Close() 2538 if localVarHttpResponse.StatusCode >= 300 { 2539 return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status) 2540 } 2541 2542 if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil { 2543 return successPayload, localVarHttpResponse, err 2544 } 2545 2546 return successPayload, localVarHttpResponse, err 2547 } 2548 2549 /* LogicalSwitchingApiService Get Switching Profile by ID 2550 Returns information about a specified switching profile. 2551 * @param ctx context.Context Authentication Context 2552 @param switchingProfileId 2553 @return manager.SpoofGuardSwitchingProfile*/ 2554 func (a *LogicalSwitchingApiService) GetSpoofGuardSwitchingProfile(ctx context.Context, switchingProfileId string) (manager.SpoofGuardSwitchingProfile, *http.Response, error) { 2555 var ( 2556 localVarHttpMethod = strings.ToUpper("Get") 2557 localVarPostBody interface{} 2558 localVarFileName string 2559 localVarFileBytes []byte 2560 successPayload manager.SpoofGuardSwitchingProfile 2561 ) 2562 2563 // create path and map variables 2564 localVarPath := a.client.cfg.BasePath + "/switching-profiles/{switching-profile-id}" 2565 localVarPath = strings.Replace(localVarPath, "{"+"switching-profile-id"+"}", fmt.Sprintf("%v", switchingProfileId), -1) 2566 2567 localVarHeaderParams := make(map[string]string) 2568 localVarQueryParams := url.Values{} 2569 localVarFormParams := url.Values{} 2570 2571 // to determine the Content-Type header 2572 localVarHttpContentTypes := []string{"application/json"} 2573 2574 // set Content-Type header 2575 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 2576 if localVarHttpContentType != "" { 2577 localVarHeaderParams["Content-Type"] = localVarHttpContentType 2578 } 2579 2580 // to determine the Accept header 2581 localVarHttpHeaderAccepts := []string{ 2582 "application/json", 2583 } 2584 2585 // set Accept header 2586 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 2587 if localVarHttpHeaderAccept != "" { 2588 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 2589 } 2590 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 2591 if err != nil { 2592 return successPayload, nil, err 2593 } 2594 2595 localVarHttpResponse, err := a.client.callAPI(r) 2596 if err != nil || localVarHttpResponse == nil { 2597 return successPayload, localVarHttpResponse, err 2598 } 2599 defer localVarHttpResponse.Body.Close() 2600 if localVarHttpResponse.StatusCode >= 300 { 2601 return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status) 2602 } 2603 2604 if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil { 2605 return successPayload, localVarHttpResponse, err 2606 } 2607 2608 return successPayload, localVarHttpResponse, err 2609 } 2610 2611 /* LogicalSwitchingApiService Get Switching Profile by ID 2612 Returns information about a specified switching profile. 2613 * @param ctx context.Context Authentication Context 2614 @param switchingProfileId 2615 @return manager.QosSwitchingProfile*/ 2616 func (a *LogicalSwitchingApiService) GetQosSwitchingProfile(ctx context.Context, switchingProfileId string) (manager.QosSwitchingProfile, *http.Response, error) { 2617 var ( 2618 localVarHttpMethod = strings.ToUpper("Get") 2619 localVarPostBody interface{} 2620 localVarFileName string 2621 localVarFileBytes []byte 2622 successPayload manager.QosSwitchingProfile 2623 ) 2624 2625 // create path and map variables 2626 localVarPath := a.client.cfg.BasePath + "/switching-profiles/{switching-profile-id}" 2627 localVarPath = strings.Replace(localVarPath, "{"+"switching-profile-id"+"}", fmt.Sprintf("%v", switchingProfileId), -1) 2628 2629 localVarHeaderParams := make(map[string]string) 2630 localVarQueryParams := url.Values{} 2631 localVarFormParams := url.Values{} 2632 2633 // to determine the Content-Type header 2634 localVarHttpContentTypes := []string{"application/json"} 2635 2636 // set Content-Type header 2637 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 2638 if localVarHttpContentType != "" { 2639 localVarHeaderParams["Content-Type"] = localVarHttpContentType 2640 } 2641 2642 // to determine the Accept header 2643 localVarHttpHeaderAccepts := []string{ 2644 "application/json", 2645 } 2646 2647 // set Accept header 2648 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 2649 if localVarHttpHeaderAccept != "" { 2650 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 2651 } 2652 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 2653 if err != nil { 2654 return successPayload, nil, err 2655 } 2656 2657 localVarHttpResponse, err := a.client.callAPI(r) 2658 if err != nil || localVarHttpResponse == nil { 2659 return successPayload, localVarHttpResponse, err 2660 } 2661 defer localVarHttpResponse.Body.Close() 2662 if localVarHttpResponse.StatusCode >= 300 { 2663 return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status) 2664 } 2665 2666 if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil { 2667 return successPayload, localVarHttpResponse, err 2668 } 2669 2670 return successPayload, localVarHttpResponse, err 2671 } 2672 2673 /* LogicalSwitchingApiService Get Counts of Ports and Switches Using This Switching Profile 2674 Get Counts of Ports and Switches Using This Switching Profile 2675 * @param ctx context.Context Authentication Context 2676 @param switchingProfileId 2677 @return manager.SwitchingProfileStatus*/ 2678 func (a *LogicalSwitchingApiService) GetSwitchingProfileStatus(ctx context.Context, switchingProfileId string) (manager.SwitchingProfileStatus, *http.Response, error) { 2679 var ( 2680 localVarHttpMethod = strings.ToUpper("Get") 2681 localVarPostBody interface{} 2682 localVarFileName string 2683 localVarFileBytes []byte 2684 successPayload manager.SwitchingProfileStatus 2685 ) 2686 2687 // create path and map variables 2688 localVarPath := a.client.cfg.BasePath + "/switching-profiles/{switching-profile-id}/summary" 2689 localVarPath = strings.Replace(localVarPath, "{"+"switching-profile-id"+"}", fmt.Sprintf("%v", switchingProfileId), -1) 2690 2691 localVarHeaderParams := make(map[string]string) 2692 localVarQueryParams := url.Values{} 2693 localVarFormParams := url.Values{} 2694 2695 // to determine the Content-Type header 2696 localVarHttpContentTypes := []string{"application/json"} 2697 2698 // set Content-Type header 2699 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 2700 if localVarHttpContentType != "" { 2701 localVarHeaderParams["Content-Type"] = localVarHttpContentType 2702 } 2703 2704 // to determine the Accept header 2705 localVarHttpHeaderAccepts := []string{ 2706 "application/json", 2707 } 2708 2709 // set Accept header 2710 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 2711 if localVarHttpHeaderAccept != "" { 2712 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 2713 } 2714 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 2715 if err != nil { 2716 return successPayload, nil, err 2717 } 2718 2719 localVarHttpResponse, err := a.client.callAPI(r) 2720 if err != nil || localVarHttpResponse == nil { 2721 return successPayload, localVarHttpResponse, err 2722 } 2723 defer localVarHttpResponse.Body.Close() 2724 if localVarHttpResponse.StatusCode >= 300 { 2725 return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status) 2726 } 2727 2728 if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil { 2729 return successPayload, localVarHttpResponse, err 2730 } 2731 2732 return successPayload, localVarHttpResponse, err 2733 } 2734 2735 /* LogicalSwitchingApiService List All Logical Ports 2736 Returns information about all configured logical switch ports. Logical switch ports connect to VM virtual network interface cards (NICs). Each logical port is associated with one logical switch. 2737 * @param ctx context.Context Authentication Context 2738 @param optional (nil or map[string]interface{}) with one or more of: 2739 @param "attachmentId" (string) Logical Port attachment Id 2740 @param "attachmentType" (string) Type of attachment for logical port; for query only. 2741 @param "bridgeClusterId" (string) Bridge Cluster identifier 2742 @param "cursor" (string) Opaque cursor to be used for getting next page of records (supplied by current result page) 2743 @param "diagnostic" (bool) Flag to enable showing of transit logical port. 2744 @param "includedFields" (string) Comma separated list of fields that should be included to result of query 2745 @param "logicalSwitchId" (string) Logical Switch identifier 2746 @param "pageSize" (int64) Maximum number of results to return in this page (server may return fewer) 2747 @param "parentVifId" (string) ID of the VIF of type PARENT 2748 @param "sortAscending" (bool) 2749 @param "sortBy" (string) Field by which records are sorted 2750 @param "switchingProfileId" (string) Network Profile identifier 2751 @param "transportNodeId" (string) Transport node identifier 2752 @param "transportZoneId" (string) Transport zone identifier 2753 @return manager.LogicalPortListResult*/ 2754 func (a *LogicalSwitchingApiService) ListLogicalPorts(ctx context.Context, localVarOptionals map[string]interface{}) (manager.LogicalPortListResult, *http.Response, error) { 2755 var ( 2756 localVarHttpMethod = strings.ToUpper("Get") 2757 localVarPostBody interface{} 2758 localVarFileName string 2759 localVarFileBytes []byte 2760 successPayload manager.LogicalPortListResult 2761 ) 2762 2763 // create path and map variables 2764 localVarPath := a.client.cfg.BasePath + "/logical-ports" 2765 2766 localVarHeaderParams := make(map[string]string) 2767 localVarQueryParams := url.Values{} 2768 localVarFormParams := url.Values{} 2769 2770 if err := typeCheckParameter(localVarOptionals["attachmentId"], "string", "attachmentId"); err != nil { 2771 return successPayload, nil, err 2772 } 2773 if err := typeCheckParameter(localVarOptionals["attachmentType"], "string", "attachmentType"); err != nil { 2774 return successPayload, nil, err 2775 } 2776 if err := typeCheckParameter(localVarOptionals["bridgeClusterId"], "string", "bridgeClusterId"); err != nil { 2777 return successPayload, nil, err 2778 } 2779 if err := typeCheckParameter(localVarOptionals["cursor"], "string", "cursor"); err != nil { 2780 return successPayload, nil, err 2781 } 2782 if err := typeCheckParameter(localVarOptionals["diagnostic"], "bool", "diagnostic"); err != nil { 2783 return successPayload, nil, err 2784 } 2785 if err := typeCheckParameter(localVarOptionals["includedFields"], "string", "includedFields"); err != nil { 2786 return successPayload, nil, err 2787 } 2788 if err := typeCheckParameter(localVarOptionals["logicalSwitchId"], "string", "logicalSwitchId"); err != nil { 2789 return successPayload, nil, err 2790 } 2791 if err := typeCheckParameter(localVarOptionals["pageSize"], "int64", "pageSize"); err != nil { 2792 return successPayload, nil, err 2793 } 2794 if err := typeCheckParameter(localVarOptionals["parentVifId"], "string", "parentVifId"); err != nil { 2795 return successPayload, nil, err 2796 } 2797 if err := typeCheckParameter(localVarOptionals["sortAscending"], "bool", "sortAscending"); err != nil { 2798 return successPayload, nil, err 2799 } 2800 if err := typeCheckParameter(localVarOptionals["sortBy"], "string", "sortBy"); err != nil { 2801 return successPayload, nil, err 2802 } 2803 if err := typeCheckParameter(localVarOptionals["switchingProfileId"], "string", "switchingProfileId"); err != nil { 2804 return successPayload, nil, err 2805 } 2806 if err := typeCheckParameter(localVarOptionals["transportNodeId"], "string", "transportNodeId"); err != nil { 2807 return successPayload, nil, err 2808 } 2809 if err := typeCheckParameter(localVarOptionals["transportZoneId"], "string", "transportZoneId"); err != nil { 2810 return successPayload, nil, err 2811 } 2812 2813 if localVarTempParam, localVarOk := localVarOptionals["attachmentId"].(string); localVarOk { 2814 localVarQueryParams.Add("attachment_id", parameterToString(localVarTempParam, "")) 2815 } 2816 if localVarTempParam, localVarOk := localVarOptionals["attachmentType"].(string); localVarOk { 2817 localVarQueryParams.Add("attachment_type", parameterToString(localVarTempParam, "")) 2818 } 2819 if localVarTempParam, localVarOk := localVarOptionals["bridgeClusterId"].(string); localVarOk { 2820 localVarQueryParams.Add("bridge_cluster_id", parameterToString(localVarTempParam, "")) 2821 } 2822 if localVarTempParam, localVarOk := localVarOptionals["cursor"].(string); localVarOk { 2823 localVarQueryParams.Add("cursor", parameterToString(localVarTempParam, "")) 2824 } 2825 if localVarTempParam, localVarOk := localVarOptionals["diagnostic"].(bool); localVarOk { 2826 localVarQueryParams.Add("diagnostic", parameterToString(localVarTempParam, "")) 2827 } 2828 if localVarTempParam, localVarOk := localVarOptionals["includedFields"].(string); localVarOk { 2829 localVarQueryParams.Add("included_fields", parameterToString(localVarTempParam, "")) 2830 } 2831 if localVarTempParam, localVarOk := localVarOptionals["logicalSwitchId"].(string); localVarOk { 2832 localVarQueryParams.Add("logical_switch_id", parameterToString(localVarTempParam, "")) 2833 } 2834 if localVarTempParam, localVarOk := localVarOptionals["pageSize"].(int64); localVarOk { 2835 localVarQueryParams.Add("page_size", parameterToString(localVarTempParam, "")) 2836 } 2837 if localVarTempParam, localVarOk := localVarOptionals["parentVifId"].(string); localVarOk { 2838 localVarQueryParams.Add("parent_vif_id", parameterToString(localVarTempParam, "")) 2839 } 2840 if localVarTempParam, localVarOk := localVarOptionals["sortAscending"].(bool); localVarOk { 2841 localVarQueryParams.Add("sort_ascending", parameterToString(localVarTempParam, "")) 2842 } 2843 if localVarTempParam, localVarOk := localVarOptionals["sortBy"].(string); localVarOk { 2844 localVarQueryParams.Add("sort_by", parameterToString(localVarTempParam, "")) 2845 } 2846 if localVarTempParam, localVarOk := localVarOptionals["switchingProfileId"].(string); localVarOk { 2847 localVarQueryParams.Add("switching_profile_id", parameterToString(localVarTempParam, "")) 2848 } 2849 if localVarTempParam, localVarOk := localVarOptionals["transportNodeId"].(string); localVarOk { 2850 localVarQueryParams.Add("transport_node_id", parameterToString(localVarTempParam, "")) 2851 } 2852 if localVarTempParam, localVarOk := localVarOptionals["transportZoneId"].(string); localVarOk { 2853 localVarQueryParams.Add("transport_zone_id", parameterToString(localVarTempParam, "")) 2854 } 2855 // to determine the Content-Type header 2856 localVarHttpContentTypes := []string{"application/json"} 2857 2858 // set Content-Type header 2859 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 2860 if localVarHttpContentType != "" { 2861 localVarHeaderParams["Content-Type"] = localVarHttpContentType 2862 } 2863 2864 // to determine the Accept header 2865 localVarHttpHeaderAccepts := []string{ 2866 "application/json", 2867 } 2868 2869 // set Accept header 2870 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 2871 if localVarHttpHeaderAccept != "" { 2872 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 2873 } 2874 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 2875 if err != nil { 2876 return successPayload, nil, err 2877 } 2878 2879 localVarHttpResponse, err := a.client.callAPI(r) 2880 if err != nil || localVarHttpResponse == nil { 2881 return successPayload, localVarHttpResponse, err 2882 } 2883 defer localVarHttpResponse.Body.Close() 2884 if localVarHttpResponse.StatusCode >= 300 { 2885 return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status) 2886 } 2887 2888 if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil { 2889 return successPayload, localVarHttpResponse, err 2890 } 2891 2892 return successPayload, localVarHttpResponse, err 2893 } 2894 2895 /* LogicalSwitchingApiService List all Logical Switches 2896 Returns information about all configured logical switches. 2897 * @param ctx context.Context Authentication Context 2898 @param optional (nil or map[string]interface{}) with one or more of: 2899 @param "cursor" (string) Opaque cursor to be used for getting next page of records (supplied by current result page) 2900 @param "diagnostic" (bool) Flag to enable showing of transit logical switch. 2901 @param "includedFields" (string) Comma separated list of fields that should be included to result of query 2902 @param "pageSize" (int64) Maximum number of results to return in this page (server may return fewer) 2903 @param "sortAscending" (bool) 2904 @param "sortBy" (string) Field by which records are sorted 2905 @param "switchingProfileId" (string) Switching Profile identifier 2906 @param "transportType" (string) Mode of transport supported in the transport zone for this logical switch 2907 @param "transportZoneId" (string) Transport zone identifier 2908 @return manager.LogicalSwitchListResult*/ 2909 func (a *LogicalSwitchingApiService) ListLogicalSwitches(ctx context.Context, localVarOptionals map[string]interface{}) (manager.LogicalSwitchListResult, *http.Response, error) { 2910 var ( 2911 localVarHttpMethod = strings.ToUpper("Get") 2912 localVarPostBody interface{} 2913 localVarFileName string 2914 localVarFileBytes []byte 2915 successPayload manager.LogicalSwitchListResult 2916 ) 2917 2918 // create path and map variables 2919 localVarPath := a.client.cfg.BasePath + "/logical-switches" 2920 2921 localVarHeaderParams := make(map[string]string) 2922 localVarQueryParams := url.Values{} 2923 localVarFormParams := url.Values{} 2924 2925 if err := typeCheckParameter(localVarOptionals["cursor"], "string", "cursor"); err != nil { 2926 return successPayload, nil, err 2927 } 2928 if err := typeCheckParameter(localVarOptionals["diagnostic"], "bool", "diagnostic"); err != nil { 2929 return successPayload, nil, err 2930 } 2931 if err := typeCheckParameter(localVarOptionals["includedFields"], "string", "includedFields"); err != nil { 2932 return successPayload, nil, err 2933 } 2934 if err := typeCheckParameter(localVarOptionals["pageSize"], "int64", "pageSize"); err != nil { 2935 return successPayload, nil, err 2936 } 2937 if err := typeCheckParameter(localVarOptionals["sortAscending"], "bool", "sortAscending"); err != nil { 2938 return successPayload, nil, err 2939 } 2940 if err := typeCheckParameter(localVarOptionals["sortBy"], "string", "sortBy"); err != nil { 2941 return successPayload, nil, err 2942 } 2943 if err := typeCheckParameter(localVarOptionals["switchingProfileId"], "string", "switchingProfileId"); err != nil { 2944 return successPayload, nil, err 2945 } 2946 if err := typeCheckParameter(localVarOptionals["transportType"], "string", "transportType"); err != nil { 2947 return successPayload, nil, err 2948 } 2949 if err := typeCheckParameter(localVarOptionals["transportZoneId"], "string", "transportZoneId"); err != nil { 2950 return successPayload, nil, err 2951 } 2952 2953 if localVarTempParam, localVarOk := localVarOptionals["cursor"].(string); localVarOk { 2954 localVarQueryParams.Add("cursor", parameterToString(localVarTempParam, "")) 2955 } 2956 if localVarTempParam, localVarOk := localVarOptionals["diagnostic"].(bool); localVarOk { 2957 localVarQueryParams.Add("diagnostic", parameterToString(localVarTempParam, "")) 2958 } 2959 if localVarTempParam, localVarOk := localVarOptionals["includedFields"].(string); localVarOk { 2960 localVarQueryParams.Add("included_fields", parameterToString(localVarTempParam, "")) 2961 } 2962 if localVarTempParam, localVarOk := localVarOptionals["pageSize"].(int64); localVarOk { 2963 localVarQueryParams.Add("page_size", parameterToString(localVarTempParam, "")) 2964 } 2965 if localVarTempParam, localVarOk := localVarOptionals["sortAscending"].(bool); localVarOk { 2966 localVarQueryParams.Add("sort_ascending", parameterToString(localVarTempParam, "")) 2967 } 2968 if localVarTempParam, localVarOk := localVarOptionals["sortBy"].(string); localVarOk { 2969 localVarQueryParams.Add("sort_by", parameterToString(localVarTempParam, "")) 2970 } 2971 if localVarTempParam, localVarOk := localVarOptionals["switchingProfileId"].(string); localVarOk { 2972 localVarQueryParams.Add("switching_profile_id", parameterToString(localVarTempParam, "")) 2973 } 2974 if localVarTempParam, localVarOk := localVarOptionals["transportType"].(string); localVarOk { 2975 localVarQueryParams.Add("transport_type", parameterToString(localVarTempParam, "")) 2976 } 2977 if localVarTempParam, localVarOk := localVarOptionals["transportZoneId"].(string); localVarOk { 2978 localVarQueryParams.Add("transport_zone_id", parameterToString(localVarTempParam, "")) 2979 } 2980 // to determine the Content-Type header 2981 localVarHttpContentTypes := []string{"application/json"} 2982 2983 // set Content-Type header 2984 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 2985 if localVarHttpContentType != "" { 2986 localVarHeaderParams["Content-Type"] = localVarHttpContentType 2987 } 2988 2989 // to determine the Accept header 2990 localVarHttpHeaderAccepts := []string{ 2991 "application/json", 2992 } 2993 2994 // set Accept header 2995 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 2996 if localVarHttpHeaderAccept != "" { 2997 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 2998 } 2999 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 3000 if err != nil { 3001 return successPayload, nil, err 3002 } 3003 3004 localVarHttpResponse, err := a.client.callAPI(r) 3005 if err != nil || localVarHttpResponse == nil { 3006 return successPayload, localVarHttpResponse, err 3007 } 3008 defer localVarHttpResponse.Body.Close() 3009 if localVarHttpResponse.StatusCode >= 300 { 3010 return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status) 3011 } 3012 3013 if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil { 3014 return successPayload, localVarHttpResponse, err 3015 } 3016 3017 return successPayload, localVarHttpResponse, err 3018 } 3019 3020 /* LogicalSwitchingApiService List logical switches by realized state 3021 Returns a list of logical switches states that have realized state as provided as query parameter. 3022 * @param ctx context.Context Authentication Context 3023 @param optional (nil or map[string]interface{}) with one or more of: 3024 @param "status" (string) Realized state of logical switches 3025 @return manager.LogicalSwitchStateListResult*/ 3026 func (a *LogicalSwitchingApiService) ListLogicalSwitchesByState(ctx context.Context, localVarOptionals map[string]interface{}) (manager.LogicalSwitchStateListResult, *http.Response, error) { 3027 var ( 3028 localVarHttpMethod = strings.ToUpper("Get") 3029 localVarPostBody interface{} 3030 localVarFileName string 3031 localVarFileBytes []byte 3032 successPayload manager.LogicalSwitchStateListResult 3033 ) 3034 3035 // create path and map variables 3036 localVarPath := a.client.cfg.BasePath + "/logical-switches/state" 3037 3038 localVarHeaderParams := make(map[string]string) 3039 localVarQueryParams := url.Values{} 3040 localVarFormParams := url.Values{} 3041 3042 if err := typeCheckParameter(localVarOptionals["status"], "string", "status"); err != nil { 3043 return successPayload, nil, err 3044 } 3045 3046 if localVarTempParam, localVarOk := localVarOptionals["status"].(string); localVarOk { 3047 localVarQueryParams.Add("status", parameterToString(localVarTempParam, "")) 3048 } 3049 // to determine the Content-Type header 3050 localVarHttpContentTypes := []string{"application/json"} 3051 3052 // set Content-Type header 3053 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 3054 if localVarHttpContentType != "" { 3055 localVarHeaderParams["Content-Type"] = localVarHttpContentType 3056 } 3057 3058 // to determine the Accept header 3059 localVarHttpHeaderAccepts := []string{ 3060 "application/json", 3061 } 3062 3063 // set Accept header 3064 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 3065 if localVarHttpHeaderAccept != "" { 3066 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 3067 } 3068 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 3069 if err != nil { 3070 return successPayload, nil, err 3071 } 3072 3073 localVarHttpResponse, err := a.client.callAPI(r) 3074 if err != nil || localVarHttpResponse == nil { 3075 return successPayload, localVarHttpResponse, err 3076 } 3077 defer localVarHttpResponse.Body.Close() 3078 if localVarHttpResponse.StatusCode >= 300 { 3079 return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status) 3080 } 3081 3082 if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil { 3083 return successPayload, localVarHttpResponse, err 3084 } 3085 3086 return successPayload, localVarHttpResponse, err 3087 } 3088 3089 /* LogicalSwitchingApiService List Switching Profiles 3090 Returns information about the system-default and user-configured switching profiles. Each switching profile has a unique ID, a display name, and various other read-only and configurable properties. The default switching profiles are assigned automatically to each switch. 3091 * @param ctx context.Context Authentication Context 3092 @param optional (nil or map[string]interface{}) with one or more of: 3093 @param "cursor" (string) Opaque cursor to be used for getting next page of records (supplied by current result page) 3094 @param "includeSystemOwned" (bool) Whether the list result contains system resources 3095 @param "includedFields" (string) Comma separated list of fields that should be included to result of query 3096 @param "pageSize" (int64) Maximum number of results to return in this page (server may return fewer) 3097 @param "sortAscending" (bool) 3098 @param "sortBy" (string) Field by which records are sorted 3099 @param "switchingProfileType" (string) comma-separated list of switching profile types, e.g. ?switching_profile_type=QosSwitchingProfile,PortMirroringSwitchingProfile 3100 @return manager.SwitchingProfilesListResult*/ 3101 func (a *LogicalSwitchingApiService) ListSwitchingProfiles(ctx context.Context, localVarOptionals map[string]interface{}) (manager.SwitchingProfilesListResult, *http.Response, error) { 3102 var ( 3103 localVarHttpMethod = strings.ToUpper("Get") 3104 localVarPostBody interface{} 3105 localVarFileName string 3106 localVarFileBytes []byte 3107 successPayload manager.SwitchingProfilesListResult 3108 ) 3109 3110 // create path and map variables 3111 localVarPath := a.client.cfg.BasePath + "/switching-profiles" 3112 3113 localVarHeaderParams := make(map[string]string) 3114 localVarQueryParams := url.Values{} 3115 localVarFormParams := url.Values{} 3116 3117 if err := typeCheckParameter(localVarOptionals["cursor"], "string", "cursor"); err != nil { 3118 return successPayload, nil, err 3119 } 3120 if err := typeCheckParameter(localVarOptionals["includeSystemOwned"], "bool", "includeSystemOwned"); err != nil { 3121 return successPayload, nil, err 3122 } 3123 if err := typeCheckParameter(localVarOptionals["includedFields"], "string", "includedFields"); err != nil { 3124 return successPayload, nil, err 3125 } 3126 if err := typeCheckParameter(localVarOptionals["pageSize"], "int64", "pageSize"); err != nil { 3127 return successPayload, nil, err 3128 } 3129 if err := typeCheckParameter(localVarOptionals["sortAscending"], "bool", "sortAscending"); err != nil { 3130 return successPayload, nil, err 3131 } 3132 if err := typeCheckParameter(localVarOptionals["sortBy"], "string", "sortBy"); err != nil { 3133 return successPayload, nil, err 3134 } 3135 if err := typeCheckParameter(localVarOptionals["switchingProfileType"], "string", "switchingProfileType"); err != nil { 3136 return successPayload, nil, err 3137 } 3138 3139 if localVarTempParam, localVarOk := localVarOptionals["cursor"].(string); localVarOk { 3140 localVarQueryParams.Add("cursor", parameterToString(localVarTempParam, "")) 3141 } 3142 if localVarTempParam, localVarOk := localVarOptionals["includeSystemOwned"].(bool); localVarOk { 3143 localVarQueryParams.Add("include_system_owned", parameterToString(localVarTempParam, "")) 3144 } 3145 if localVarTempParam, localVarOk := localVarOptionals["includedFields"].(string); localVarOk { 3146 localVarQueryParams.Add("included_fields", parameterToString(localVarTempParam, "")) 3147 } 3148 if localVarTempParam, localVarOk := localVarOptionals["pageSize"].(int64); localVarOk { 3149 localVarQueryParams.Add("page_size", parameterToString(localVarTempParam, "")) 3150 } 3151 if localVarTempParam, localVarOk := localVarOptionals["sortAscending"].(bool); localVarOk { 3152 localVarQueryParams.Add("sort_ascending", parameterToString(localVarTempParam, "")) 3153 } 3154 if localVarTempParam, localVarOk := localVarOptionals["sortBy"].(string); localVarOk { 3155 localVarQueryParams.Add("sort_by", parameterToString(localVarTempParam, "")) 3156 } 3157 if localVarTempParam, localVarOk := localVarOptionals["switchingProfileType"].(string); localVarOk { 3158 localVarQueryParams.Add("switching_profile_type", parameterToString(localVarTempParam, "")) 3159 } 3160 // to determine the Content-Type header 3161 localVarHttpContentTypes := []string{"application/json"} 3162 3163 // set Content-Type header 3164 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 3165 if localVarHttpContentType != "" { 3166 localVarHeaderParams["Content-Type"] = localVarHttpContentType 3167 } 3168 3169 // to determine the Accept header 3170 localVarHttpHeaderAccepts := []string{ 3171 "application/json", 3172 } 3173 3174 // set Accept header 3175 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 3176 if localVarHttpHeaderAccept != "" { 3177 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 3178 } 3179 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 3180 if err != nil { 3181 return successPayload, nil, err 3182 } 3183 3184 localVarHttpResponse, err := a.client.callAPI(r) 3185 if err != nil || localVarHttpResponse == nil { 3186 return successPayload, localVarHttpResponse, err 3187 } 3188 defer localVarHttpResponse.Body.Close() 3189 if localVarHttpResponse.StatusCode >= 300 { 3190 return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status) 3191 } 3192 3193 if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil { 3194 return successPayload, localVarHttpResponse, err 3195 } 3196 3197 return successPayload, localVarHttpResponse, err 3198 } 3199 3200 /* LogicalSwitchingApiService Update a Logical Port 3201 Modifies an existing logical switch port. Parameters that can be modified include attachment_type (LOGICALROUTER, VIF), admin_state (UP or DOWN), attachment id and switching_profile_ids. You cannot modify the logical_switch_id. In other words, you cannot move an existing port from one switch to another switch. 3202 * @param ctx context.Context Authentication Context 3203 @param lportId 3204 @param logicalPort 3205 @return manager.LogicalPort*/ 3206 func (a *LogicalSwitchingApiService) UpdateLogicalPort(ctx context.Context, lportId string, logicalPort manager.LogicalPort) (manager.LogicalPort, *http.Response, error) { 3207 var ( 3208 localVarHttpMethod = strings.ToUpper("Put") 3209 localVarPostBody interface{} 3210 localVarFileName string 3211 localVarFileBytes []byte 3212 successPayload manager.LogicalPort 3213 ) 3214 3215 // create path and map variables 3216 localVarPath := a.client.cfg.BasePath + "/logical-ports/{lport-id}" 3217 localVarPath = strings.Replace(localVarPath, "{"+"lport-id"+"}", fmt.Sprintf("%v", lportId), -1) 3218 3219 localVarHeaderParams := make(map[string]string) 3220 localVarQueryParams := url.Values{} 3221 localVarFormParams := url.Values{} 3222 3223 // to determine the Content-Type header 3224 localVarHttpContentTypes := []string{"application/json"} 3225 3226 // set Content-Type header 3227 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 3228 if localVarHttpContentType != "" { 3229 localVarHeaderParams["Content-Type"] = localVarHttpContentType 3230 } 3231 3232 // to determine the Accept header 3233 localVarHttpHeaderAccepts := []string{ 3234 "application/json", 3235 } 3236 3237 // set Accept header 3238 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 3239 if localVarHttpHeaderAccept != "" { 3240 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 3241 } 3242 // body params 3243 localVarPostBody = &logicalPort 3244 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 3245 if err != nil { 3246 return successPayload, nil, err 3247 } 3248 3249 localVarHttpResponse, err := a.client.callAPI(r) 3250 if err != nil || localVarHttpResponse == nil { 3251 return successPayload, localVarHttpResponse, err 3252 } 3253 defer localVarHttpResponse.Body.Close() 3254 if localVarHttpResponse.StatusCode >= 300 { 3255 return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status) 3256 } 3257 3258 if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil { 3259 return successPayload, localVarHttpResponse, err 3260 } 3261 3262 return successPayload, localVarHttpResponse, err 3263 } 3264 3265 /* LogicalSwitchingApiService Update a Logical Switch 3266 Modifies attributes of an existing logical switch. Modifiable attributes include admin_state, replication_mode, switching_profile_ids and vlan. You cannot modify the original transport_zone_id. 3267 * @param ctx context.Context Authentication Context 3268 @param lswitchId 3269 @param logicalSwitch 3270 @return manager.LogicalSwitch*/ 3271 func (a *LogicalSwitchingApiService) UpdateLogicalSwitch(ctx context.Context, lswitchId string, logicalSwitch manager.LogicalSwitch) (manager.LogicalSwitch, *http.Response, error) { 3272 var ( 3273 localVarHttpMethod = strings.ToUpper("Put") 3274 localVarPostBody interface{} 3275 localVarFileName string 3276 localVarFileBytes []byte 3277 successPayload manager.LogicalSwitch 3278 ) 3279 3280 // create path and map variables 3281 localVarPath := a.client.cfg.BasePath + "/logical-switches/{lswitch-id}" 3282 localVarPath = strings.Replace(localVarPath, "{"+"lswitch-id"+"}", fmt.Sprintf("%v", lswitchId), -1) 3283 3284 localVarHeaderParams := make(map[string]string) 3285 localVarQueryParams := url.Values{} 3286 localVarFormParams := url.Values{} 3287 3288 // to determine the Content-Type header 3289 localVarHttpContentTypes := []string{"application/json"} 3290 3291 // set Content-Type header 3292 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 3293 if localVarHttpContentType != "" { 3294 localVarHeaderParams["Content-Type"] = localVarHttpContentType 3295 } 3296 3297 // to determine the Accept header 3298 localVarHttpHeaderAccepts := []string{ 3299 "application/json", 3300 } 3301 3302 // set Accept header 3303 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 3304 if localVarHttpHeaderAccept != "" { 3305 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 3306 } 3307 // body params 3308 localVarPostBody = &logicalSwitch 3309 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 3310 if err != nil { 3311 return successPayload, nil, err 3312 } 3313 3314 localVarHttpResponse, err := a.client.callAPI(r) 3315 if err != nil || localVarHttpResponse == nil { 3316 return successPayload, localVarHttpResponse, err 3317 } 3318 defer localVarHttpResponse.Body.Close() 3319 if localVarHttpResponse.StatusCode >= 300 { 3320 return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status) 3321 } 3322 3323 if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil { 3324 return successPayload, localVarHttpResponse, err 3325 } 3326 3327 return successPayload, localVarHttpResponse, err 3328 } 3329 3330 /* LogicalSwitchingApiService Update a Switching Profile 3331 Updates the user-configurable parameters of a switching profile. Only the qos, port-mirroring, spoof-guard and port-security switching profiles can be modified. You cannot modify the ipfix or ip-discovery switching profiles. 3332 * @param ctx context.Context Authentication Context 3333 @param switchingProfileId 3334 @param baseSwitchingProfile 3335 @return manager.BaseSwitchingProfile*/ 3336 func (a *LogicalSwitchingApiService) UpdateSwitchingProfile(ctx context.Context, switchingProfileId string, baseSwitchingProfile manager.BaseSwitchingProfile) (manager.BaseSwitchingProfile, *http.Response, error) { 3337 var ( 3338 localVarHttpMethod = strings.ToUpper("Put") 3339 localVarPostBody interface{} 3340 localVarFileName string 3341 localVarFileBytes []byte 3342 successPayload manager.BaseSwitchingProfile 3343 ) 3344 3345 // create path and map variables 3346 localVarPath := a.client.cfg.BasePath + "/switching-profiles/{switching-profile-id}" 3347 localVarPath = strings.Replace(localVarPath, "{"+"switching-profile-id"+"}", fmt.Sprintf("%v", switchingProfileId), -1) 3348 3349 localVarHeaderParams := make(map[string]string) 3350 localVarQueryParams := url.Values{} 3351 localVarFormParams := url.Values{} 3352 3353 // to determine the Content-Type header 3354 localVarHttpContentTypes := []string{"application/json"} 3355 3356 // set Content-Type header 3357 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 3358 if localVarHttpContentType != "" { 3359 localVarHeaderParams["Content-Type"] = localVarHttpContentType 3360 } 3361 3362 // to determine the Accept header 3363 localVarHttpHeaderAccepts := []string{ 3364 "application/json", 3365 } 3366 3367 // set Accept header 3368 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 3369 if localVarHttpHeaderAccept != "" { 3370 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 3371 } 3372 // body params 3373 localVarPostBody = &baseSwitchingProfile 3374 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 3375 if err != nil { 3376 return successPayload, nil, err 3377 } 3378 3379 localVarHttpResponse, err := a.client.callAPI(r) 3380 if err != nil || localVarHttpResponse == nil { 3381 return successPayload, localVarHttpResponse, err 3382 } 3383 defer localVarHttpResponse.Body.Close() 3384 if localVarHttpResponse.StatusCode >= 300 { 3385 return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status) 3386 } 3387 3388 if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil { 3389 return successPayload, localVarHttpResponse, err 3390 } 3391 3392 return successPayload, localVarHttpResponse, err 3393 } 3394 3395 /* LogicalSwitchingApiService Update a Switching Profile 3396 Updates the user-configurable parameters of a switching profile. Only the qos, port-mirroring, spoof-guard and port-security switching profiles can be modified. You cannot modify the ipfix or ip-discovery switching profiles. 3397 * @param ctx context.Context Authentication Context 3398 @param switchingProfileId 3399 @param baseSwitchingProfile 3400 @return manager.SwitchSecuritySwitchingProfile*/ 3401 func (a *LogicalSwitchingApiService) UpdateSwitchSecuritySwitchingProfile(ctx context.Context, switchingProfileId string, baseSwitchingProfile manager.SwitchSecuritySwitchingProfile) (manager.SwitchSecuritySwitchingProfile, *http.Response, error) { 3402 var ( 3403 localVarHttpMethod = strings.ToUpper("Put") 3404 localVarPostBody interface{} 3405 localVarFileName string 3406 localVarFileBytes []byte 3407 successPayload manager.SwitchSecuritySwitchingProfile 3408 ) 3409 3410 baseSwitchingProfile.ResourceType = "SwitchSecuritySwitchingProfile" 3411 3412 // create path and map variables 3413 localVarPath := a.client.cfg.BasePath + "/switching-profiles/{switching-profile-id}" 3414 localVarPath = strings.Replace(localVarPath, "{"+"switching-profile-id"+"}", fmt.Sprintf("%v", switchingProfileId), -1) 3415 3416 localVarHeaderParams := make(map[string]string) 3417 localVarQueryParams := url.Values{} 3418 localVarFormParams := url.Values{} 3419 3420 // to determine the Content-Type header 3421 localVarHttpContentTypes := []string{"application/json"} 3422 3423 // set Content-Type header 3424 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 3425 if localVarHttpContentType != "" { 3426 localVarHeaderParams["Content-Type"] = localVarHttpContentType 3427 } 3428 3429 // to determine the Accept header 3430 localVarHttpHeaderAccepts := []string{ 3431 "application/json", 3432 } 3433 3434 // set Accept header 3435 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 3436 if localVarHttpHeaderAccept != "" { 3437 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 3438 } 3439 // body params 3440 localVarPostBody = &baseSwitchingProfile 3441 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 3442 if err != nil { 3443 return successPayload, nil, err 3444 } 3445 3446 localVarHttpResponse, err := a.client.callAPI(r) 3447 if err != nil || localVarHttpResponse == nil { 3448 return successPayload, localVarHttpResponse, err 3449 } 3450 defer localVarHttpResponse.Body.Close() 3451 if localVarHttpResponse.StatusCode >= 300 { 3452 return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status) 3453 } 3454 3455 if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil { 3456 return successPayload, localVarHttpResponse, err 3457 } 3458 3459 return successPayload, localVarHttpResponse, err 3460 } 3461 3462 /* LogicalSwitchingApiService Update a Switching Profile 3463 Updates the user-configurable parameters of a switching profile. Only the qos, port-mirroring, spoof-guard and port-security switching profiles can be modified. You cannot modify the ipfix or ip-discovery switching profiles. 3464 * @param ctx context.Context Authentication Context 3465 @param switchingProfileId 3466 @param baseSwitchingProfile 3467 @return manager.MacManagementSwitchingProfile*/ 3468 func (a *LogicalSwitchingApiService) UpdateMacManagementSwitchingProfile(ctx context.Context, switchingProfileId string, baseSwitchingProfile manager.MacManagementSwitchingProfile) (manager.MacManagementSwitchingProfile, *http.Response, error) { 3469 var ( 3470 localVarHttpMethod = strings.ToUpper("Put") 3471 localVarPostBody interface{} 3472 localVarFileName string 3473 localVarFileBytes []byte 3474 successPayload manager.MacManagementSwitchingProfile 3475 ) 3476 3477 baseSwitchingProfile.ResourceType = "MacManagementSwitchingProfile" 3478 3479 // create path and map variables 3480 localVarPath := a.client.cfg.BasePath + "/switching-profiles/{switching-profile-id}" 3481 localVarPath = strings.Replace(localVarPath, "{"+"switching-profile-id"+"}", fmt.Sprintf("%v", switchingProfileId), -1) 3482 3483 localVarHeaderParams := make(map[string]string) 3484 localVarQueryParams := url.Values{} 3485 localVarFormParams := url.Values{} 3486 3487 // to determine the Content-Type header 3488 localVarHttpContentTypes := []string{"application/json"} 3489 3490 // set Content-Type header 3491 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 3492 if localVarHttpContentType != "" { 3493 localVarHeaderParams["Content-Type"] = localVarHttpContentType 3494 } 3495 3496 // to determine the Accept header 3497 localVarHttpHeaderAccepts := []string{ 3498 "application/json", 3499 } 3500 3501 // set Accept header 3502 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 3503 if localVarHttpHeaderAccept != "" { 3504 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 3505 } 3506 // body params 3507 localVarPostBody = &baseSwitchingProfile 3508 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 3509 if err != nil { 3510 return successPayload, nil, err 3511 } 3512 3513 localVarHttpResponse, err := a.client.callAPI(r) 3514 if err != nil || localVarHttpResponse == nil { 3515 return successPayload, localVarHttpResponse, err 3516 } 3517 defer localVarHttpResponse.Body.Close() 3518 if localVarHttpResponse.StatusCode >= 300 { 3519 return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status) 3520 } 3521 3522 if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil { 3523 return successPayload, localVarHttpResponse, err 3524 } 3525 3526 return successPayload, localVarHttpResponse, err 3527 } 3528 3529 /* LogicalSwitchingApiService Update a Switching Profile 3530 Updates the user-configurable parameters of a switching profile. Only the qos, port-mirroring, spoof-guard and port-security switching profiles can be modified. You cannot modify the ipfix or ip-discovery switching profiles. 3531 * @param ctx context.Context Authentication Context 3532 @param switchingProfileId 3533 @param baseSwitchingProfile 3534 @return manager.IpDiscoverySwitchingProfile*/ 3535 func (a *LogicalSwitchingApiService) UpdateIpDiscoverySwitchingProfile(ctx context.Context, switchingProfileId string, baseSwitchingProfile manager.IpDiscoverySwitchingProfile) (manager.IpDiscoverySwitchingProfile, *http.Response, error) { 3536 var ( 3537 localVarHttpMethod = strings.ToUpper("Put") 3538 localVarPostBody interface{} 3539 localVarFileName string 3540 localVarFileBytes []byte 3541 successPayload manager.IpDiscoverySwitchingProfile 3542 ) 3543 3544 baseSwitchingProfile.ResourceType = "IpDiscoverySwitchingProfile" 3545 3546 // create path and map variables 3547 localVarPath := a.client.cfg.BasePath + "/switching-profiles/{switching-profile-id}" 3548 localVarPath = strings.Replace(localVarPath, "{"+"switching-profile-id"+"}", fmt.Sprintf("%v", switchingProfileId), -1) 3549 3550 localVarHeaderParams := make(map[string]string) 3551 localVarQueryParams := url.Values{} 3552 localVarFormParams := url.Values{} 3553 3554 // to determine the Content-Type header 3555 localVarHttpContentTypes := []string{"application/json"} 3556 3557 // set Content-Type header 3558 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 3559 if localVarHttpContentType != "" { 3560 localVarHeaderParams["Content-Type"] = localVarHttpContentType 3561 } 3562 3563 // to determine the Accept header 3564 localVarHttpHeaderAccepts := []string{ 3565 "application/json", 3566 } 3567 3568 // set Accept header 3569 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 3570 if localVarHttpHeaderAccept != "" { 3571 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 3572 } 3573 // body params 3574 localVarPostBody = &baseSwitchingProfile 3575 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 3576 if err != nil { 3577 return successPayload, nil, err 3578 } 3579 3580 localVarHttpResponse, err := a.client.callAPI(r) 3581 if err != nil || localVarHttpResponse == nil { 3582 return successPayload, localVarHttpResponse, err 3583 } 3584 defer localVarHttpResponse.Body.Close() 3585 if localVarHttpResponse.StatusCode >= 300 { 3586 return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status) 3587 } 3588 3589 if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil { 3590 return successPayload, localVarHttpResponse, err 3591 } 3592 3593 return successPayload, localVarHttpResponse, err 3594 } 3595 3596 /* LogicalSwitchingApiService Update a Switching Profile 3597 Updates the user-configurable parameters of a switching profile. Only the qos, port-mirroring, spoof-guard and port-security switching profiles can be modified. You cannot modify the ipfix or ip-discovery switching profiles. 3598 * @param ctx context.Context Authentication Context 3599 @param switchingProfileId 3600 @param baseSwitchingProfile 3601 @return manager.PortMirroringSwitchingProfile*/ 3602 func (a *LogicalSwitchingApiService) UpdatePortMirroringSwitchingProfile(ctx context.Context, switchingProfileId string, baseSwitchingProfile manager.PortMirroringSwitchingProfile) (manager.PortMirroringSwitchingProfile, *http.Response, error) { 3603 var ( 3604 localVarHttpMethod = strings.ToUpper("Put") 3605 localVarPostBody interface{} 3606 localVarFileName string 3607 localVarFileBytes []byte 3608 successPayload manager.PortMirroringSwitchingProfile 3609 ) 3610 3611 baseSwitchingProfile.ResourceType = "PortMirroringSwitchingProfile" 3612 3613 // create path and map variables 3614 localVarPath := a.client.cfg.BasePath + "/switching-profiles/{switching-profile-id}" 3615 localVarPath = strings.Replace(localVarPath, "{"+"switching-profile-id"+"}", fmt.Sprintf("%v", switchingProfileId), -1) 3616 3617 localVarHeaderParams := make(map[string]string) 3618 localVarQueryParams := url.Values{} 3619 localVarFormParams := url.Values{} 3620 3621 // to determine the Content-Type header 3622 localVarHttpContentTypes := []string{"application/json"} 3623 3624 // set Content-Type header 3625 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 3626 if localVarHttpContentType != "" { 3627 localVarHeaderParams["Content-Type"] = localVarHttpContentType 3628 } 3629 3630 // to determine the Accept header 3631 localVarHttpHeaderAccepts := []string{ 3632 "application/json", 3633 } 3634 3635 // set Accept header 3636 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 3637 if localVarHttpHeaderAccept != "" { 3638 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 3639 } 3640 // body params 3641 localVarPostBody = &baseSwitchingProfile 3642 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 3643 if err != nil { 3644 return successPayload, nil, err 3645 } 3646 3647 localVarHttpResponse, err := a.client.callAPI(r) 3648 if err != nil || localVarHttpResponse == nil { 3649 return successPayload, localVarHttpResponse, err 3650 } 3651 defer localVarHttpResponse.Body.Close() 3652 if localVarHttpResponse.StatusCode >= 300 { 3653 return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status) 3654 } 3655 3656 if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil { 3657 return successPayload, localVarHttpResponse, err 3658 } 3659 3660 return successPayload, localVarHttpResponse, err 3661 } 3662 3663 /* LogicalSwitchingApiService Update a Switching Profile 3664 Updates the user-configurable parameters of a switching profile. Only the qos, port-mirroring, spoof-guard and port-security switching profiles can be modified. You cannot modify the ipfix or ip-discovery switching profiles. 3665 * @param ctx context.Context Authentication Context 3666 @param switchingProfileId 3667 @param baseSwitchingProfile 3668 @return manager.SpoofGuardSwitchingProfile*/ 3669 func (a *LogicalSwitchingApiService) UpdateSpoofGuardSwitchingProfile(ctx context.Context, switchingProfileId string, baseSwitchingProfile manager.SpoofGuardSwitchingProfile) (manager.SpoofGuardSwitchingProfile, *http.Response, error) { 3670 var ( 3671 localVarHttpMethod = strings.ToUpper("Put") 3672 localVarPostBody interface{} 3673 localVarFileName string 3674 localVarFileBytes []byte 3675 successPayload manager.SpoofGuardSwitchingProfile 3676 ) 3677 3678 baseSwitchingProfile.ResourceType = "SpoofGuardSwitchingProfile" 3679 3680 // create path and map variables 3681 localVarPath := a.client.cfg.BasePath + "/switching-profiles/{switching-profile-id}" 3682 localVarPath = strings.Replace(localVarPath, "{"+"switching-profile-id"+"}", fmt.Sprintf("%v", switchingProfileId), -1) 3683 3684 localVarHeaderParams := make(map[string]string) 3685 localVarQueryParams := url.Values{} 3686 localVarFormParams := url.Values{} 3687 3688 // to determine the Content-Type header 3689 localVarHttpContentTypes := []string{"application/json"} 3690 3691 // set Content-Type header 3692 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 3693 if localVarHttpContentType != "" { 3694 localVarHeaderParams["Content-Type"] = localVarHttpContentType 3695 } 3696 3697 // to determine the Accept header 3698 localVarHttpHeaderAccepts := []string{ 3699 "application/json", 3700 } 3701 3702 // set Accept header 3703 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 3704 if localVarHttpHeaderAccept != "" { 3705 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 3706 } 3707 // body params 3708 localVarPostBody = &baseSwitchingProfile 3709 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 3710 if err != nil { 3711 return successPayload, nil, err 3712 } 3713 3714 localVarHttpResponse, err := a.client.callAPI(r) 3715 if err != nil || localVarHttpResponse == nil { 3716 return successPayload, localVarHttpResponse, err 3717 } 3718 defer localVarHttpResponse.Body.Close() 3719 if localVarHttpResponse.StatusCode >= 300 { 3720 return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status) 3721 } 3722 3723 if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil { 3724 return successPayload, localVarHttpResponse, err 3725 } 3726 3727 return successPayload, localVarHttpResponse, err 3728 } 3729 3730 /* LogicalSwitchingApiService Update a Switching Profile 3731 Updates the user-configurable parameters of a switching profile. Only the qos, port-mirroring, spoof-guard and port-security switching profiles can be modified. You cannot modify the ipfix or ip-discovery switching profiles. 3732 * @param ctx context.Context Authentication Context 3733 @param switchingProfileId 3734 @param baseSwitchingProfile 3735 @return manager.QosSwitchingProfile*/ 3736 func (a *LogicalSwitchingApiService) UpdateQosSwitchingProfile(ctx context.Context, switchingProfileId string, baseSwitchingProfile manager.QosSwitchingProfile) (manager.QosSwitchingProfile, *http.Response, error) { 3737 var ( 3738 localVarHttpMethod = strings.ToUpper("Put") 3739 localVarPostBody interface{} 3740 localVarFileName string 3741 localVarFileBytes []byte 3742 successPayload manager.QosSwitchingProfile 3743 ) 3744 3745 baseSwitchingProfile.ResourceType = "QosSwitchingProfile" 3746 3747 // create path and map variables 3748 localVarPath := a.client.cfg.BasePath + "/switching-profiles/{switching-profile-id}" 3749 localVarPath = strings.Replace(localVarPath, "{"+"switching-profile-id"+"}", fmt.Sprintf("%v", switchingProfileId), -1) 3750 3751 localVarHeaderParams := make(map[string]string) 3752 localVarQueryParams := url.Values{} 3753 localVarFormParams := url.Values{} 3754 3755 // to determine the Content-Type header 3756 localVarHttpContentTypes := []string{"application/json"} 3757 3758 // set Content-Type header 3759 localVarHttpContentType := selectHeaderContentType(localVarHttpContentTypes) 3760 if localVarHttpContentType != "" { 3761 localVarHeaderParams["Content-Type"] = localVarHttpContentType 3762 } 3763 3764 // to determine the Accept header 3765 localVarHttpHeaderAccepts := []string{ 3766 "application/json", 3767 } 3768 3769 // set Accept header 3770 localVarHttpHeaderAccept := selectHeaderAccept(localVarHttpHeaderAccepts) 3771 if localVarHttpHeaderAccept != "" { 3772 localVarHeaderParams["Accept"] = localVarHttpHeaderAccept 3773 } 3774 // body params 3775 localVarPostBody = &baseSwitchingProfile 3776 r, err := a.client.prepareRequest(ctx, localVarPath, localVarHttpMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, localVarFileName, localVarFileBytes) 3777 if err != nil { 3778 return successPayload, nil, err 3779 } 3780 3781 localVarHttpResponse, err := a.client.callAPI(r) 3782 if err != nil || localVarHttpResponse == nil { 3783 return successPayload, localVarHttpResponse, err 3784 } 3785 defer localVarHttpResponse.Body.Close() 3786 if localVarHttpResponse.StatusCode >= 300 { 3787 return successPayload, localVarHttpResponse, reportError(localVarHttpResponse.Status) 3788 } 3789 3790 if err = json.NewDecoder(localVarHttpResponse.Body).Decode(&successPayload); err != nil { 3791 return successPayload, localVarHttpResponse, err 3792 } 3793 3794 return successPayload, localVarHttpResponse, err 3795 }