strongdm.svc
1# Copyright 2020 StrongDM Inc 2# 3# Licensed under the Apache License, Version 2.0 (the "License"); 4# you may not use this file except in compliance with the License. 5# You may obtain a copy of the License at 6# 7# http://www.apache.org/licenses/LICENSE-2.0 8# 9# Unless required by applicable law or agreed to in writing, software 10# distributed under the License is distributed on an "AS IS" BASIS, 11# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12# See the License for the specific language governing permissions and 13# limitations under the License. 14# 15 16# Code generated by protogen. DO NOT EDIT. 17 18import grpc 19from . import plumbing 20from . import models 21from .options_pb2 import * 22from .options_pb2_grpc import * 23from .spec_pb2 import * 24from .spec_pb2_grpc import * 25from .tags_pb2 import * 26from .tags_pb2_grpc import * 27from .access_requests_pb2 import * 28from .access_requests_pb2_grpc import * 29from .access_request_events_history_pb2 import * 30from .access_request_events_history_pb2_grpc import * 31from .access_requests_history_pb2 import * 32from .access_requests_history_pb2_grpc import * 33from .custom_headers_pb2 import * 34from .custom_headers_pb2_grpc import * 35from .drivers_pb2 import * 36from .drivers_pb2_grpc import * 37from .account_attachments_pb2 import * 38from .account_attachments_pb2_grpc import * 39from .account_attachments_history_pb2 import * 40from .account_attachments_history_pb2_grpc import * 41from .account_grants_pb2 import * 42from .account_grants_pb2_grpc import * 43from .account_grants_history_pb2 import * 44from .account_grants_history_pb2_grpc import * 45from .account_permissions_pb2 import * 46from .account_permissions_pb2_grpc import * 47from .account_resources_pb2 import * 48from .account_resources_pb2_grpc import * 49from .account_resources_history_pb2 import * 50from .account_resources_history_pb2_grpc import * 51from .accounts_pb2 import * 52from .accounts_pb2_grpc import * 53from .accounts_groups_pb2 import * 54from .accounts_groups_pb2_grpc import * 55from .accounts_groups_history_pb2 import * 56from .accounts_groups_history_pb2_grpc import * 57from .accounts_history_pb2 import * 58from .accounts_history_pb2_grpc import * 59from .activities_pb2 import * 60from .activities_pb2_grpc import * 61from .approval_workflow_approvers_pb2 import * 62from .approval_workflow_approvers_pb2_grpc import * 63from .approval_workflow_approvers_history_pb2 import * 64from .approval_workflow_approvers_history_pb2_grpc import * 65from .approval_workflow_steps_pb2 import * 66from .approval_workflow_steps_pb2_grpc import * 67from .approval_workflow_steps_history_pb2 import * 68from .approval_workflow_steps_history_pb2_grpc import * 69from .approval_workflows_pb2 import * 70from .approval_workflows_pb2_grpc import * 71from .approval_workflows_history_pb2 import * 72from .approval_workflows_history_pb2_grpc import * 73from .resourcetypes_pb2 import * 74from .resourcetypes_pb2_grpc import * 75from .location_enums_pb2 import * 76from .location_enums_pb2_grpc import * 77from .authorization_policies_pb2 import * 78from .authorization_policies_pb2_grpc import * 79from .control_panel_pb2 import * 80from .control_panel_pb2_grpc import * 81from .discovery_connectors_pb2 import * 82from .discovery_connectors_pb2_grpc import * 83from .granted_account_entitlements_pb2 import * 84from .granted_account_entitlements_pb2_grpc import * 85from .granted_resource_entitlements_pb2 import * 86from .granted_resource_entitlements_pb2_grpc import * 87from .granted_role_entitlements_pb2 import * 88from .granted_role_entitlements_pb2_grpc import * 89from .roles_pb2 import * 90from .roles_pb2_grpc import * 91from .groups_pb2 import * 92from .groups_pb2_grpc import * 93from .groups_history_pb2 import * 94from .groups_history_pb2_grpc import * 95from .groups_roles_pb2 import * 96from .groups_roles_pb2_grpc import * 97from .groups_roles_history_pb2 import * 98from .groups_roles_history_pb2_grpc import * 99from .health_checks_pb2 import * 100from .health_checks_pb2_grpc import * 101from .identity_aliases_pb2 import * 102from .identity_aliases_pb2_grpc import * 103from .identity_aliases_history_pb2 import * 104from .identity_aliases_history_pb2_grpc import * 105from .identity_sets_pb2 import * 106from .identity_sets_pb2_grpc import * 107from .identity_sets_history_pb2 import * 108from .identity_sets_history_pb2_grpc import * 109from .managed_secrets_pb2 import * 110from .managed_secrets_pb2_grpc import * 111from .nodes_pb2 import * 112from .nodes_pb2_grpc import * 113from .nodes_history_pb2 import * 114from .nodes_history_pb2_grpc import * 115from .organization_history_pb2 import * 116from .organization_history_pb2_grpc import * 117from .organizations_pb2 import * 118from .organizations_pb2_grpc import * 119from .peering_group_nodes_pb2 import * 120from .peering_group_nodes_pb2_grpc import * 121from .peering_group_peers_pb2 import * 122from .peering_group_peers_pb2_grpc import * 123from .peering_group_resources_pb2 import * 124from .peering_group_resources_pb2_grpc import * 125from .peering_groups_pb2 import * 126from .peering_groups_pb2_grpc import * 127from .policies_pb2 import * 128from .policies_pb2_grpc import * 129from .policies_history_pb2 import * 130from .policies_history_pb2_grpc import * 131from .proxy_cluster_keys_pb2 import * 132from .proxy_cluster_keys_pb2_grpc import * 133from .queries_pb2 import * 134from .queries_pb2_grpc import * 135from .remote_identities_pb2 import * 136from .remote_identities_pb2_grpc import * 137from .remote_identities_history_pb2 import * 138from .remote_identities_history_pb2_grpc import * 139from .remote_identity_groups_pb2 import * 140from .remote_identity_groups_pb2_grpc import * 141from .remote_identity_groups_history_pb2 import * 142from .remote_identity_groups_history_pb2_grpc import * 143from .replays_pb2 import * 144from .replays_pb2_grpc import * 145from .requestable_account_entitlements_pb2 import * 146from .requestable_account_entitlements_pb2_grpc import * 147from .requestable_resource_entitlements_pb2 import * 148from .requestable_resource_entitlements_pb2_grpc import * 149from .requestable_role_entitlements_pb2 import * 150from .requestable_role_entitlements_pb2_grpc import * 151from .resources_pb2 import * 152from .resources_pb2_grpc import * 153from .resources_history_pb2 import * 154from .resources_history_pb2_grpc import * 155from .role_resources_pb2 import * 156from .role_resources_pb2_grpc import * 157from .role_resources_history_pb2 import * 158from .role_resources_history_pb2_grpc import * 159from .roles_history_pb2 import * 160from .roles_history_pb2_grpc import * 161from .secret_engine_policy_pb2 import * 162from .secret_engine_policy_pb2_grpc import * 163from .secret_engine_types_pb2 import * 164from .secret_engine_types_pb2_grpc import * 165from .secret_store_types_pb2 import * 166from .secret_store_types_pb2_grpc import * 167from .secret_stores_pb2 import * 168from .secret_stores_pb2_grpc import * 169from .secret_engines_pb2 import * 170from .secret_engines_pb2_grpc import * 171from .secret_store_healths_pb2 import * 172from .secret_store_healths_pb2_grpc import * 173from .secret_stores_history_pb2 import * 174from .secret_stores_history_pb2_grpc import * 175from .workflow_approvers_pb2 import * 176from .workflow_approvers_pb2_grpc import * 177from .workflow_approvers_history_pb2 import * 178from .workflow_approvers_history_pb2_grpc import * 179from .workflow_roles_pb2 import * 180from .workflow_roles_pb2_grpc import * 181from .workflow_roles_history_pb2 import * 182from .workflow_roles_history_pb2_grpc import * 183from .workflows_pb2 import * 184from .workflows_pb2_grpc import * 185from .workflows_history_pb2 import * 186from .workflows_history_pb2_grpc import * 187import warnings 188import functools 189import time 190 191 192def deprecated(func): 193 """This is a decorator which can be used to mark functions 194 as deprecated. It will result in a warning being emitted 195 when the function is used.""" 196 @functools.wraps(func) 197 def new_func(*args, **kwargs): 198 warnings.warn("Call to deprecated function {}.".format(func.__name__), 199 category=DeprecationWarning, 200 stacklevel=2) 201 return func(*args, **kwargs) 202 203 return new_func 204 205 206class AccessRequests: 207 ''' 208 AccessRequests are requests for access to a resource that may match a Workflow. 209 See `strongdm.models.AccessRequest`. 210 ''' 211 def __init__(self, channel, client): 212 self.parent = client 213 self.stub = AccessRequestsStub(channel) 214 215 def list(self, filter, *args, timeout=None): 216 ''' 217 Lists existing access requests. 218 ''' 219 deadline = None if timeout is None else time.time() + timeout 220 req = AccessRequestListRequest() 221 req.meta.CopyFrom(ListRequestMetadata()) 222 if self.parent.page_limit > 0: 223 req.meta.limit = self.parent.page_limit 224 if self.parent.snapshot_datetime is not None: 225 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 226 227 req.filter = plumbing.quote_filter_args(filter, *args) 228 229 def generator(svc, req): 230 tries = 0 231 while True: 232 t = None if deadline is None else deadline - time.time() 233 try: 234 plumbing_response = svc.stub.List( 235 req, 236 metadata=svc.parent.get_metadata( 237 'AccessRequests.List', req), 238 timeout=t) 239 except Exception as e: 240 if self.parent.shouldRetry(tries, e, deadline): 241 tries += 1 242 time.sleep( 243 self.parent.exponentialBackoff(tries, deadline)) 244 continue 245 raise plumbing.convert_error_to_porcelain(e) from e 246 tries = 0 247 for plumbing_item in plumbing_response.access_requests: 248 yield plumbing.convert_access_request_to_porcelain( 249 plumbing_item) 250 if plumbing_response.meta.next_cursor == '': 251 break 252 req.meta.cursor = plumbing_response.meta.next_cursor 253 254 return generator(self, req) 255 256 257class SnapshotAccessRequests: 258 ''' 259 SnapshotAccessRequests exposes the read only methods of the AccessRequests 260 service for historical queries. 261 ''' 262 def __init__(self, access_requests): 263 self.access_requests = access_requests 264 265 def list(self, filter, *args, timeout=None): 266 ''' 267 Lists existing access requests. 268 ''' 269 return self.access_requests.list(filter, *args, timeout=timeout) 270 271 272class AccessRequestEventsHistory: 273 ''' 274 AccessRequestEventsHistory provides records of all changes to the state of an AccessRequest. 275 See `strongdm.models.AccessRequestEventHistory`. 276 ''' 277 def __init__(self, channel, client): 278 self.parent = client 279 self.stub = AccessRequestEventsHistoryStub(channel) 280 281 def list(self, filter, *args, timeout=None): 282 ''' 283 List gets a list of AccessRequestEventHistory records matching a given set of criteria. 284 ''' 285 deadline = None if timeout is None else time.time() + timeout 286 req = AccessRequestEventHistoryListRequest() 287 req.meta.CopyFrom(ListRequestMetadata()) 288 if self.parent.page_limit > 0: 289 req.meta.limit = self.parent.page_limit 290 if self.parent.snapshot_datetime is not None: 291 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 292 293 req.filter = plumbing.quote_filter_args(filter, *args) 294 295 def generator(svc, req): 296 tries = 0 297 while True: 298 t = None if deadline is None else deadline - time.time() 299 try: 300 plumbing_response = svc.stub.List( 301 req, 302 metadata=svc.parent.get_metadata( 303 'AccessRequestEventsHistory.List', req), 304 timeout=t) 305 except Exception as e: 306 if self.parent.shouldRetry(tries, e, deadline): 307 tries += 1 308 time.sleep( 309 self.parent.exponentialBackoff(tries, deadline)) 310 continue 311 raise plumbing.convert_error_to_porcelain(e) from e 312 tries = 0 313 for plumbing_item in plumbing_response.history: 314 yield plumbing.convert_access_request_event_history_to_porcelain( 315 plumbing_item) 316 if plumbing_response.meta.next_cursor == '': 317 break 318 req.meta.cursor = plumbing_response.meta.next_cursor 319 320 return generator(self, req) 321 322 323class AccessRequestsHistory: 324 ''' 325 AccessRequestsHistory provides records of all changes to the state of an AccessRequest. 326 See `strongdm.models.AccessRequestHistory`. 327 ''' 328 def __init__(self, channel, client): 329 self.parent = client 330 self.stub = AccessRequestsHistoryStub(channel) 331 332 def list(self, filter, *args, timeout=None): 333 ''' 334 List gets a list of AccessRequestHistory records matching a given set of criteria. 335 ''' 336 deadline = None if timeout is None else time.time() + timeout 337 req = AccessRequestHistoryListRequest() 338 req.meta.CopyFrom(ListRequestMetadata()) 339 if self.parent.page_limit > 0: 340 req.meta.limit = self.parent.page_limit 341 if self.parent.snapshot_datetime is not None: 342 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 343 344 req.filter = plumbing.quote_filter_args(filter, *args) 345 346 def generator(svc, req): 347 tries = 0 348 while True: 349 t = None if deadline is None else deadline - time.time() 350 try: 351 plumbing_response = svc.stub.List( 352 req, 353 metadata=svc.parent.get_metadata( 354 'AccessRequestsHistory.List', req), 355 timeout=t) 356 except Exception as e: 357 if self.parent.shouldRetry(tries, e, deadline): 358 tries += 1 359 time.sleep( 360 self.parent.exponentialBackoff(tries, deadline)) 361 continue 362 raise plumbing.convert_error_to_porcelain(e) from e 363 tries = 0 364 for plumbing_item in plumbing_response.history: 365 yield plumbing.convert_access_request_history_to_porcelain( 366 plumbing_item) 367 if plumbing_response.meta.next_cursor == '': 368 break 369 req.meta.cursor = plumbing_response.meta.next_cursor 370 371 return generator(self, req) 372 373 374class AccountAttachments: 375 ''' 376 AccountAttachments assign an account to a role. 377 See `strongdm.models.AccountAttachment`. 378 ''' 379 def __init__(self, channel, client): 380 self.parent = client 381 self.stub = AccountAttachmentsStub(channel) 382 383 def create(self, account_attachment, timeout=None): 384 ''' 385 Create registers a new AccountAttachment. 386 ''' 387 deadline = None if timeout is None else time.time() + timeout 388 req = AccountAttachmentCreateRequest() 389 390 if account_attachment is not None: 391 req.account_attachment.CopyFrom( 392 plumbing.convert_account_attachment_to_plumbing( 393 account_attachment)) 394 tries = 0 395 plumbing_response = None 396 while True: 397 t = None if deadline is None else deadline - time.time() 398 try: 399 plumbing_response = self.stub.Create( 400 req, 401 metadata=self.parent.get_metadata( 402 'AccountAttachments.Create', req), 403 timeout=t) 404 except Exception as e: 405 if self.parent.shouldRetry(tries, e, deadline): 406 tries += 1 407 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 408 continue 409 raise plumbing.convert_error_to_porcelain(e) from e 410 break 411 412 resp = models.AccountAttachmentCreateResponse() 413 resp.account_attachment = plumbing.convert_account_attachment_to_porcelain( 414 plumbing_response.account_attachment) 415 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 416 plumbing_response.meta) 417 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 418 plumbing_response.rate_limit) 419 return resp 420 421 def get(self, id, timeout=None): 422 ''' 423 Get reads one AccountAttachment by ID. 424 ''' 425 deadline = None if timeout is None else time.time() + timeout 426 req = AccountAttachmentGetRequest() 427 if self.parent.snapshot_datetime is not None: 428 req.meta.CopyFrom(GetRequestMetadata()) 429 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 430 431 req.id = (id) 432 tries = 0 433 plumbing_response = None 434 while True: 435 t = None if deadline is None else deadline - time.time() 436 try: 437 plumbing_response = self.stub.Get( 438 req, 439 metadata=self.parent.get_metadata('AccountAttachments.Get', 440 req), 441 timeout=t) 442 except Exception as e: 443 if self.parent.shouldRetry(tries, e, deadline): 444 tries += 1 445 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 446 continue 447 raise plumbing.convert_error_to_porcelain(e) from e 448 break 449 450 resp = models.AccountAttachmentGetResponse() 451 resp.account_attachment = plumbing.convert_account_attachment_to_porcelain( 452 plumbing_response.account_attachment) 453 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 454 plumbing_response.meta) 455 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 456 plumbing_response.rate_limit) 457 return resp 458 459 def delete(self, id, timeout=None): 460 ''' 461 Delete removes a AccountAttachment by ID. 462 ''' 463 deadline = None if timeout is None else time.time() + timeout 464 req = AccountAttachmentDeleteRequest() 465 466 req.id = (id) 467 tries = 0 468 plumbing_response = None 469 while True: 470 t = None if deadline is None else deadline - time.time() 471 try: 472 plumbing_response = self.stub.Delete( 473 req, 474 metadata=self.parent.get_metadata( 475 'AccountAttachments.Delete', req), 476 timeout=t) 477 except Exception as e: 478 if self.parent.shouldRetry(tries, e, deadline): 479 tries += 1 480 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 481 continue 482 raise plumbing.convert_error_to_porcelain(e) from e 483 break 484 485 resp = models.AccountAttachmentDeleteResponse() 486 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 487 plumbing_response.meta) 488 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 489 plumbing_response.rate_limit) 490 return resp 491 492 def list(self, filter, *args, timeout=None): 493 ''' 494 List gets a list of AccountAttachments matching a given set of criteria. 495 ''' 496 deadline = None if timeout is None else time.time() + timeout 497 req = AccountAttachmentListRequest() 498 req.meta.CopyFrom(ListRequestMetadata()) 499 if self.parent.page_limit > 0: 500 req.meta.limit = self.parent.page_limit 501 if self.parent.snapshot_datetime is not None: 502 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 503 504 req.filter = plumbing.quote_filter_args(filter, *args) 505 506 def generator(svc, req): 507 tries = 0 508 while True: 509 t = None if deadline is None else deadline - time.time() 510 try: 511 plumbing_response = svc.stub.List( 512 req, 513 metadata=svc.parent.get_metadata( 514 'AccountAttachments.List', req), 515 timeout=t) 516 except Exception as e: 517 if self.parent.shouldRetry(tries, e, deadline): 518 tries += 1 519 time.sleep( 520 self.parent.exponentialBackoff(tries, deadline)) 521 continue 522 raise plumbing.convert_error_to_porcelain(e) from e 523 tries = 0 524 for plumbing_item in plumbing_response.account_attachments: 525 yield plumbing.convert_account_attachment_to_porcelain( 526 plumbing_item) 527 if plumbing_response.meta.next_cursor == '': 528 break 529 req.meta.cursor = plumbing_response.meta.next_cursor 530 531 return generator(self, req) 532 533 534class SnapshotAccountAttachments: 535 ''' 536 SnapshotAccountAttachments exposes the read only methods of the AccountAttachments 537 service for historical queries. 538 ''' 539 def __init__(self, account_attachments): 540 self.account_attachments = account_attachments 541 542 def get(self, id, timeout=None): 543 ''' 544 Get reads one AccountAttachment by ID. 545 ''' 546 return self.account_attachments.get(id, timeout=timeout) 547 548 def list(self, filter, *args, timeout=None): 549 ''' 550 List gets a list of AccountAttachments matching a given set of criteria. 551 ''' 552 return self.account_attachments.list(filter, *args, timeout=timeout) 553 554 555class AccountAttachmentsHistory: 556 ''' 557 AccountAttachmentsHistory records all changes to the state of an AccountAttachment. 558 See `strongdm.models.AccountAttachmentHistory`. 559 ''' 560 def __init__(self, channel, client): 561 self.parent = client 562 self.stub = AccountAttachmentsHistoryStub(channel) 563 564 def list(self, filter, *args, timeout=None): 565 ''' 566 List gets a list of AccountAttachmentHistory records matching a given set of criteria. 567 ''' 568 deadline = None if timeout is None else time.time() + timeout 569 req = AccountAttachmentHistoryListRequest() 570 req.meta.CopyFrom(ListRequestMetadata()) 571 if self.parent.page_limit > 0: 572 req.meta.limit = self.parent.page_limit 573 if self.parent.snapshot_datetime is not None: 574 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 575 576 req.filter = plumbing.quote_filter_args(filter, *args) 577 578 def generator(svc, req): 579 tries = 0 580 while True: 581 t = None if deadline is None else deadline - time.time() 582 try: 583 plumbing_response = svc.stub.List( 584 req, 585 metadata=svc.parent.get_metadata( 586 'AccountAttachmentsHistory.List', req), 587 timeout=t) 588 except Exception as e: 589 if self.parent.shouldRetry(tries, e, deadline): 590 tries += 1 591 time.sleep( 592 self.parent.exponentialBackoff(tries, deadline)) 593 continue 594 raise plumbing.convert_error_to_porcelain(e) from e 595 tries = 0 596 for plumbing_item in plumbing_response.history: 597 yield plumbing.convert_account_attachment_history_to_porcelain( 598 plumbing_item) 599 if plumbing_response.meta.next_cursor == '': 600 break 601 req.meta.cursor = plumbing_response.meta.next_cursor 602 603 return generator(self, req) 604 605 606class AccountGrants: 607 ''' 608 AccountGrants assign a resource directly to an account, giving the account the permission to connect to that resource. 609 See `strongdm.models.AccountGrant`. 610 ''' 611 def __init__(self, channel, client): 612 self.parent = client 613 self.stub = AccountGrantsStub(channel) 614 615 def create(self, account_grant, timeout=None): 616 ''' 617 Create registers a new AccountGrant. 618 ''' 619 deadline = None if timeout is None else time.time() + timeout 620 req = AccountGrantCreateRequest() 621 622 if account_grant is not None: 623 req.account_grant.CopyFrom( 624 plumbing.convert_account_grant_to_plumbing(account_grant)) 625 tries = 0 626 plumbing_response = None 627 while True: 628 t = None if deadline is None else deadline - time.time() 629 try: 630 plumbing_response = self.stub.Create( 631 req, 632 metadata=self.parent.get_metadata('AccountGrants.Create', 633 req), 634 timeout=t) 635 except Exception as e: 636 if self.parent.shouldRetry(tries, e, deadline): 637 tries += 1 638 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 639 continue 640 raise plumbing.convert_error_to_porcelain(e) from e 641 break 642 643 resp = models.AccountGrantCreateResponse() 644 resp.account_grant = plumbing.convert_account_grant_to_porcelain( 645 plumbing_response.account_grant) 646 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 647 plumbing_response.meta) 648 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 649 plumbing_response.rate_limit) 650 return resp 651 652 def get(self, id, timeout=None): 653 ''' 654 Get reads one AccountGrant by ID. 655 ''' 656 deadline = None if timeout is None else time.time() + timeout 657 req = AccountGrantGetRequest() 658 if self.parent.snapshot_datetime is not None: 659 req.meta.CopyFrom(GetRequestMetadata()) 660 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 661 662 req.id = (id) 663 tries = 0 664 plumbing_response = None 665 while True: 666 t = None if deadline is None else deadline - time.time() 667 try: 668 plumbing_response = self.stub.Get( 669 req, 670 metadata=self.parent.get_metadata('AccountGrants.Get', 671 req), 672 timeout=t) 673 except Exception as e: 674 if self.parent.shouldRetry(tries, e, deadline): 675 tries += 1 676 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 677 continue 678 raise plumbing.convert_error_to_porcelain(e) from e 679 break 680 681 resp = models.AccountGrantGetResponse() 682 resp.account_grant = plumbing.convert_account_grant_to_porcelain( 683 plumbing_response.account_grant) 684 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 685 plumbing_response.meta) 686 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 687 plumbing_response.rate_limit) 688 return resp 689 690 def delete(self, id, timeout=None): 691 ''' 692 Delete removes a AccountGrant by ID. 693 ''' 694 deadline = None if timeout is None else time.time() + timeout 695 req = AccountGrantDeleteRequest() 696 697 req.id = (id) 698 tries = 0 699 plumbing_response = None 700 while True: 701 t = None if deadline is None else deadline - time.time() 702 try: 703 plumbing_response = self.stub.Delete( 704 req, 705 metadata=self.parent.get_metadata('AccountGrants.Delete', 706 req), 707 timeout=t) 708 except Exception as e: 709 if self.parent.shouldRetry(tries, e, deadline): 710 tries += 1 711 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 712 continue 713 raise plumbing.convert_error_to_porcelain(e) from e 714 break 715 716 resp = models.AccountGrantDeleteResponse() 717 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 718 plumbing_response.meta) 719 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 720 plumbing_response.rate_limit) 721 return resp 722 723 def list(self, filter, *args, timeout=None): 724 ''' 725 List gets a list of AccountGrants matching a given set of criteria. 726 ''' 727 deadline = None if timeout is None else time.time() + timeout 728 req = AccountGrantListRequest() 729 req.meta.CopyFrom(ListRequestMetadata()) 730 if self.parent.page_limit > 0: 731 req.meta.limit = self.parent.page_limit 732 if self.parent.snapshot_datetime is not None: 733 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 734 735 req.filter = plumbing.quote_filter_args(filter, *args) 736 737 def generator(svc, req): 738 tries = 0 739 while True: 740 t = None if deadline is None else deadline - time.time() 741 try: 742 plumbing_response = svc.stub.List( 743 req, 744 metadata=svc.parent.get_metadata( 745 'AccountGrants.List', req), 746 timeout=t) 747 except Exception as e: 748 if self.parent.shouldRetry(tries, e, deadline): 749 tries += 1 750 time.sleep( 751 self.parent.exponentialBackoff(tries, deadline)) 752 continue 753 raise plumbing.convert_error_to_porcelain(e) from e 754 tries = 0 755 for plumbing_item in plumbing_response.account_grants: 756 yield plumbing.convert_account_grant_to_porcelain( 757 plumbing_item) 758 if plumbing_response.meta.next_cursor == '': 759 break 760 req.meta.cursor = plumbing_response.meta.next_cursor 761 762 return generator(self, req) 763 764 765class SnapshotAccountGrants: 766 ''' 767 SnapshotAccountGrants exposes the read only methods of the AccountGrants 768 service for historical queries. 769 ''' 770 def __init__(self, account_grants): 771 self.account_grants = account_grants 772 773 def get(self, id, timeout=None): 774 ''' 775 Get reads one AccountGrant by ID. 776 ''' 777 return self.account_grants.get(id, timeout=timeout) 778 779 def list(self, filter, *args, timeout=None): 780 ''' 781 List gets a list of AccountGrants matching a given set of criteria. 782 ''' 783 return self.account_grants.list(filter, *args, timeout=timeout) 784 785 786class AccountGrantsHistory: 787 ''' 788 AccountGrantsHistory records all changes to the state of an AccountGrant. 789 See `strongdm.models.AccountGrantHistory`. 790 ''' 791 def __init__(self, channel, client): 792 self.parent = client 793 self.stub = AccountGrantsHistoryStub(channel) 794 795 def list(self, filter, *args, timeout=None): 796 ''' 797 List gets a list of AccountGrantHistory records matching a given set of criteria. 798 ''' 799 deadline = None if timeout is None else time.time() + timeout 800 req = AccountGrantHistoryListRequest() 801 req.meta.CopyFrom(ListRequestMetadata()) 802 if self.parent.page_limit > 0: 803 req.meta.limit = self.parent.page_limit 804 if self.parent.snapshot_datetime is not None: 805 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 806 807 req.filter = plumbing.quote_filter_args(filter, *args) 808 809 def generator(svc, req): 810 tries = 0 811 while True: 812 t = None if deadline is None else deadline - time.time() 813 try: 814 plumbing_response = svc.stub.List( 815 req, 816 metadata=svc.parent.get_metadata( 817 'AccountGrantsHistory.List', req), 818 timeout=t) 819 except Exception as e: 820 if self.parent.shouldRetry(tries, e, deadline): 821 tries += 1 822 time.sleep( 823 self.parent.exponentialBackoff(tries, deadline)) 824 continue 825 raise plumbing.convert_error_to_porcelain(e) from e 826 tries = 0 827 for plumbing_item in plumbing_response.history: 828 yield plumbing.convert_account_grant_history_to_porcelain( 829 plumbing_item) 830 if plumbing_response.meta.next_cursor == '': 831 break 832 req.meta.cursor = plumbing_response.meta.next_cursor 833 834 return generator(self, req) 835 836 837class AccountPermissions: 838 ''' 839 AccountPermissions records the granular permissions accounts have, allowing them to execute 840 relevant commands via StrongDM's APIs. 841 See `strongdm.models.AccountPermission`. 842 ''' 843 def __init__(self, channel, client): 844 self.parent = client 845 self.stub = AccountPermissionsStub(channel) 846 847 def list(self, filter, *args, timeout=None): 848 ''' 849 List gets a list of Permission records matching a given set of criteria. 850 ''' 851 deadline = None if timeout is None else time.time() + timeout 852 req = AccountPermissionListRequest() 853 req.meta.CopyFrom(ListRequestMetadata()) 854 if self.parent.page_limit > 0: 855 req.meta.limit = self.parent.page_limit 856 if self.parent.snapshot_datetime is not None: 857 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 858 859 req.filter = plumbing.quote_filter_args(filter, *args) 860 861 def generator(svc, req): 862 tries = 0 863 while True: 864 t = None if deadline is None else deadline - time.time() 865 try: 866 plumbing_response = svc.stub.List( 867 req, 868 metadata=svc.parent.get_metadata( 869 'AccountPermissions.List', req), 870 timeout=t) 871 except Exception as e: 872 if self.parent.shouldRetry(tries, e, deadline): 873 tries += 1 874 time.sleep( 875 self.parent.exponentialBackoff(tries, deadline)) 876 continue 877 raise plumbing.convert_error_to_porcelain(e) from e 878 tries = 0 879 for plumbing_item in plumbing_response.permissions: 880 yield plumbing.convert_account_permission_to_porcelain( 881 plumbing_item) 882 if plumbing_response.meta.next_cursor == '': 883 break 884 req.meta.cursor = plumbing_response.meta.next_cursor 885 886 return generator(self, req) 887 888 889class SnapshotAccountPermissions: 890 ''' 891 SnapshotAccountPermissions exposes the read only methods of the AccountPermissions 892 service for historical queries. 893 ''' 894 def __init__(self, account_permissions): 895 self.account_permissions = account_permissions 896 897 def list(self, filter, *args, timeout=None): 898 ''' 899 List gets a list of Permission records matching a given set of criteria. 900 ''' 901 return self.account_permissions.list(filter, *args, timeout=timeout) 902 903 904class AccountResources: 905 ''' 906 AccountResources enumerates the resources to which accounts have access. 907 The AccountResources service is read-only. 908 See `strongdm.models.AccountResource`. 909 ''' 910 def __init__(self, channel, client): 911 self.parent = client 912 self.stub = AccountResourcesStub(channel) 913 914 def list(self, filter, *args, timeout=None): 915 ''' 916 List gets a list of AccountResource records matching a given set of criteria. 917 ''' 918 deadline = None if timeout is None else time.time() + timeout 919 req = AccountResourceListRequest() 920 req.meta.CopyFrom(ListRequestMetadata()) 921 if self.parent.page_limit > 0: 922 req.meta.limit = self.parent.page_limit 923 if self.parent.snapshot_datetime is not None: 924 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 925 926 req.filter = plumbing.quote_filter_args(filter, *args) 927 928 def generator(svc, req): 929 tries = 0 930 while True: 931 t = None if deadline is None else deadline - time.time() 932 try: 933 plumbing_response = svc.stub.List( 934 req, 935 metadata=svc.parent.get_metadata( 936 'AccountResources.List', req), 937 timeout=t) 938 except Exception as e: 939 if self.parent.shouldRetry(tries, e, deadline): 940 tries += 1 941 time.sleep( 942 self.parent.exponentialBackoff(tries, deadline)) 943 continue 944 raise plumbing.convert_error_to_porcelain(e) from e 945 tries = 0 946 for plumbing_item in plumbing_response.account_resources: 947 yield plumbing.convert_account_resource_to_porcelain( 948 plumbing_item) 949 if plumbing_response.meta.next_cursor == '': 950 break 951 req.meta.cursor = plumbing_response.meta.next_cursor 952 953 return generator(self, req) 954 955 956class SnapshotAccountResources: 957 ''' 958 SnapshotAccountResources exposes the read only methods of the AccountResources 959 service for historical queries. 960 ''' 961 def __init__(self, account_resources): 962 self.account_resources = account_resources 963 964 def list(self, filter, *args, timeout=None): 965 ''' 966 List gets a list of AccountResource records matching a given set of criteria. 967 ''' 968 return self.account_resources.list(filter, *args, timeout=timeout) 969 970 971class AccountResourcesHistory: 972 ''' 973 AccountResourcesHistory records all changes to the state of a AccountResource. 974 See `strongdm.models.AccountResourceHistory`. 975 ''' 976 def __init__(self, channel, client): 977 self.parent = client 978 self.stub = AccountResourcesHistoryStub(channel) 979 980 def list(self, filter, *args, timeout=None): 981 ''' 982 List gets a list of AccountResourceHistory records matching a given set of criteria. 983 ''' 984 deadline = None if timeout is None else time.time() + timeout 985 req = AccountResourceHistoryListRequest() 986 req.meta.CopyFrom(ListRequestMetadata()) 987 if self.parent.page_limit > 0: 988 req.meta.limit = self.parent.page_limit 989 if self.parent.snapshot_datetime is not None: 990 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 991 992 req.filter = plumbing.quote_filter_args(filter, *args) 993 994 def generator(svc, req): 995 tries = 0 996 while True: 997 t = None if deadline is None else deadline - time.time() 998 try: 999 plumbing_response = svc.stub.List( 1000 req, 1001 metadata=svc.parent.get_metadata( 1002 'AccountResourcesHistory.List', req), 1003 timeout=t) 1004 except Exception as e: 1005 if self.parent.shouldRetry(tries, e, deadline): 1006 tries += 1 1007 time.sleep( 1008 self.parent.exponentialBackoff(tries, deadline)) 1009 continue 1010 raise plumbing.convert_error_to_porcelain(e) from e 1011 tries = 0 1012 for plumbing_item in plumbing_response.history: 1013 yield plumbing.convert_account_resource_history_to_porcelain( 1014 plumbing_item) 1015 if plumbing_response.meta.next_cursor == '': 1016 break 1017 req.meta.cursor = plumbing_response.meta.next_cursor 1018 1019 return generator(self, req) 1020 1021 1022class Accounts: 1023 ''' 1024 Accounts are users that have access to strongDM. There are two types of accounts: 1025 1. **Users:** humans who are authenticated through username and password or SSO. 1026 2. **Service Accounts:** machines that are authenticated using a service token. 1027 3. **Tokens** are access keys with permissions that can be used for authentication. 1028 See: 1029 `strongdm.models.Service` 1030 `strongdm.models.Token` 1031 `strongdm.models.User` 1032 ''' 1033 def __init__(self, channel, client): 1034 self.parent = client 1035 self.stub = AccountsStub(channel) 1036 1037 def create(self, account, timeout=None): 1038 ''' 1039 Create registers a new Account. 1040 ''' 1041 deadline = None if timeout is None else time.time() + timeout 1042 req = AccountCreateRequest() 1043 1044 if account is not None: 1045 req.account.CopyFrom(plumbing.convert_account_to_plumbing(account)) 1046 tries = 0 1047 plumbing_response = None 1048 while True: 1049 t = None if deadline is None else deadline - time.time() 1050 try: 1051 plumbing_response = self.stub.Create( 1052 req, 1053 metadata=self.parent.get_metadata('Accounts.Create', req), 1054 timeout=t) 1055 except Exception as e: 1056 if self.parent.shouldRetry(tries, e, deadline): 1057 tries += 1 1058 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1059 continue 1060 raise plumbing.convert_error_to_porcelain(e) from e 1061 break 1062 1063 resp = models.AccountCreateResponse() 1064 resp.access_key = (plumbing_response.access_key) 1065 resp.account = plumbing.convert_account_to_porcelain( 1066 plumbing_response.account) 1067 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 1068 plumbing_response.meta) 1069 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1070 plumbing_response.rate_limit) 1071 resp.secret_key = (plumbing_response.secret_key) 1072 resp.token = (plumbing_response.token) 1073 return resp 1074 1075 def get(self, id, timeout=None): 1076 ''' 1077 Get reads one Account by ID. 1078 ''' 1079 deadline = None if timeout is None else time.time() + timeout 1080 req = AccountGetRequest() 1081 if self.parent.snapshot_datetime is not None: 1082 req.meta.CopyFrom(GetRequestMetadata()) 1083 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1084 1085 req.id = (id) 1086 tries = 0 1087 plumbing_response = None 1088 while True: 1089 t = None if deadline is None else deadline - time.time() 1090 try: 1091 plumbing_response = self.stub.Get( 1092 req, 1093 metadata=self.parent.get_metadata('Accounts.Get', req), 1094 timeout=t) 1095 except Exception as e: 1096 if self.parent.shouldRetry(tries, e, deadline): 1097 tries += 1 1098 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1099 continue 1100 raise plumbing.convert_error_to_porcelain(e) from e 1101 break 1102 1103 resp = models.AccountGetResponse() 1104 resp.account = plumbing.convert_account_to_porcelain( 1105 plumbing_response.account) 1106 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1107 plumbing_response.meta) 1108 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1109 plumbing_response.rate_limit) 1110 return resp 1111 1112 def update(self, account, timeout=None): 1113 ''' 1114 Update replaces all the fields of an Account by ID. 1115 ''' 1116 deadline = None if timeout is None else time.time() + timeout 1117 req = AccountUpdateRequest() 1118 1119 if account is not None: 1120 req.account.CopyFrom(plumbing.convert_account_to_plumbing(account)) 1121 tries = 0 1122 plumbing_response = None 1123 while True: 1124 t = None if deadline is None else deadline - time.time() 1125 try: 1126 plumbing_response = self.stub.Update( 1127 req, 1128 metadata=self.parent.get_metadata('Accounts.Update', req), 1129 timeout=t) 1130 except Exception as e: 1131 if self.parent.shouldRetry(tries, e, deadline): 1132 tries += 1 1133 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1134 continue 1135 raise plumbing.convert_error_to_porcelain(e) from e 1136 break 1137 1138 resp = models.AccountUpdateResponse() 1139 resp.account = plumbing.convert_account_to_porcelain( 1140 plumbing_response.account) 1141 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 1142 plumbing_response.meta) 1143 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1144 plumbing_response.rate_limit) 1145 return resp 1146 1147 def delete(self, id, timeout=None): 1148 ''' 1149 Delete removes an Account by ID. 1150 ''' 1151 deadline = None if timeout is None else time.time() + timeout 1152 req = AccountDeleteRequest() 1153 1154 req.id = (id) 1155 tries = 0 1156 plumbing_response = None 1157 while True: 1158 t = None if deadline is None else deadline - time.time() 1159 try: 1160 plumbing_response = self.stub.Delete( 1161 req, 1162 metadata=self.parent.get_metadata('Accounts.Delete', req), 1163 timeout=t) 1164 except Exception as e: 1165 if self.parent.shouldRetry(tries, e, deadline): 1166 tries += 1 1167 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1168 continue 1169 raise plumbing.convert_error_to_porcelain(e) from e 1170 break 1171 1172 resp = models.AccountDeleteResponse() 1173 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 1174 plumbing_response.meta) 1175 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1176 plumbing_response.rate_limit) 1177 return resp 1178 1179 def list(self, filter, *args, timeout=None): 1180 ''' 1181 List gets a list of Accounts matching a given set of criteria. 1182 ''' 1183 deadline = None if timeout is None else time.time() + timeout 1184 req = AccountListRequest() 1185 req.meta.CopyFrom(ListRequestMetadata()) 1186 if self.parent.page_limit > 0: 1187 req.meta.limit = self.parent.page_limit 1188 if self.parent.snapshot_datetime is not None: 1189 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1190 1191 req.filter = plumbing.quote_filter_args(filter, *args) 1192 1193 def generator(svc, req): 1194 tries = 0 1195 while True: 1196 t = None if deadline is None else deadline - time.time() 1197 try: 1198 plumbing_response = svc.stub.List( 1199 req, 1200 metadata=svc.parent.get_metadata('Accounts.List', req), 1201 timeout=t) 1202 except Exception as e: 1203 if self.parent.shouldRetry(tries, e, deadline): 1204 tries += 1 1205 time.sleep( 1206 self.parent.exponentialBackoff(tries, deadline)) 1207 continue 1208 raise plumbing.convert_error_to_porcelain(e) from e 1209 tries = 0 1210 for plumbing_item in plumbing_response.accounts: 1211 yield plumbing.convert_account_to_porcelain(plumbing_item) 1212 if plumbing_response.meta.next_cursor == '': 1213 break 1214 req.meta.cursor = plumbing_response.meta.next_cursor 1215 1216 return generator(self, req) 1217 1218 1219class SnapshotAccounts: 1220 ''' 1221 SnapshotAccounts exposes the read only methods of the Accounts 1222 service for historical queries. 1223 ''' 1224 def __init__(self, accounts): 1225 self.accounts = accounts 1226 1227 def get(self, id, timeout=None): 1228 ''' 1229 Get reads one Account by ID. 1230 ''' 1231 return self.accounts.get(id, timeout=timeout) 1232 1233 def list(self, filter, *args, timeout=None): 1234 ''' 1235 List gets a list of Accounts matching a given set of criteria. 1236 ''' 1237 return self.accounts.list(filter, *args, timeout=timeout) 1238 1239 1240class AccountsGroups: 1241 ''' 1242 An AccountGroup links an account and a group. 1243 See `strongdm.models.AccountGroup`. 1244 ''' 1245 def __init__(self, channel, client): 1246 self.parent = client 1247 self.stub = AccountsGroupsStub(channel) 1248 1249 def create(self, account_group, timeout=None): 1250 ''' 1251 Create create a new AccountGroup. 1252 ''' 1253 deadline = None if timeout is None else time.time() + timeout 1254 req = AccountGroupCreateRequest() 1255 1256 if account_group is not None: 1257 req.account_group.CopyFrom( 1258 plumbing.convert_account_group_to_plumbing(account_group)) 1259 tries = 0 1260 plumbing_response = None 1261 while True: 1262 t = None if deadline is None else deadline - time.time() 1263 try: 1264 plumbing_response = self.stub.Create( 1265 req, 1266 metadata=self.parent.get_metadata('AccountsGroups.Create', 1267 req), 1268 timeout=t) 1269 except Exception as e: 1270 if self.parent.shouldRetry(tries, e, deadline): 1271 tries += 1 1272 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1273 continue 1274 raise plumbing.convert_error_to_porcelain(e) from e 1275 break 1276 1277 resp = models.AccountGroupCreateResponse() 1278 resp.account_group = plumbing.convert_account_group_to_porcelain( 1279 plumbing_response.account_group) 1280 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1281 plumbing_response.rate_limit) 1282 return resp 1283 1284 def get(self, id, timeout=None): 1285 ''' 1286 Get reads one AccountGroup by ID. 1287 ''' 1288 deadline = None if timeout is None else time.time() + timeout 1289 req = AccountGroupGetRequest() 1290 if self.parent.snapshot_datetime is not None: 1291 req.meta.CopyFrom(GetRequestMetadata()) 1292 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1293 1294 req.id = (id) 1295 tries = 0 1296 plumbing_response = None 1297 while True: 1298 t = None if deadline is None else deadline - time.time() 1299 try: 1300 plumbing_response = self.stub.Get( 1301 req, 1302 metadata=self.parent.get_metadata('AccountsGroups.Get', 1303 req), 1304 timeout=t) 1305 except Exception as e: 1306 if self.parent.shouldRetry(tries, e, deadline): 1307 tries += 1 1308 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1309 continue 1310 raise plumbing.convert_error_to_porcelain(e) from e 1311 break 1312 1313 resp = models.AccountGroupGetResponse() 1314 resp.account_group = plumbing.convert_account_group_to_porcelain( 1315 plumbing_response.account_group) 1316 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1317 plumbing_response.meta) 1318 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1319 plumbing_response.rate_limit) 1320 return resp 1321 1322 def delete(self, id, timeout=None): 1323 ''' 1324 Delete removes an AccountGroup by ID. 1325 ''' 1326 deadline = None if timeout is None else time.time() + timeout 1327 req = AccountGroupDeleteRequest() 1328 1329 req.id = (id) 1330 tries = 0 1331 plumbing_response = None 1332 while True: 1333 t = None if deadline is None else deadline - time.time() 1334 try: 1335 plumbing_response = self.stub.Delete( 1336 req, 1337 metadata=self.parent.get_metadata('AccountsGroups.Delete', 1338 req), 1339 timeout=t) 1340 except Exception as e: 1341 if self.parent.shouldRetry(tries, e, deadline): 1342 tries += 1 1343 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1344 continue 1345 raise plumbing.convert_error_to_porcelain(e) from e 1346 break 1347 1348 resp = models.AccountGroupDeleteResponse() 1349 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 1350 plumbing_response.meta) 1351 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1352 plumbing_response.rate_limit) 1353 return resp 1354 1355 def list(self, filter, *args, timeout=None): 1356 ''' 1357 List gets a list of AccountGroups matching a given set of criteria. 1358 ''' 1359 deadline = None if timeout is None else time.time() + timeout 1360 req = AccountGroupListRequest() 1361 req.meta.CopyFrom(ListRequestMetadata()) 1362 if self.parent.page_limit > 0: 1363 req.meta.limit = self.parent.page_limit 1364 if self.parent.snapshot_datetime is not None: 1365 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1366 1367 req.filter = plumbing.quote_filter_args(filter, *args) 1368 1369 def generator(svc, req): 1370 tries = 0 1371 while True: 1372 t = None if deadline is None else deadline - time.time() 1373 try: 1374 plumbing_response = svc.stub.List( 1375 req, 1376 metadata=svc.parent.get_metadata( 1377 'AccountsGroups.List', req), 1378 timeout=t) 1379 except Exception as e: 1380 if self.parent.shouldRetry(tries, e, deadline): 1381 tries += 1 1382 time.sleep( 1383 self.parent.exponentialBackoff(tries, deadline)) 1384 continue 1385 raise plumbing.convert_error_to_porcelain(e) from e 1386 tries = 0 1387 for plumbing_item in plumbing_response.account_groups: 1388 yield plumbing.convert_account_group_to_porcelain( 1389 plumbing_item) 1390 if plumbing_response.meta.next_cursor == '': 1391 break 1392 req.meta.cursor = plumbing_response.meta.next_cursor 1393 1394 return generator(self, req) 1395 1396 1397class SnapshotAccountsGroups: 1398 ''' 1399 SnapshotAccountsGroups exposes the read only methods of the AccountsGroups 1400 service for historical queries. 1401 ''' 1402 def __init__(self, accounts_groups): 1403 self.accounts_groups = accounts_groups 1404 1405 def get(self, id, timeout=None): 1406 ''' 1407 Get reads one AccountGroup by ID. 1408 ''' 1409 return self.accounts_groups.get(id, timeout=timeout) 1410 1411 def list(self, filter, *args, timeout=None): 1412 ''' 1413 List gets a list of AccountGroups matching a given set of criteria. 1414 ''' 1415 return self.accounts_groups.list(filter, *args, timeout=timeout) 1416 1417 1418class AccountsGroupsHistory: 1419 ''' 1420 AccountsGroupsHistory records all changes to the state of an AccountGroup. 1421 See `strongdm.models.AccountGroupHistory`. 1422 ''' 1423 def __init__(self, channel, client): 1424 self.parent = client 1425 self.stub = AccountsGroupsHistoryStub(channel) 1426 1427 def list(self, filter, *args, timeout=None): 1428 ''' 1429 List gets a list of AccountGroupHistory records matching a given set of criteria. 1430 ''' 1431 deadline = None if timeout is None else time.time() + timeout 1432 req = AccountGroupHistoryListRequest() 1433 req.meta.CopyFrom(ListRequestMetadata()) 1434 if self.parent.page_limit > 0: 1435 req.meta.limit = self.parent.page_limit 1436 if self.parent.snapshot_datetime is not None: 1437 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1438 1439 req.filter = plumbing.quote_filter_args(filter, *args) 1440 1441 def generator(svc, req): 1442 tries = 0 1443 while True: 1444 t = None if deadline is None else deadline - time.time() 1445 try: 1446 plumbing_response = svc.stub.List( 1447 req, 1448 metadata=svc.parent.get_metadata( 1449 'AccountsGroupsHistory.List', req), 1450 timeout=t) 1451 except Exception as e: 1452 if self.parent.shouldRetry(tries, e, deadline): 1453 tries += 1 1454 time.sleep( 1455 self.parent.exponentialBackoff(tries, deadline)) 1456 continue 1457 raise plumbing.convert_error_to_porcelain(e) from e 1458 tries = 0 1459 for plumbing_item in plumbing_response.history: 1460 yield plumbing.convert_account_group_history_to_porcelain( 1461 plumbing_item) 1462 if plumbing_response.meta.next_cursor == '': 1463 break 1464 req.meta.cursor = plumbing_response.meta.next_cursor 1465 1466 return generator(self, req) 1467 1468 1469class AccountsHistory: 1470 ''' 1471 AccountsHistory records all changes to the state of an Account. 1472 See `strongdm.models.AccountHistory`. 1473 ''' 1474 def __init__(self, channel, client): 1475 self.parent = client 1476 self.stub = AccountsHistoryStub(channel) 1477 1478 def list(self, filter, *args, timeout=None): 1479 ''' 1480 List gets a list of AccountHistory records matching a given set of criteria. 1481 ''' 1482 deadline = None if timeout is None else time.time() + timeout 1483 req = AccountHistoryListRequest() 1484 req.meta.CopyFrom(ListRequestMetadata()) 1485 if self.parent.page_limit > 0: 1486 req.meta.limit = self.parent.page_limit 1487 if self.parent.snapshot_datetime is not None: 1488 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1489 1490 req.filter = plumbing.quote_filter_args(filter, *args) 1491 1492 def generator(svc, req): 1493 tries = 0 1494 while True: 1495 t = None if deadline is None else deadline - time.time() 1496 try: 1497 plumbing_response = svc.stub.List( 1498 req, 1499 metadata=svc.parent.get_metadata( 1500 'AccountsHistory.List', req), 1501 timeout=t) 1502 except Exception as e: 1503 if self.parent.shouldRetry(tries, e, deadline): 1504 tries += 1 1505 time.sleep( 1506 self.parent.exponentialBackoff(tries, deadline)) 1507 continue 1508 raise plumbing.convert_error_to_porcelain(e) from e 1509 tries = 0 1510 for plumbing_item in plumbing_response.history: 1511 yield plumbing.convert_account_history_to_porcelain( 1512 plumbing_item) 1513 if plumbing_response.meta.next_cursor == '': 1514 break 1515 req.meta.cursor = plumbing_response.meta.next_cursor 1516 1517 return generator(self, req) 1518 1519 1520class Activities: 1521 ''' 1522 An Activity is a record of an action taken against a strongDM deployment, e.g. 1523 a user creation, resource deletion, sso configuration change, etc. The Activities 1524 service is read-only. 1525 See `strongdm.models.Activity`. 1526 ''' 1527 def __init__(self, channel, client): 1528 self.parent = client 1529 self.stub = ActivitiesStub(channel) 1530 1531 def get(self, id, timeout=None): 1532 ''' 1533 Get reads one Activity by ID. 1534 ''' 1535 deadline = None if timeout is None else time.time() + timeout 1536 req = ActivityGetRequest() 1537 if self.parent.snapshot_datetime is not None: 1538 req.meta.CopyFrom(GetRequestMetadata()) 1539 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1540 1541 req.id = (id) 1542 tries = 0 1543 plumbing_response = None 1544 while True: 1545 t = None if deadline is None else deadline - time.time() 1546 try: 1547 plumbing_response = self.stub.Get( 1548 req, 1549 metadata=self.parent.get_metadata('Activities.Get', req), 1550 timeout=t) 1551 except Exception as e: 1552 if self.parent.shouldRetry(tries, e, deadline): 1553 tries += 1 1554 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1555 continue 1556 raise plumbing.convert_error_to_porcelain(e) from e 1557 break 1558 1559 resp = models.ActivityGetResponse() 1560 resp.activity = plumbing.convert_activity_to_porcelain( 1561 plumbing_response.activity) 1562 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1563 plumbing_response.meta) 1564 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1565 plumbing_response.rate_limit) 1566 return resp 1567 1568 def list(self, filter, *args, timeout=None): 1569 ''' 1570 List gets a list of Activities matching a given set of criteria. 1571 The 'before' and 'after' filters can be used to control the time 1572 range of the output activities. If not provided, one week of back 1573 of activities will be returned. 1574 ''' 1575 deadline = None if timeout is None else time.time() + timeout 1576 req = ActivityListRequest() 1577 req.meta.CopyFrom(ListRequestMetadata()) 1578 if self.parent.page_limit > 0: 1579 req.meta.limit = self.parent.page_limit 1580 if self.parent.snapshot_datetime is not None: 1581 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1582 1583 req.filter = plumbing.quote_filter_args(filter, *args) 1584 1585 def generator(svc, req): 1586 tries = 0 1587 while True: 1588 t = None if deadline is None else deadline - time.time() 1589 try: 1590 plumbing_response = svc.stub.List( 1591 req, 1592 metadata=svc.parent.get_metadata( 1593 'Activities.List', req), 1594 timeout=t) 1595 except Exception as e: 1596 if self.parent.shouldRetry(tries, e, deadline): 1597 tries += 1 1598 time.sleep( 1599 self.parent.exponentialBackoff(tries, deadline)) 1600 continue 1601 raise plumbing.convert_error_to_porcelain(e) from e 1602 tries = 0 1603 for plumbing_item in plumbing_response.activities: 1604 yield plumbing.convert_activity_to_porcelain(plumbing_item) 1605 if plumbing_response.meta.next_cursor == '': 1606 break 1607 req.meta.cursor = plumbing_response.meta.next_cursor 1608 1609 return generator(self, req) 1610 1611 1612class ApprovalWorkflowApprovers: 1613 ''' 1614 ApprovalWorkflowApprovers link approval workflow approvers to an ApprovalWorkflowStep 1615 See `strongdm.models.ApprovalWorkflowApprover`. 1616 ''' 1617 def __init__(self, channel, client): 1618 self.parent = client 1619 self.stub = ApprovalWorkflowApproversStub(channel) 1620 1621 def create(self, approval_workflow_approver, timeout=None): 1622 ''' 1623 Deprecated: Create creates a new approval workflow approver. 1624 ''' 1625 deadline = None if timeout is None else time.time() + timeout 1626 req = ApprovalWorkflowApproverCreateRequest() 1627 1628 if approval_workflow_approver is not None: 1629 req.approval_workflow_approver.CopyFrom( 1630 plumbing.convert_approval_workflow_approver_to_plumbing( 1631 approval_workflow_approver)) 1632 tries = 0 1633 plumbing_response = None 1634 while True: 1635 t = None if deadline is None else deadline - time.time() 1636 try: 1637 plumbing_response = self.stub.Create( 1638 req, 1639 metadata=self.parent.get_metadata( 1640 'ApprovalWorkflowApprovers.Create', req), 1641 timeout=t) 1642 except Exception as e: 1643 if self.parent.shouldRetry(tries, e, deadline): 1644 tries += 1 1645 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1646 continue 1647 raise plumbing.convert_error_to_porcelain(e) from e 1648 break 1649 1650 resp = models.ApprovalWorkflowApproverCreateResponse() 1651 resp.approval_workflow_approver = plumbing.convert_approval_workflow_approver_to_porcelain( 1652 plumbing_response.approval_workflow_approver) 1653 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1654 plumbing_response.rate_limit) 1655 return resp 1656 1657 def get(self, id, timeout=None): 1658 ''' 1659 Deprecated: Get reads one approval workflow approver by ID. 1660 ''' 1661 deadline = None if timeout is None else time.time() + timeout 1662 req = ApprovalWorkflowApproverGetRequest() 1663 if self.parent.snapshot_datetime is not None: 1664 req.meta.CopyFrom(GetRequestMetadata()) 1665 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1666 1667 req.id = (id) 1668 tries = 0 1669 plumbing_response = None 1670 while True: 1671 t = None if deadline is None else deadline - time.time() 1672 try: 1673 plumbing_response = self.stub.Get( 1674 req, 1675 metadata=self.parent.get_metadata( 1676 'ApprovalWorkflowApprovers.Get', req), 1677 timeout=t) 1678 except Exception as e: 1679 if self.parent.shouldRetry(tries, e, deadline): 1680 tries += 1 1681 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1682 continue 1683 raise plumbing.convert_error_to_porcelain(e) from e 1684 break 1685 1686 resp = models.ApprovalWorkflowApproverGetResponse() 1687 resp.approval_workflow_approver = plumbing.convert_approval_workflow_approver_to_porcelain( 1688 plumbing_response.approval_workflow_approver) 1689 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1690 plumbing_response.meta) 1691 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1692 plumbing_response.rate_limit) 1693 return resp 1694 1695 def delete(self, id, timeout=None): 1696 ''' 1697 Deprecated: Delete deletes an existing approval workflow approver. 1698 ''' 1699 deadline = None if timeout is None else time.time() + timeout 1700 req = ApprovalWorkflowApproverDeleteRequest() 1701 1702 req.id = (id) 1703 tries = 0 1704 plumbing_response = None 1705 while True: 1706 t = None if deadline is None else deadline - time.time() 1707 try: 1708 plumbing_response = self.stub.Delete( 1709 req, 1710 metadata=self.parent.get_metadata( 1711 'ApprovalWorkflowApprovers.Delete', req), 1712 timeout=t) 1713 except Exception as e: 1714 if self.parent.shouldRetry(tries, e, deadline): 1715 tries += 1 1716 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1717 continue 1718 raise plumbing.convert_error_to_porcelain(e) from e 1719 break 1720 1721 resp = models.ApprovalWorkflowApproverDeleteResponse() 1722 resp.id = (plumbing_response.id) 1723 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1724 plumbing_response.rate_limit) 1725 return resp 1726 1727 def list(self, filter, *args, timeout=None): 1728 ''' 1729 Deprecated: Lists existing approval workflow approvers. 1730 ''' 1731 deadline = None if timeout is None else time.time() + timeout 1732 req = ApprovalWorkflowApproverListRequest() 1733 req.meta.CopyFrom(ListRequestMetadata()) 1734 if self.parent.page_limit > 0: 1735 req.meta.limit = self.parent.page_limit 1736 if self.parent.snapshot_datetime is not None: 1737 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1738 1739 req.filter = plumbing.quote_filter_args(filter, *args) 1740 1741 def generator(svc, req): 1742 tries = 0 1743 while True: 1744 t = None if deadline is None else deadline - time.time() 1745 try: 1746 plumbing_response = svc.stub.List( 1747 req, 1748 metadata=svc.parent.get_metadata( 1749 'ApprovalWorkflowApprovers.List', req), 1750 timeout=t) 1751 except Exception as e: 1752 if self.parent.shouldRetry(tries, e, deadline): 1753 tries += 1 1754 time.sleep( 1755 self.parent.exponentialBackoff(tries, deadline)) 1756 continue 1757 raise plumbing.convert_error_to_porcelain(e) from e 1758 tries = 0 1759 for plumbing_item in plumbing_response.approval_workflow_approvers: 1760 yield plumbing.convert_approval_workflow_approver_to_porcelain( 1761 plumbing_item) 1762 if plumbing_response.meta.next_cursor == '': 1763 break 1764 req.meta.cursor = plumbing_response.meta.next_cursor 1765 1766 return generator(self, req) 1767 1768 1769class SnapshotApprovalWorkflowApprovers: 1770 ''' 1771 SnapshotApprovalWorkflowApprovers exposes the read only methods of the ApprovalWorkflowApprovers 1772 service for historical queries. 1773 ''' 1774 def __init__(self, approval_workflow_approvers): 1775 self.approval_workflow_approvers = approval_workflow_approvers 1776 1777 def get(self, id, timeout=None): 1778 ''' 1779 Deprecated: Get reads one approval workflow approver by ID. 1780 ''' 1781 return self.approval_workflow_approvers.get(id, timeout=timeout) 1782 1783 def list(self, filter, *args, timeout=None): 1784 ''' 1785 Deprecated: Lists existing approval workflow approvers. 1786 ''' 1787 return self.approval_workflow_approvers.list(filter, 1788 *args, 1789 timeout=timeout) 1790 1791 1792class ApprovalWorkflowApproversHistory: 1793 ''' 1794 ApprovalWorkflowApproversHistory records all changes to the state of an ApprovalWorkflowApprover. 1795 See `strongdm.models.ApprovalWorkflowApproverHistory`. 1796 ''' 1797 def __init__(self, channel, client): 1798 self.parent = client 1799 self.stub = ApprovalWorkflowApproversHistoryStub(channel) 1800 1801 def list(self, filter, *args, timeout=None): 1802 ''' 1803 List gets a list of ApprovalWorkflowApproverHistory records matching a given set of criteria. 1804 ''' 1805 deadline = None if timeout is None else time.time() + timeout 1806 req = ApprovalWorkflowApproverHistoryListRequest() 1807 req.meta.CopyFrom(ListRequestMetadata()) 1808 if self.parent.page_limit > 0: 1809 req.meta.limit = self.parent.page_limit 1810 if self.parent.snapshot_datetime is not None: 1811 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1812 1813 req.filter = plumbing.quote_filter_args(filter, *args) 1814 1815 def generator(svc, req): 1816 tries = 0 1817 while True: 1818 t = None if deadline is None else deadline - time.time() 1819 try: 1820 plumbing_response = svc.stub.List( 1821 req, 1822 metadata=svc.parent.get_metadata( 1823 'ApprovalWorkflowApproversHistory.List', req), 1824 timeout=t) 1825 except Exception as e: 1826 if self.parent.shouldRetry(tries, e, deadline): 1827 tries += 1 1828 time.sleep( 1829 self.parent.exponentialBackoff(tries, deadline)) 1830 continue 1831 raise plumbing.convert_error_to_porcelain(e) from e 1832 tries = 0 1833 for plumbing_item in plumbing_response.history: 1834 yield plumbing.convert_approval_workflow_approver_history_to_porcelain( 1835 plumbing_item) 1836 if plumbing_response.meta.next_cursor == '': 1837 break 1838 req.meta.cursor = plumbing_response.meta.next_cursor 1839 1840 return generator(self, req) 1841 1842 1843class ApprovalWorkflowSteps: 1844 ''' 1845 ApprovalWorkflowSteps link approval workflow steps to an ApprovalWorkflow 1846 See `strongdm.models.ApprovalWorkflowStep`. 1847 ''' 1848 def __init__(self, channel, client): 1849 self.parent = client 1850 self.stub = ApprovalWorkflowStepsStub(channel) 1851 1852 def create(self, approval_workflow_step, timeout=None): 1853 ''' 1854 Deprecated: Create creates a new approval workflow step. 1855 ''' 1856 deadline = None if timeout is None else time.time() + timeout 1857 req = ApprovalWorkflowStepCreateRequest() 1858 1859 if approval_workflow_step is not None: 1860 req.approval_workflow_step.CopyFrom( 1861 plumbing.convert_approval_workflow_step_to_plumbing( 1862 approval_workflow_step)) 1863 tries = 0 1864 plumbing_response = None 1865 while True: 1866 t = None if deadline is None else deadline - time.time() 1867 try: 1868 plumbing_response = self.stub.Create( 1869 req, 1870 metadata=self.parent.get_metadata( 1871 'ApprovalWorkflowSteps.Create', req), 1872 timeout=t) 1873 except Exception as e: 1874 if self.parent.shouldRetry(tries, e, deadline): 1875 tries += 1 1876 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1877 continue 1878 raise plumbing.convert_error_to_porcelain(e) from e 1879 break 1880 1881 resp = models.ApprovalWorkflowStepCreateResponse() 1882 resp.approval_workflow_step = plumbing.convert_approval_workflow_step_to_porcelain( 1883 plumbing_response.approval_workflow_step) 1884 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1885 plumbing_response.rate_limit) 1886 return resp 1887 1888 def get(self, id, timeout=None): 1889 ''' 1890 Deprecated: Get reads one approval workflow step by ID. 1891 ''' 1892 deadline = None if timeout is None else time.time() + timeout 1893 req = ApprovalWorkflowStepGetRequest() 1894 if self.parent.snapshot_datetime is not None: 1895 req.meta.CopyFrom(GetRequestMetadata()) 1896 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1897 1898 req.id = (id) 1899 tries = 0 1900 plumbing_response = None 1901 while True: 1902 t = None if deadline is None else deadline - time.time() 1903 try: 1904 plumbing_response = self.stub.Get( 1905 req, 1906 metadata=self.parent.get_metadata( 1907 'ApprovalWorkflowSteps.Get', req), 1908 timeout=t) 1909 except Exception as e: 1910 if self.parent.shouldRetry(tries, e, deadline): 1911 tries += 1 1912 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1913 continue 1914 raise plumbing.convert_error_to_porcelain(e) from e 1915 break 1916 1917 resp = models.ApprovalWorkflowStepGetResponse() 1918 resp.approval_workflow_step = plumbing.convert_approval_workflow_step_to_porcelain( 1919 plumbing_response.approval_workflow_step) 1920 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1921 plumbing_response.meta) 1922 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1923 plumbing_response.rate_limit) 1924 return resp 1925 1926 def delete(self, id, timeout=None): 1927 ''' 1928 Deprecated: Delete deletes an existing approval workflow step. 1929 ''' 1930 deadline = None if timeout is None else time.time() + timeout 1931 req = ApprovalWorkflowStepDeleteRequest() 1932 1933 req.id = (id) 1934 tries = 0 1935 plumbing_response = None 1936 while True: 1937 t = None if deadline is None else deadline - time.time() 1938 try: 1939 plumbing_response = self.stub.Delete( 1940 req, 1941 metadata=self.parent.get_metadata( 1942 'ApprovalWorkflowSteps.Delete', req), 1943 timeout=t) 1944 except Exception as e: 1945 if self.parent.shouldRetry(tries, e, deadline): 1946 tries += 1 1947 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1948 continue 1949 raise plumbing.convert_error_to_porcelain(e) from e 1950 break 1951 1952 resp = models.ApprovalWorkflowStepDeleteResponse() 1953 resp.id = (plumbing_response.id) 1954 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1955 plumbing_response.rate_limit) 1956 return resp 1957 1958 def list(self, filter, *args, timeout=None): 1959 ''' 1960 Deprecated: Lists existing approval workflow steps. 1961 ''' 1962 deadline = None if timeout is None else time.time() + timeout 1963 req = ApprovalWorkflowStepListRequest() 1964 req.meta.CopyFrom(ListRequestMetadata()) 1965 if self.parent.page_limit > 0: 1966 req.meta.limit = self.parent.page_limit 1967 if self.parent.snapshot_datetime is not None: 1968 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1969 1970 req.filter = plumbing.quote_filter_args(filter, *args) 1971 1972 def generator(svc, req): 1973 tries = 0 1974 while True: 1975 t = None if deadline is None else deadline - time.time() 1976 try: 1977 plumbing_response = svc.stub.List( 1978 req, 1979 metadata=svc.parent.get_metadata( 1980 'ApprovalWorkflowSteps.List', req), 1981 timeout=t) 1982 except Exception as e: 1983 if self.parent.shouldRetry(tries, e, deadline): 1984 tries += 1 1985 time.sleep( 1986 self.parent.exponentialBackoff(tries, deadline)) 1987 continue 1988 raise plumbing.convert_error_to_porcelain(e) from e 1989 tries = 0 1990 for plumbing_item in plumbing_response.approval_workflow_steps: 1991 yield plumbing.convert_approval_workflow_step_to_porcelain( 1992 plumbing_item) 1993 if plumbing_response.meta.next_cursor == '': 1994 break 1995 req.meta.cursor = plumbing_response.meta.next_cursor 1996 1997 return generator(self, req) 1998 1999 2000class SnapshotApprovalWorkflowSteps: 2001 ''' 2002 SnapshotApprovalWorkflowSteps exposes the read only methods of the ApprovalWorkflowSteps 2003 service for historical queries. 2004 ''' 2005 def __init__(self, approval_workflow_steps): 2006 self.approval_workflow_steps = approval_workflow_steps 2007 2008 def get(self, id, timeout=None): 2009 ''' 2010 Deprecated: Get reads one approval workflow step by ID. 2011 ''' 2012 return self.approval_workflow_steps.get(id, timeout=timeout) 2013 2014 def list(self, filter, *args, timeout=None): 2015 ''' 2016 Deprecated: Lists existing approval workflow steps. 2017 ''' 2018 return self.approval_workflow_steps.list(filter, 2019 *args, 2020 timeout=timeout) 2021 2022 2023class ApprovalWorkflowStepsHistory: 2024 ''' 2025 ApprovalWorkflowStepsHistory records all changes to the state of an ApprovalWorkflowStep. 2026 See `strongdm.models.ApprovalWorkflowStepHistory`. 2027 ''' 2028 def __init__(self, channel, client): 2029 self.parent = client 2030 self.stub = ApprovalWorkflowStepsHistoryStub(channel) 2031 2032 def list(self, filter, *args, timeout=None): 2033 ''' 2034 List gets a list of ApprovalWorkflowStepHistory records matching a given set of criteria. 2035 ''' 2036 deadline = None if timeout is None else time.time() + timeout 2037 req = ApprovalWorkflowStepHistoryListRequest() 2038 req.meta.CopyFrom(ListRequestMetadata()) 2039 if self.parent.page_limit > 0: 2040 req.meta.limit = self.parent.page_limit 2041 if self.parent.snapshot_datetime is not None: 2042 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2043 2044 req.filter = plumbing.quote_filter_args(filter, *args) 2045 2046 def generator(svc, req): 2047 tries = 0 2048 while True: 2049 t = None if deadline is None else deadline - time.time() 2050 try: 2051 plumbing_response = svc.stub.List( 2052 req, 2053 metadata=svc.parent.get_metadata( 2054 'ApprovalWorkflowStepsHistory.List', req), 2055 timeout=t) 2056 except Exception as e: 2057 if self.parent.shouldRetry(tries, e, deadline): 2058 tries += 1 2059 time.sleep( 2060 self.parent.exponentialBackoff(tries, deadline)) 2061 continue 2062 raise plumbing.convert_error_to_porcelain(e) from e 2063 tries = 0 2064 for plumbing_item in plumbing_response.history: 2065 yield plumbing.convert_approval_workflow_step_history_to_porcelain( 2066 plumbing_item) 2067 if plumbing_response.meta.next_cursor == '': 2068 break 2069 req.meta.cursor = plumbing_response.meta.next_cursor 2070 2071 return generator(self, req) 2072 2073 2074class ApprovalWorkflows: 2075 ''' 2076 ApprovalWorkflows are the mechanism by which requests for access can be viewed by authorized 2077 approvers and be approved or denied. 2078 See `strongdm.models.ApprovalWorkflow`. 2079 ''' 2080 def __init__(self, channel, client): 2081 self.parent = client 2082 self.stub = ApprovalWorkflowsStub(channel) 2083 2084 def create(self, approval_workflow, timeout=None): 2085 ''' 2086 Create creates a new approval workflow and requires a name and approval mode for the approval workflow. 2087 ''' 2088 deadline = None if timeout is None else time.time() + timeout 2089 req = ApprovalWorkflowCreateRequest() 2090 2091 if approval_workflow is not None: 2092 req.approval_workflow.CopyFrom( 2093 plumbing.convert_approval_workflow_to_plumbing( 2094 approval_workflow)) 2095 tries = 0 2096 plumbing_response = None 2097 while True: 2098 t = None if deadline is None else deadline - time.time() 2099 try: 2100 plumbing_response = self.stub.Create( 2101 req, 2102 metadata=self.parent.get_metadata( 2103 'ApprovalWorkflows.Create', req), 2104 timeout=t) 2105 except Exception as e: 2106 if self.parent.shouldRetry(tries, e, deadline): 2107 tries += 1 2108 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2109 continue 2110 raise plumbing.convert_error_to_porcelain(e) from e 2111 break 2112 2113 resp = models.ApprovalWorkflowCreateResponse() 2114 resp.approval_workflow = plumbing.convert_approval_workflow_to_porcelain( 2115 plumbing_response.approval_workflow) 2116 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2117 plumbing_response.rate_limit) 2118 return resp 2119 2120 def get(self, id, timeout=None): 2121 ''' 2122 Get reads one approval workflow by ID. 2123 ''' 2124 deadline = None if timeout is None else time.time() + timeout 2125 req = ApprovalWorkflowGetRequest() 2126 if self.parent.snapshot_datetime is not None: 2127 req.meta.CopyFrom(GetRequestMetadata()) 2128 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2129 2130 req.id = (id) 2131 tries = 0 2132 plumbing_response = None 2133 while True: 2134 t = None if deadline is None else deadline - time.time() 2135 try: 2136 plumbing_response = self.stub.Get( 2137 req, 2138 metadata=self.parent.get_metadata('ApprovalWorkflows.Get', 2139 req), 2140 timeout=t) 2141 except Exception as e: 2142 if self.parent.shouldRetry(tries, e, deadline): 2143 tries += 1 2144 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2145 continue 2146 raise plumbing.convert_error_to_porcelain(e) from e 2147 break 2148 2149 resp = models.ApprovalWorkflowGetResponse() 2150 resp.approval_workflow = plumbing.convert_approval_workflow_to_porcelain( 2151 plumbing_response.approval_workflow) 2152 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2153 plumbing_response.meta) 2154 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2155 plumbing_response.rate_limit) 2156 return resp 2157 2158 def delete(self, id, timeout=None): 2159 ''' 2160 Delete deletes an existing approval workflow. 2161 ''' 2162 deadline = None if timeout is None else time.time() + timeout 2163 req = ApprovalWorkflowDeleteRequest() 2164 2165 req.id = (id) 2166 tries = 0 2167 plumbing_response = None 2168 while True: 2169 t = None if deadline is None else deadline - time.time() 2170 try: 2171 plumbing_response = self.stub.Delete( 2172 req, 2173 metadata=self.parent.get_metadata( 2174 'ApprovalWorkflows.Delete', req), 2175 timeout=t) 2176 except Exception as e: 2177 if self.parent.shouldRetry(tries, e, deadline): 2178 tries += 1 2179 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2180 continue 2181 raise plumbing.convert_error_to_porcelain(e) from e 2182 break 2183 2184 resp = models.ApprovalWorkflowDeleteResponse() 2185 resp.id = (plumbing_response.id) 2186 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2187 plumbing_response.rate_limit) 2188 return resp 2189 2190 def update(self, approval_workflow, timeout=None): 2191 ''' 2192 Update updates an existing approval workflow. 2193 ''' 2194 deadline = None if timeout is None else time.time() + timeout 2195 req = ApprovalWorkflowUpdateRequest() 2196 2197 if approval_workflow is not None: 2198 req.approval_workflow.CopyFrom( 2199 plumbing.convert_approval_workflow_to_plumbing( 2200 approval_workflow)) 2201 tries = 0 2202 plumbing_response = None 2203 while True: 2204 t = None if deadline is None else deadline - time.time() 2205 try: 2206 plumbing_response = self.stub.Update( 2207 req, 2208 metadata=self.parent.get_metadata( 2209 'ApprovalWorkflows.Update', req), 2210 timeout=t) 2211 except Exception as e: 2212 if self.parent.shouldRetry(tries, e, deadline): 2213 tries += 1 2214 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2215 continue 2216 raise plumbing.convert_error_to_porcelain(e) from e 2217 break 2218 2219 resp = models.ApprovalWorkflowUpdateResponse() 2220 resp.approval_workflow = plumbing.convert_approval_workflow_to_porcelain( 2221 plumbing_response.approval_workflow) 2222 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2223 plumbing_response.rate_limit) 2224 return resp 2225 2226 def list(self, filter, *args, timeout=None): 2227 ''' 2228 Lists existing approval workflows. 2229 ''' 2230 deadline = None if timeout is None else time.time() + timeout 2231 req = ApprovalWorkflowListRequest() 2232 req.meta.CopyFrom(ListRequestMetadata()) 2233 if self.parent.page_limit > 0: 2234 req.meta.limit = self.parent.page_limit 2235 if self.parent.snapshot_datetime is not None: 2236 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2237 2238 req.filter = plumbing.quote_filter_args(filter, *args) 2239 2240 def generator(svc, req): 2241 tries = 0 2242 while True: 2243 t = None if deadline is None else deadline - time.time() 2244 try: 2245 plumbing_response = svc.stub.List( 2246 req, 2247 metadata=svc.parent.get_metadata( 2248 'ApprovalWorkflows.List', req), 2249 timeout=t) 2250 except Exception as e: 2251 if self.parent.shouldRetry(tries, e, deadline): 2252 tries += 1 2253 time.sleep( 2254 self.parent.exponentialBackoff(tries, deadline)) 2255 continue 2256 raise plumbing.convert_error_to_porcelain(e) from e 2257 tries = 0 2258 for plumbing_item in plumbing_response.approval_workflows: 2259 yield plumbing.convert_approval_workflow_to_porcelain( 2260 plumbing_item) 2261 if plumbing_response.meta.next_cursor == '': 2262 break 2263 req.meta.cursor = plumbing_response.meta.next_cursor 2264 2265 return generator(self, req) 2266 2267 2268class SnapshotApprovalWorkflows: 2269 ''' 2270 SnapshotApprovalWorkflows exposes the read only methods of the ApprovalWorkflows 2271 service for historical queries. 2272 ''' 2273 def __init__(self, approval_workflows): 2274 self.approval_workflows = approval_workflows 2275 2276 def get(self, id, timeout=None): 2277 ''' 2278 Get reads one approval workflow by ID. 2279 ''' 2280 return self.approval_workflows.get(id, timeout=timeout) 2281 2282 def list(self, filter, *args, timeout=None): 2283 ''' 2284 Lists existing approval workflows. 2285 ''' 2286 return self.approval_workflows.list(filter, *args, timeout=timeout) 2287 2288 2289class ApprovalWorkflowsHistory: 2290 ''' 2291 ApprovalWorkflowsHistory records all changes to the state of an ApprovalWorkflow. 2292 See `strongdm.models.ApprovalWorkflowHistory`. 2293 ''' 2294 def __init__(self, channel, client): 2295 self.parent = client 2296 self.stub = ApprovalWorkflowsHistoryStub(channel) 2297 2298 def list(self, filter, *args, timeout=None): 2299 ''' 2300 List gets a list of ApprovalWorkflowHistory records matching a given set of criteria. 2301 ''' 2302 deadline = None if timeout is None else time.time() + timeout 2303 req = ApprovalWorkflowHistoryListRequest() 2304 req.meta.CopyFrom(ListRequestMetadata()) 2305 if self.parent.page_limit > 0: 2306 req.meta.limit = self.parent.page_limit 2307 if self.parent.snapshot_datetime is not None: 2308 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2309 2310 req.filter = plumbing.quote_filter_args(filter, *args) 2311 2312 def generator(svc, req): 2313 tries = 0 2314 while True: 2315 t = None if deadline is None else deadline - time.time() 2316 try: 2317 plumbing_response = svc.stub.List( 2318 req, 2319 metadata=svc.parent.get_metadata( 2320 'ApprovalWorkflowsHistory.List', req), 2321 timeout=t) 2322 except Exception as e: 2323 if self.parent.shouldRetry(tries, e, deadline): 2324 tries += 1 2325 time.sleep( 2326 self.parent.exponentialBackoff(tries, deadline)) 2327 continue 2328 raise plumbing.convert_error_to_porcelain(e) from e 2329 tries = 0 2330 for plumbing_item in plumbing_response.history: 2331 yield plumbing.convert_approval_workflow_history_to_porcelain( 2332 plumbing_item) 2333 if plumbing_response.meta.next_cursor == '': 2334 break 2335 req.meta.cursor = plumbing_response.meta.next_cursor 2336 2337 return generator(self, req) 2338 2339 2340class ControlPanel: 2341 ''' 2342 ControlPanel contains all administrative controls. 2343 ''' 2344 def __init__(self, channel, client): 2345 self.parent = client 2346 self.stub = ControlPanelStub(channel) 2347 2348 def get_sshca_public_key(self, timeout=None): 2349 ''' 2350 GetSSHCAPublicKey retrieves the SSH CA public key. 2351 ''' 2352 deadline = None if timeout is None else time.time() + timeout 2353 req = ControlPanelGetSSHCAPublicKeyRequest() 2354 2355 tries = 0 2356 plumbing_response = None 2357 while True: 2358 t = None if deadline is None else deadline - time.time() 2359 try: 2360 plumbing_response = self.stub.GetSSHCAPublicKey( 2361 req, 2362 metadata=self.parent.get_metadata( 2363 'ControlPanel.GetSSHCAPublicKey', req), 2364 timeout=t) 2365 except Exception as e: 2366 if self.parent.shouldRetry(tries, e, deadline): 2367 tries += 1 2368 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2369 continue 2370 raise plumbing.convert_error_to_porcelain(e) from e 2371 break 2372 2373 resp = models.ControlPanelGetSSHCAPublicKeyResponse() 2374 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2375 plumbing_response.meta) 2376 resp.public_key = (plumbing_response.public_key) 2377 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2378 plumbing_response.rate_limit) 2379 return resp 2380 2381 def get_rdpca_public_key(self, timeout=None): 2382 ''' 2383 GetRDPCAPublicKey retrieves the RDP CA public key. 2384 ''' 2385 deadline = None if timeout is None else time.time() + timeout 2386 req = ControlPanelGetRDPCAPublicKeyRequest() 2387 2388 tries = 0 2389 plumbing_response = None 2390 while True: 2391 t = None if deadline is None else deadline - time.time() 2392 try: 2393 plumbing_response = self.stub.GetRDPCAPublicKey( 2394 req, 2395 metadata=self.parent.get_metadata( 2396 'ControlPanel.GetRDPCAPublicKey', req), 2397 timeout=t) 2398 except Exception as e: 2399 if self.parent.shouldRetry(tries, e, deadline): 2400 tries += 1 2401 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2402 continue 2403 raise plumbing.convert_error_to_porcelain(e) from e 2404 break 2405 2406 resp = models.ControlPanelGetRDPCAPublicKeyResponse() 2407 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2408 plumbing_response.meta) 2409 resp.public_key = (plumbing_response.public_key) 2410 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2411 plumbing_response.rate_limit) 2412 return resp 2413 2414 def get_org_url_info(self, timeout=None): 2415 ''' 2416 GetOrgURLInfo retrieves URL configuration for the organization. 2417 This includes the base URL, website subdomain, OIDC issuer URL, and SAML metadata URL. 2418 ''' 2419 deadline = None if timeout is None else time.time() + timeout 2420 req = ControlPanelGetOrgURLInfoRequest() 2421 2422 tries = 0 2423 plumbing_response = None 2424 while True: 2425 t = None if deadline is None else deadline - time.time() 2426 try: 2427 plumbing_response = self.stub.GetOrgURLInfo( 2428 req, 2429 metadata=self.parent.get_metadata( 2430 'ControlPanel.GetOrgURLInfo', req), 2431 timeout=t) 2432 except Exception as e: 2433 if self.parent.shouldRetry(tries, e, deadline): 2434 tries += 1 2435 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2436 continue 2437 raise plumbing.convert_error_to_porcelain(e) from e 2438 break 2439 2440 resp = models.ControlPanelGetOrgURLInfoResponse() 2441 resp.base_url = (plumbing_response.base_url) 2442 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2443 plumbing_response.meta) 2444 resp.oidc_issuer_url = (plumbing_response.oidc_issuer_url) 2445 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2446 plumbing_response.rate_limit) 2447 resp.saml_metadata_url = (plumbing_response.saml_metadata_url) 2448 resp.websites_subdomain = (plumbing_response.websites_subdomain) 2449 return resp 2450 2451 def verify_jwt(self, token, timeout=None): 2452 ''' 2453 VerifyJWT reports whether the given JWT token (x-sdm-token) is valid. 2454 ''' 2455 deadline = None if timeout is None else time.time() + timeout 2456 req = ControlPanelVerifyJWTRequest() 2457 2458 req.token = (token) 2459 tries = 0 2460 plumbing_response = None 2461 while True: 2462 t = None if deadline is None else deadline - time.time() 2463 try: 2464 plumbing_response = self.stub.VerifyJWT( 2465 req, 2466 metadata=self.parent.get_metadata('ControlPanel.VerifyJWT', 2467 req), 2468 timeout=t) 2469 except Exception as e: 2470 if self.parent.shouldRetry(tries, e, deadline): 2471 tries += 1 2472 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2473 continue 2474 raise plumbing.convert_error_to_porcelain(e) from e 2475 break 2476 2477 resp = models.ControlPanelVerifyJWTResponse() 2478 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2479 plumbing_response.meta) 2480 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2481 plumbing_response.rate_limit) 2482 resp.valid = (plumbing_response.valid) 2483 return resp 2484 2485 2486class DiscoveryConnectors: 2487 ''' 2488 A Discovery Connector is a configuration object for performing Resource 2489 Scans in remote systems such as AWS, GCP, Azure, and other systems. 2490 See: 2491 `strongdm.models.AWSConnector` 2492 `strongdm.models.AzureConnector` 2493 `strongdm.models.GCPConnector` 2494 ''' 2495 def __init__(self, channel, client): 2496 self.parent = client 2497 self.stub = DiscoveryConnectorsStub(channel) 2498 2499 def create(self, connector, timeout=None): 2500 ''' 2501 Create adds a new Connector. 2502 ''' 2503 deadline = None if timeout is None else time.time() + timeout 2504 req = ConnectorCreateRequest() 2505 2506 if connector is not None: 2507 req.connector.CopyFrom( 2508 plumbing.convert_connector_to_plumbing(connector)) 2509 tries = 0 2510 plumbing_response = None 2511 while True: 2512 t = None if deadline is None else deadline - time.time() 2513 try: 2514 plumbing_response = self.stub.Create( 2515 req, 2516 metadata=self.parent.get_metadata( 2517 'DiscoveryConnectors.Create', req), 2518 timeout=t) 2519 except Exception as e: 2520 if self.parent.shouldRetry(tries, e, deadline): 2521 tries += 1 2522 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2523 continue 2524 raise plumbing.convert_error_to_porcelain(e) from e 2525 break 2526 2527 resp = models.ConnectorCreateResponse() 2528 resp.connector = plumbing.convert_connector_to_porcelain( 2529 plumbing_response.connector) 2530 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2531 plumbing_response.rate_limit) 2532 return resp 2533 2534 def get(self, id, timeout=None): 2535 ''' 2536 Get reads one Connector by ID 2537 ''' 2538 deadline = None if timeout is None else time.time() + timeout 2539 req = ConnectorGetRequest() 2540 if self.parent.snapshot_datetime is not None: 2541 req.meta.CopyFrom(GetRequestMetadata()) 2542 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2543 2544 req.id = (id) 2545 tries = 0 2546 plumbing_response = None 2547 while True: 2548 t = None if deadline is None else deadline - time.time() 2549 try: 2550 plumbing_response = self.stub.Get( 2551 req, 2552 metadata=self.parent.get_metadata( 2553 'DiscoveryConnectors.Get', req), 2554 timeout=t) 2555 except Exception as e: 2556 if self.parent.shouldRetry(tries, e, deadline): 2557 tries += 1 2558 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2559 continue 2560 raise plumbing.convert_error_to_porcelain(e) from e 2561 break 2562 2563 resp = models.ConnectorGetResponse() 2564 resp.connector = plumbing.convert_connector_to_porcelain( 2565 plumbing_response.connector) 2566 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2567 plumbing_response.meta) 2568 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2569 plumbing_response.rate_limit) 2570 return resp 2571 2572 def update(self, connector, timeout=None): 2573 ''' 2574 Update replaces all the fields of a Connector by ID. 2575 ''' 2576 deadline = None if timeout is None else time.time() + timeout 2577 req = ConnectorUpdateRequest() 2578 2579 if connector is not None: 2580 req.connector.CopyFrom( 2581 plumbing.convert_connector_to_plumbing(connector)) 2582 tries = 0 2583 plumbing_response = None 2584 while True: 2585 t = None if deadline is None else deadline - time.time() 2586 try: 2587 plumbing_response = self.stub.Update( 2588 req, 2589 metadata=self.parent.get_metadata( 2590 'DiscoveryConnectors.Update', req), 2591 timeout=t) 2592 except Exception as e: 2593 if self.parent.shouldRetry(tries, e, deadline): 2594 tries += 1 2595 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2596 continue 2597 raise plumbing.convert_error_to_porcelain(e) from e 2598 break 2599 2600 resp = models.ConnectorUpdateResponse() 2601 resp.connector = plumbing.convert_connector_to_porcelain( 2602 plumbing_response.connector) 2603 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2604 plumbing_response.rate_limit) 2605 return resp 2606 2607 def delete(self, id, timeout=None): 2608 ''' 2609 Delete removes a Connector by ID. 2610 ''' 2611 deadline = None if timeout is None else time.time() + timeout 2612 req = ConnectorDeleteRequest() 2613 2614 req.id = (id) 2615 tries = 0 2616 plumbing_response = None 2617 while True: 2618 t = None if deadline is None else deadline - time.time() 2619 try: 2620 plumbing_response = self.stub.Delete( 2621 req, 2622 metadata=self.parent.get_metadata( 2623 'DiscoveryConnectors.Delete', req), 2624 timeout=t) 2625 except Exception as e: 2626 if self.parent.shouldRetry(tries, e, deadline): 2627 tries += 1 2628 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2629 continue 2630 raise plumbing.convert_error_to_porcelain(e) from e 2631 break 2632 2633 resp = models.ConnectorDeleteResponse() 2634 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 2635 plumbing_response.meta) 2636 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2637 plumbing_response.rate_limit) 2638 return resp 2639 2640 def list(self, filter, *args, timeout=None): 2641 ''' 2642 List gets a list of Connectors matching a given set of criteria. 2643 ''' 2644 deadline = None if timeout is None else time.time() + timeout 2645 req = ConnectorListRequest() 2646 req.meta.CopyFrom(ListRequestMetadata()) 2647 if self.parent.page_limit > 0: 2648 req.meta.limit = self.parent.page_limit 2649 if self.parent.snapshot_datetime is not None: 2650 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2651 2652 req.filter = plumbing.quote_filter_args(filter, *args) 2653 2654 def generator(svc, req): 2655 tries = 0 2656 while True: 2657 t = None if deadline is None else deadline - time.time() 2658 try: 2659 plumbing_response = svc.stub.List( 2660 req, 2661 metadata=svc.parent.get_metadata( 2662 'DiscoveryConnectors.List', req), 2663 timeout=t) 2664 except Exception as e: 2665 if self.parent.shouldRetry(tries, e, deadline): 2666 tries += 1 2667 time.sleep( 2668 self.parent.exponentialBackoff(tries, deadline)) 2669 continue 2670 raise plumbing.convert_error_to_porcelain(e) from e 2671 tries = 0 2672 for plumbing_item in plumbing_response.connectors: 2673 yield plumbing.convert_connector_to_porcelain( 2674 plumbing_item) 2675 if plumbing_response.meta.next_cursor == '': 2676 break 2677 req.meta.cursor = plumbing_response.meta.next_cursor 2678 2679 return generator(self, req) 2680 2681 2682class SnapshotDiscoveryConnectors: 2683 ''' 2684 SnapshotDiscoveryConnectors exposes the read only methods of the DiscoveryConnectors 2685 service for historical queries. 2686 ''' 2687 def __init__(self, discovery_connectors): 2688 self.discovery_connectors = discovery_connectors 2689 2690 def get(self, id, timeout=None): 2691 ''' 2692 Get reads one Connector by ID 2693 ''' 2694 return self.discovery_connectors.get(id, timeout=timeout) 2695 2696 def list(self, filter, *args, timeout=None): 2697 ''' 2698 List gets a list of Connectors matching a given set of criteria. 2699 ''' 2700 return self.discovery_connectors.list(filter, *args, timeout=timeout) 2701 2702 2703class GrantedAccountEntitlements: 2704 ''' 2705 GrantedAccountEntitlements enumerates the resources to which an account has been granted access. 2706 The GrantedAccountEntitlements service is read-only. 2707 See `strongdm.models.GrantedAccountEntitlement`. 2708 ''' 2709 def __init__(self, channel, client): 2710 self.parent = client 2711 self.stub = GrantedAccountEntitlementsStub(channel) 2712 2713 def list(self, account_id, filter, *args, timeout=None): 2714 ''' 2715 List gets a list of GrantedAccountEntitlement records matching a given set of criteria. 2716 ''' 2717 deadline = None if timeout is None else time.time() + timeout 2718 req = GrantedAccountEntitlementListRequest() 2719 req.meta.CopyFrom(ListRequestMetadata()) 2720 if self.parent.page_limit > 0: 2721 req.meta.limit = self.parent.page_limit 2722 if self.parent.snapshot_datetime is not None: 2723 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2724 2725 req.account_id = (account_id) 2726 req.filter = plumbing.quote_filter_args(filter, *args) 2727 2728 def generator(svc, req): 2729 tries = 0 2730 while True: 2731 t = None if deadline is None else deadline - time.time() 2732 try: 2733 plumbing_response = svc.stub.List( 2734 req, 2735 metadata=svc.parent.get_metadata( 2736 'GrantedAccountEntitlements.List', req), 2737 timeout=t) 2738 except Exception as e: 2739 if self.parent.shouldRetry(tries, e, deadline): 2740 tries += 1 2741 time.sleep( 2742 self.parent.exponentialBackoff(tries, deadline)) 2743 continue 2744 raise plumbing.convert_error_to_porcelain(e) from e 2745 tries = 0 2746 for plumbing_item in plumbing_response.granted_account_entitlements: 2747 yield plumbing.convert_granted_account_entitlement_to_porcelain( 2748 plumbing_item) 2749 if plumbing_response.meta.next_cursor == '': 2750 break 2751 req.meta.cursor = plumbing_response.meta.next_cursor 2752 2753 return generator(self, req) 2754 2755 2756class SnapshotGrantedAccountEntitlements: 2757 ''' 2758 SnapshotGrantedAccountEntitlements exposes the read only methods of the GrantedAccountEntitlements 2759 service for historical queries. 2760 ''' 2761 def __init__(self, granted_account_entitlements): 2762 self.granted_account_entitlements = granted_account_entitlements 2763 2764 def list(self, account_id, filter, *args, timeout=None): 2765 ''' 2766 List gets a list of GrantedAccountEntitlement records matching a given set of criteria. 2767 ''' 2768 return self.granted_account_entitlements.list(account_id, 2769 filter, 2770 *args, 2771 timeout=timeout) 2772 2773 2774class GrantedResourceEntitlements: 2775 ''' 2776 GrantedResourceEntitlements enumerates the accounts that have been granted access to a given resource. 2777 The GrantedResourceEntitlements service is read-only. 2778 See `strongdm.models.GrantedResourceEntitlement`. 2779 ''' 2780 def __init__(self, channel, client): 2781 self.parent = client 2782 self.stub = GrantedResourceEntitlementsStub(channel) 2783 2784 def list(self, resource_id, filter, *args, timeout=None): 2785 ''' 2786 List gets a list of GrantedResourceEntitlement records matching a given set of criteria. 2787 ''' 2788 deadline = None if timeout is None else time.time() + timeout 2789 req = GrantedResourceEntitlementListRequest() 2790 req.meta.CopyFrom(ListRequestMetadata()) 2791 if self.parent.page_limit > 0: 2792 req.meta.limit = self.parent.page_limit 2793 if self.parent.snapshot_datetime is not None: 2794 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2795 2796 req.resource_id = (resource_id) 2797 req.filter = plumbing.quote_filter_args(filter, *args) 2798 2799 def generator(svc, req): 2800 tries = 0 2801 while True: 2802 t = None if deadline is None else deadline - time.time() 2803 try: 2804 plumbing_response = svc.stub.List( 2805 req, 2806 metadata=svc.parent.get_metadata( 2807 'GrantedResourceEntitlements.List', req), 2808 timeout=t) 2809 except Exception as e: 2810 if self.parent.shouldRetry(tries, e, deadline): 2811 tries += 1 2812 time.sleep( 2813 self.parent.exponentialBackoff(tries, deadline)) 2814 continue 2815 raise plumbing.convert_error_to_porcelain(e) from e 2816 tries = 0 2817 for plumbing_item in plumbing_response.granted_resource_entitlements: 2818 yield plumbing.convert_granted_resource_entitlement_to_porcelain( 2819 plumbing_item) 2820 if plumbing_response.meta.next_cursor == '': 2821 break 2822 req.meta.cursor = plumbing_response.meta.next_cursor 2823 2824 return generator(self, req) 2825 2826 2827class SnapshotGrantedResourceEntitlements: 2828 ''' 2829 SnapshotGrantedResourceEntitlements exposes the read only methods of the GrantedResourceEntitlements 2830 service for historical queries. 2831 ''' 2832 def __init__(self, granted_resource_entitlements): 2833 self.granted_resource_entitlements = granted_resource_entitlements 2834 2835 def list(self, resource_id, filter, *args, timeout=None): 2836 ''' 2837 List gets a list of GrantedResourceEntitlement records matching a given set of criteria. 2838 ''' 2839 return self.granted_resource_entitlements.list(resource_id, 2840 filter, 2841 *args, 2842 timeout=timeout) 2843 2844 2845class GrantedRoleEntitlements: 2846 ''' 2847 GrantedRoleEntitlements enumerates the resources to which a role grants access. 2848 The GrantedRoleEntitlements service is read-only. 2849 See `strongdm.models.GrantedRoleEntitlement`. 2850 ''' 2851 def __init__(self, channel, client): 2852 self.parent = client 2853 self.stub = GrantedRoleEntitlementsStub(channel) 2854 2855 def list(self, role_id, filter, *args, timeout=None): 2856 ''' 2857 List gets a list of GrantedRoleEntitlement records matching a given set of criteria. 2858 ''' 2859 deadline = None if timeout is None else time.time() + timeout 2860 req = GrantedRoleEntitlementListRequest() 2861 req.meta.CopyFrom(ListRequestMetadata()) 2862 if self.parent.page_limit > 0: 2863 req.meta.limit = self.parent.page_limit 2864 if self.parent.snapshot_datetime is not None: 2865 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2866 2867 req.role_id = (role_id) 2868 req.filter = plumbing.quote_filter_args(filter, *args) 2869 2870 def generator(svc, req): 2871 tries = 0 2872 while True: 2873 t = None if deadline is None else deadline - time.time() 2874 try: 2875 plumbing_response = svc.stub.List( 2876 req, 2877 metadata=svc.parent.get_metadata( 2878 'GrantedRoleEntitlements.List', req), 2879 timeout=t) 2880 except Exception as e: 2881 if self.parent.shouldRetry(tries, e, deadline): 2882 tries += 1 2883 time.sleep( 2884 self.parent.exponentialBackoff(tries, deadline)) 2885 continue 2886 raise plumbing.convert_error_to_porcelain(e) from e 2887 tries = 0 2888 for plumbing_item in plumbing_response.granted_role_entitlements: 2889 yield plumbing.convert_granted_role_entitlement_to_porcelain( 2890 plumbing_item) 2891 if plumbing_response.meta.next_cursor == '': 2892 break 2893 req.meta.cursor = plumbing_response.meta.next_cursor 2894 2895 return generator(self, req) 2896 2897 2898class SnapshotGrantedRoleEntitlements: 2899 ''' 2900 SnapshotGrantedRoleEntitlements exposes the read only methods of the GrantedRoleEntitlements 2901 service for historical queries. 2902 ''' 2903 def __init__(self, granted_role_entitlements): 2904 self.granted_role_entitlements = granted_role_entitlements 2905 2906 def list(self, role_id, filter, *args, timeout=None): 2907 ''' 2908 List gets a list of GrantedRoleEntitlement records matching a given set of criteria. 2909 ''' 2910 return self.granted_role_entitlements.list(role_id, 2911 filter, 2912 *args, 2913 timeout=timeout) 2914 2915 2916class Roles: 2917 ''' 2918 A Role has a list of access rules which determine which Resources the members 2919 of the Role have access to. An Account can be a member of multiple Roles via 2920 AccountAttachments. 2921 See `strongdm.models.Role`. 2922 ''' 2923 def __init__(self, channel, client): 2924 self.parent = client 2925 self.stub = RolesStub(channel) 2926 2927 def create(self, role, timeout=None): 2928 ''' 2929 Create registers a new Role. 2930 ''' 2931 deadline = None if timeout is None else time.time() + timeout 2932 req = RoleCreateRequest() 2933 2934 if role is not None: 2935 req.role.CopyFrom(plumbing.convert_role_to_plumbing(role)) 2936 tries = 0 2937 plumbing_response = None 2938 while True: 2939 t = None if deadline is None else deadline - time.time() 2940 try: 2941 plumbing_response = self.stub.Create( 2942 req, 2943 metadata=self.parent.get_metadata('Roles.Create', req), 2944 timeout=t) 2945 except Exception as e: 2946 if self.parent.shouldRetry(tries, e, deadline): 2947 tries += 1 2948 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2949 continue 2950 raise plumbing.convert_error_to_porcelain(e) from e 2951 break 2952 2953 resp = models.RoleCreateResponse() 2954 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 2955 plumbing_response.meta) 2956 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2957 plumbing_response.rate_limit) 2958 resp.role = plumbing.convert_role_to_porcelain(plumbing_response.role) 2959 return resp 2960 2961 def get(self, id, timeout=None): 2962 ''' 2963 Get reads one Role by ID. 2964 ''' 2965 deadline = None if timeout is None else time.time() + timeout 2966 req = RoleGetRequest() 2967 if self.parent.snapshot_datetime is not None: 2968 req.meta.CopyFrom(GetRequestMetadata()) 2969 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2970 2971 req.id = (id) 2972 tries = 0 2973 plumbing_response = None 2974 while True: 2975 t = None if deadline is None else deadline - time.time() 2976 try: 2977 plumbing_response = self.stub.Get( 2978 req, 2979 metadata=self.parent.get_metadata('Roles.Get', req), 2980 timeout=t) 2981 except Exception as e: 2982 if self.parent.shouldRetry(tries, e, deadline): 2983 tries += 1 2984 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2985 continue 2986 raise plumbing.convert_error_to_porcelain(e) from e 2987 break 2988 2989 resp = models.RoleGetResponse() 2990 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2991 plumbing_response.meta) 2992 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2993 plumbing_response.rate_limit) 2994 resp.role = plumbing.convert_role_to_porcelain(plumbing_response.role) 2995 return resp 2996 2997 def update(self, role, timeout=None): 2998 ''' 2999 Update replaces all the fields of a Role by ID. 3000 ''' 3001 deadline = None if timeout is None else time.time() + timeout 3002 req = RoleUpdateRequest() 3003 3004 if role is not None: 3005 req.role.CopyFrom(plumbing.convert_role_to_plumbing(role)) 3006 tries = 0 3007 plumbing_response = None 3008 while True: 3009 t = None if deadline is None else deadline - time.time() 3010 try: 3011 plumbing_response = self.stub.Update( 3012 req, 3013 metadata=self.parent.get_metadata('Roles.Update', req), 3014 timeout=t) 3015 except Exception as e: 3016 if self.parent.shouldRetry(tries, e, deadline): 3017 tries += 1 3018 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3019 continue 3020 raise plumbing.convert_error_to_porcelain(e) from e 3021 break 3022 3023 resp = models.RoleUpdateResponse() 3024 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 3025 plumbing_response.meta) 3026 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3027 plumbing_response.rate_limit) 3028 resp.role = plumbing.convert_role_to_porcelain(plumbing_response.role) 3029 return resp 3030 3031 def delete(self, id, timeout=None): 3032 ''' 3033 Delete removes a Role by ID. 3034 ''' 3035 deadline = None if timeout is None else time.time() + timeout 3036 req = RoleDeleteRequest() 3037 3038 req.id = (id) 3039 tries = 0 3040 plumbing_response = None 3041 while True: 3042 t = None if deadline is None else deadline - time.time() 3043 try: 3044 plumbing_response = self.stub.Delete( 3045 req, 3046 metadata=self.parent.get_metadata('Roles.Delete', req), 3047 timeout=t) 3048 except Exception as e: 3049 if self.parent.shouldRetry(tries, e, deadline): 3050 tries += 1 3051 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3052 continue 3053 raise plumbing.convert_error_to_porcelain(e) from e 3054 break 3055 3056 resp = models.RoleDeleteResponse() 3057 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3058 plumbing_response.meta) 3059 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3060 plumbing_response.rate_limit) 3061 return resp 3062 3063 def list(self, filter, *args, timeout=None): 3064 ''' 3065 List gets a list of Roles matching a given set of criteria. 3066 ''' 3067 deadline = None if timeout is None else time.time() + timeout 3068 req = RoleListRequest() 3069 req.meta.CopyFrom(ListRequestMetadata()) 3070 if self.parent.page_limit > 0: 3071 req.meta.limit = self.parent.page_limit 3072 if self.parent.snapshot_datetime is not None: 3073 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3074 3075 req.filter = plumbing.quote_filter_args(filter, *args) 3076 3077 def generator(svc, req): 3078 tries = 0 3079 while True: 3080 t = None if deadline is None else deadline - time.time() 3081 try: 3082 plumbing_response = svc.stub.List( 3083 req, 3084 metadata=svc.parent.get_metadata('Roles.List', req), 3085 timeout=t) 3086 except Exception as e: 3087 if self.parent.shouldRetry(tries, e, deadline): 3088 tries += 1 3089 time.sleep( 3090 self.parent.exponentialBackoff(tries, deadline)) 3091 continue 3092 raise plumbing.convert_error_to_porcelain(e) from e 3093 tries = 0 3094 for plumbing_item in plumbing_response.roles: 3095 yield plumbing.convert_role_to_porcelain(plumbing_item) 3096 if plumbing_response.meta.next_cursor == '': 3097 break 3098 req.meta.cursor = plumbing_response.meta.next_cursor 3099 3100 return generator(self, req) 3101 3102 3103class SnapshotRoles: 3104 ''' 3105 SnapshotRoles exposes the read only methods of the Roles 3106 service for historical queries. 3107 ''' 3108 def __init__(self, roles): 3109 self.roles = roles 3110 3111 def get(self, id, timeout=None): 3112 ''' 3113 Get reads one Role by ID. 3114 ''' 3115 return self.roles.get(id, timeout=timeout) 3116 3117 def list(self, filter, *args, timeout=None): 3118 ''' 3119 List gets a list of Roles matching a given set of criteria. 3120 ''' 3121 return self.roles.list(filter, *args, timeout=timeout) 3122 3123 3124class Groups: 3125 ''' 3126 A Group is a set of principals. 3127 See `strongdm.models.Group`. 3128 ''' 3129 def __init__(self, channel, client): 3130 self.parent = client 3131 self.stub = GroupsStub(channel) 3132 3133 def create(self, group, timeout=None): 3134 ''' 3135 Create registers a new Group. 3136 ''' 3137 deadline = None if timeout is None else time.time() + timeout 3138 req = GroupCreateRequest() 3139 3140 if group is not None: 3141 req.group.CopyFrom(plumbing.convert_group_to_plumbing(group)) 3142 tries = 0 3143 plumbing_response = None 3144 while True: 3145 t = None if deadline is None else deadline - time.time() 3146 try: 3147 plumbing_response = self.stub.Create( 3148 req, 3149 metadata=self.parent.get_metadata('Groups.Create', req), 3150 timeout=t) 3151 except Exception as e: 3152 if self.parent.shouldRetry(tries, e, deadline): 3153 tries += 1 3154 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3155 continue 3156 raise plumbing.convert_error_to_porcelain(e) from e 3157 break 3158 3159 resp = models.GroupCreateResponse() 3160 resp.group = plumbing.convert_group_to_porcelain( 3161 plumbing_response.group) 3162 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3163 plumbing_response.rate_limit) 3164 return resp 3165 3166 def create_from_roles(self, role_ids, commit, timeout=None): 3167 deadline = None if timeout is None else time.time() + timeout 3168 req = GroupCreateFromRolesRequest() 3169 3170 req.role_ids.extend((role_ids)) 3171 req.commit = (commit) 3172 tries = 0 3173 plumbing_response = None 3174 while True: 3175 t = None if deadline is None else deadline - time.time() 3176 try: 3177 plumbing_response = self.stub.CreateFromRoles( 3178 req, 3179 metadata=self.parent.get_metadata('Groups.CreateFromRoles', 3180 req), 3181 timeout=t) 3182 except Exception as e: 3183 if self.parent.shouldRetry(tries, e, deadline): 3184 tries += 1 3185 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3186 continue 3187 raise plumbing.convert_error_to_porcelain(e) from e 3188 break 3189 3190 resp = models.GroupCreateFromRolesResponse() 3191 resp.group_from_role = plumbing.convert_repeated_group_from_role_to_porcelain( 3192 plumbing_response.group_from_role) 3193 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3194 plumbing_response.rate_limit) 3195 return resp 3196 3197 def get(self, id, timeout=None): 3198 ''' 3199 Get reads one Group by ID. 3200 ''' 3201 deadline = None if timeout is None else time.time() + timeout 3202 req = GroupGetRequest() 3203 if self.parent.snapshot_datetime is not None: 3204 req.meta.CopyFrom(GetRequestMetadata()) 3205 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3206 3207 req.id = (id) 3208 tries = 0 3209 plumbing_response = None 3210 while True: 3211 t = None if deadline is None else deadline - time.time() 3212 try: 3213 plumbing_response = self.stub.Get( 3214 req, 3215 metadata=self.parent.get_metadata('Groups.Get', req), 3216 timeout=t) 3217 except Exception as e: 3218 if self.parent.shouldRetry(tries, e, deadline): 3219 tries += 1 3220 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3221 continue 3222 raise plumbing.convert_error_to_porcelain(e) from e 3223 break 3224 3225 resp = models.GroupGetResponse() 3226 resp.group = plumbing.convert_group_to_porcelain( 3227 plumbing_response.group) 3228 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3229 plumbing_response.meta) 3230 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3231 plumbing_response.rate_limit) 3232 return resp 3233 3234 def update(self, group, timeout=None): 3235 ''' 3236 Update replaces all the fields of a Group by ID. 3237 ''' 3238 deadline = None if timeout is None else time.time() + timeout 3239 req = GroupUpdateRequest() 3240 3241 if group is not None: 3242 req.group.CopyFrom(plumbing.convert_group_to_plumbing(group)) 3243 tries = 0 3244 plumbing_response = None 3245 while True: 3246 t = None if deadline is None else deadline - time.time() 3247 try: 3248 plumbing_response = self.stub.Update( 3249 req, 3250 metadata=self.parent.get_metadata('Groups.Update', req), 3251 timeout=t) 3252 except Exception as e: 3253 if self.parent.shouldRetry(tries, e, deadline): 3254 tries += 1 3255 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3256 continue 3257 raise plumbing.convert_error_to_porcelain(e) from e 3258 break 3259 3260 resp = models.GroupUpdateResponse() 3261 resp.group = plumbing.convert_group_to_porcelain( 3262 plumbing_response.group) 3263 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3264 plumbing_response.rate_limit) 3265 return resp 3266 3267 def delete(self, id, timeout=None): 3268 ''' 3269 Delete removes a Group by ID. 3270 ''' 3271 deadline = None if timeout is None else time.time() + timeout 3272 req = GroupDeleteRequest() 3273 3274 req.id = (id) 3275 tries = 0 3276 plumbing_response = None 3277 while True: 3278 t = None if deadline is None else deadline - time.time() 3279 try: 3280 plumbing_response = self.stub.Delete( 3281 req, 3282 metadata=self.parent.get_metadata('Groups.Delete', req), 3283 timeout=t) 3284 except Exception as e: 3285 if self.parent.shouldRetry(tries, e, deadline): 3286 tries += 1 3287 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3288 continue 3289 raise plumbing.convert_error_to_porcelain(e) from e 3290 break 3291 3292 resp = models.GroupDeleteResponse() 3293 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3294 plumbing_response.meta) 3295 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3296 plumbing_response.rate_limit) 3297 return resp 3298 3299 def list(self, filter, *args, timeout=None): 3300 ''' 3301 List gets a list of Groups matching a given set of criteria. 3302 ''' 3303 deadline = None if timeout is None else time.time() + timeout 3304 req = GroupListRequest() 3305 req.meta.CopyFrom(ListRequestMetadata()) 3306 if self.parent.page_limit > 0: 3307 req.meta.limit = self.parent.page_limit 3308 if self.parent.snapshot_datetime is not None: 3309 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3310 3311 req.filter = plumbing.quote_filter_args(filter, *args) 3312 3313 def generator(svc, req): 3314 tries = 0 3315 while True: 3316 t = None if deadline is None else deadline - time.time() 3317 try: 3318 plumbing_response = svc.stub.List( 3319 req, 3320 metadata=svc.parent.get_metadata('Groups.List', req), 3321 timeout=t) 3322 except Exception as e: 3323 if self.parent.shouldRetry(tries, e, deadline): 3324 tries += 1 3325 time.sleep( 3326 self.parent.exponentialBackoff(tries, deadline)) 3327 continue 3328 raise plumbing.convert_error_to_porcelain(e) from e 3329 tries = 0 3330 for plumbing_item in plumbing_response.groups: 3331 yield plumbing.convert_group_to_porcelain(plumbing_item) 3332 if plumbing_response.meta.next_cursor == '': 3333 break 3334 req.meta.cursor = plumbing_response.meta.next_cursor 3335 3336 return generator(self, req) 3337 3338 3339class SnapshotGroups: 3340 ''' 3341 SnapshotGroups exposes the read only methods of the Groups 3342 service for historical queries. 3343 ''' 3344 def __init__(self, groups): 3345 self.groups = groups 3346 3347 def get(self, id, timeout=None): 3348 ''' 3349 Get reads one Group by ID. 3350 ''' 3351 return self.groups.get(id, timeout=timeout) 3352 3353 def list(self, filter, *args, timeout=None): 3354 ''' 3355 List gets a list of Groups matching a given set of criteria. 3356 ''' 3357 return self.groups.list(filter, *args, timeout=timeout) 3358 3359 3360class GroupsHistory: 3361 ''' 3362 GroupsHistory records all changes to the state of a Group. 3363 See `strongdm.models.GroupHistory`. 3364 ''' 3365 def __init__(self, channel, client): 3366 self.parent = client 3367 self.stub = GroupsHistoryStub(channel) 3368 3369 def list(self, filter, *args, timeout=None): 3370 ''' 3371 List gets a list of GroupHistory records matching a given set of criteria. 3372 ''' 3373 deadline = None if timeout is None else time.time() + timeout 3374 req = GroupHistoryListRequest() 3375 req.meta.CopyFrom(ListRequestMetadata()) 3376 if self.parent.page_limit > 0: 3377 req.meta.limit = self.parent.page_limit 3378 if self.parent.snapshot_datetime is not None: 3379 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3380 3381 req.filter = plumbing.quote_filter_args(filter, *args) 3382 3383 def generator(svc, req): 3384 tries = 0 3385 while True: 3386 t = None if deadline is None else deadline - time.time() 3387 try: 3388 plumbing_response = svc.stub.List( 3389 req, 3390 metadata=svc.parent.get_metadata( 3391 'GroupsHistory.List', req), 3392 timeout=t) 3393 except Exception as e: 3394 if self.parent.shouldRetry(tries, e, deadline): 3395 tries += 1 3396 time.sleep( 3397 self.parent.exponentialBackoff(tries, deadline)) 3398 continue 3399 raise plumbing.convert_error_to_porcelain(e) from e 3400 tries = 0 3401 for plumbing_item in plumbing_response.history: 3402 yield plumbing.convert_group_history_to_porcelain( 3403 plumbing_item) 3404 if plumbing_response.meta.next_cursor == '': 3405 break 3406 req.meta.cursor = plumbing_response.meta.next_cursor 3407 3408 return generator(self, req) 3409 3410 3411class GroupsRoles: 3412 ''' 3413 A GroupRole is an assignment of a Group to a Role. 3414 See `strongdm.models.GroupRole`. 3415 ''' 3416 def __init__(self, channel, client): 3417 self.parent = client 3418 self.stub = GroupsRolesStub(channel) 3419 3420 def create(self, group_role, timeout=None): 3421 ''' 3422 Create registers a new GroupRole. 3423 ''' 3424 deadline = None if timeout is None else time.time() + timeout 3425 req = GroupRoleCreateRequest() 3426 3427 if group_role is not None: 3428 req.group_role.CopyFrom( 3429 plumbing.convert_group_role_to_plumbing(group_role)) 3430 tries = 0 3431 plumbing_response = None 3432 while True: 3433 t = None if deadline is None else deadline - time.time() 3434 try: 3435 plumbing_response = self.stub.Create( 3436 req, 3437 metadata=self.parent.get_metadata('GroupsRoles.Create', 3438 req), 3439 timeout=t) 3440 except Exception as e: 3441 if self.parent.shouldRetry(tries, e, deadline): 3442 tries += 1 3443 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3444 continue 3445 raise plumbing.convert_error_to_porcelain(e) from e 3446 break 3447 3448 resp = models.GroupRoleCreateResponse() 3449 resp.group_role = plumbing.convert_group_role_to_porcelain( 3450 plumbing_response.group_role) 3451 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3452 plumbing_response.rate_limit) 3453 return resp 3454 3455 def get(self, id, timeout=None): 3456 ''' 3457 Get reads one GroupRole by ID. 3458 ''' 3459 deadline = None if timeout is None else time.time() + timeout 3460 req = GroupRoleGetRequest() 3461 if self.parent.snapshot_datetime is not None: 3462 req.meta.CopyFrom(GetRequestMetadata()) 3463 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3464 3465 req.id = (id) 3466 tries = 0 3467 plumbing_response = None 3468 while True: 3469 t = None if deadline is None else deadline - time.time() 3470 try: 3471 plumbing_response = self.stub.Get( 3472 req, 3473 metadata=self.parent.get_metadata('GroupsRoles.Get', req), 3474 timeout=t) 3475 except Exception as e: 3476 if self.parent.shouldRetry(tries, e, deadline): 3477 tries += 1 3478 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3479 continue 3480 raise plumbing.convert_error_to_porcelain(e) from e 3481 break 3482 3483 resp = models.GroupRoleGetResponse() 3484 resp.group_role = plumbing.convert_group_role_to_porcelain( 3485 plumbing_response.group_role) 3486 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3487 plumbing_response.meta) 3488 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3489 plumbing_response.rate_limit) 3490 return resp 3491 3492 def delete(self, id, timeout=None): 3493 ''' 3494 Delete removes a GroupRole by ID. 3495 ''' 3496 deadline = None if timeout is None else time.time() + timeout 3497 req = GroupRoleDeleteRequest() 3498 3499 req.id = (id) 3500 tries = 0 3501 plumbing_response = None 3502 while True: 3503 t = None if deadline is None else deadline - time.time() 3504 try: 3505 plumbing_response = self.stub.Delete( 3506 req, 3507 metadata=self.parent.get_metadata('GroupsRoles.Delete', 3508 req), 3509 timeout=t) 3510 except Exception as e: 3511 if self.parent.shouldRetry(tries, e, deadline): 3512 tries += 1 3513 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3514 continue 3515 raise plumbing.convert_error_to_porcelain(e) from e 3516 break 3517 3518 resp = models.GroupRoleDeleteResponse() 3519 resp.group_role = plumbing.convert_group_role_to_porcelain( 3520 plumbing_response.group_role) 3521 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3522 plumbing_response.meta) 3523 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3524 plumbing_response.rate_limit) 3525 return resp 3526 3527 def list(self, filter, *args, timeout=None): 3528 ''' 3529 List gets a list of GroupRoles matching a given set of criteria. 3530 ''' 3531 deadline = None if timeout is None else time.time() + timeout 3532 req = GroupRoleListRequest() 3533 req.meta.CopyFrom(ListRequestMetadata()) 3534 if self.parent.page_limit > 0: 3535 req.meta.limit = self.parent.page_limit 3536 if self.parent.snapshot_datetime is not None: 3537 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3538 3539 req.filter = plumbing.quote_filter_args(filter, *args) 3540 3541 def generator(svc, req): 3542 tries = 0 3543 while True: 3544 t = None if deadline is None else deadline - time.time() 3545 try: 3546 plumbing_response = svc.stub.List( 3547 req, 3548 metadata=svc.parent.get_metadata( 3549 'GroupsRoles.List', req), 3550 timeout=t) 3551 except Exception as e: 3552 if self.parent.shouldRetry(tries, e, deadline): 3553 tries += 1 3554 time.sleep( 3555 self.parent.exponentialBackoff(tries, deadline)) 3556 continue 3557 raise plumbing.convert_error_to_porcelain(e) from e 3558 tries = 0 3559 for plumbing_item in plumbing_response.groups_roles: 3560 yield plumbing.convert_group_role_to_porcelain( 3561 plumbing_item) 3562 if plumbing_response.meta.next_cursor == '': 3563 break 3564 req.meta.cursor = plumbing_response.meta.next_cursor 3565 3566 return generator(self, req) 3567 3568 3569class SnapshotGroupsRoles: 3570 ''' 3571 SnapshotGroupsRoles exposes the read only methods of the GroupsRoles 3572 service for historical queries. 3573 ''' 3574 def __init__(self, groups_roles): 3575 self.groups_roles = groups_roles 3576 3577 def get(self, id, timeout=None): 3578 ''' 3579 Get reads one GroupRole by ID. 3580 ''' 3581 return self.groups_roles.get(id, timeout=timeout) 3582 3583 def list(self, filter, *args, timeout=None): 3584 ''' 3585 List gets a list of GroupRoles matching a given set of criteria. 3586 ''' 3587 return self.groups_roles.list(filter, *args, timeout=timeout) 3588 3589 3590class GroupsRolesHistory: 3591 ''' 3592 GroupsRolesHistory records all changes to the state of a GroupRole. 3593 See `strongdm.models.GroupRoleHistory`. 3594 ''' 3595 def __init__(self, channel, client): 3596 self.parent = client 3597 self.stub = GroupsRolesHistoryStub(channel) 3598 3599 def list(self, filter, *args, timeout=None): 3600 ''' 3601 List gets a list of GroupRoleHistory records matching a given set of criteria. 3602 ''' 3603 deadline = None if timeout is None else time.time() + timeout 3604 req = GroupRoleHistoryListRequest() 3605 req.meta.CopyFrom(ListRequestMetadata()) 3606 if self.parent.page_limit > 0: 3607 req.meta.limit = self.parent.page_limit 3608 if self.parent.snapshot_datetime is not None: 3609 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3610 3611 req.filter = plumbing.quote_filter_args(filter, *args) 3612 3613 def generator(svc, req): 3614 tries = 0 3615 while True: 3616 t = None if deadline is None else deadline - time.time() 3617 try: 3618 plumbing_response = svc.stub.List( 3619 req, 3620 metadata=svc.parent.get_metadata( 3621 'GroupsRolesHistory.List', req), 3622 timeout=t) 3623 except Exception as e: 3624 if self.parent.shouldRetry(tries, e, deadline): 3625 tries += 1 3626 time.sleep( 3627 self.parent.exponentialBackoff(tries, deadline)) 3628 continue 3629 raise plumbing.convert_error_to_porcelain(e) from e 3630 tries = 0 3631 for plumbing_item in plumbing_response.history: 3632 yield plumbing.convert_group_role_history_to_porcelain( 3633 plumbing_item) 3634 if plumbing_response.meta.next_cursor == '': 3635 break 3636 req.meta.cursor = plumbing_response.meta.next_cursor 3637 3638 return generator(self, req) 3639 3640 3641class HealthChecks: 3642 ''' 3643 HealthChecks lists the last healthcheck between each node and resource. 3644 Note the unconventional capitalization here is to prevent having a collision with GRPC 3645 See `strongdm.models.Healthcheck`. 3646 ''' 3647 def __init__(self, channel, client): 3648 self.parent = client 3649 self.stub = HealthChecksStub(channel) 3650 3651 def list(self, filter, *args, timeout=None): 3652 ''' 3653 List gets a list of Healthchecks matching a given set of criteria. 3654 ''' 3655 deadline = None if timeout is None else time.time() + timeout 3656 req = HealthcheckListRequest() 3657 req.meta.CopyFrom(ListRequestMetadata()) 3658 if self.parent.page_limit > 0: 3659 req.meta.limit = self.parent.page_limit 3660 if self.parent.snapshot_datetime is not None: 3661 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3662 3663 req.filter = plumbing.quote_filter_args(filter, *args) 3664 3665 def generator(svc, req): 3666 tries = 0 3667 while True: 3668 t = None if deadline is None else deadline - time.time() 3669 try: 3670 plumbing_response = svc.stub.List( 3671 req, 3672 metadata=svc.parent.get_metadata( 3673 'HealthChecks.List', req), 3674 timeout=t) 3675 except Exception as e: 3676 if self.parent.shouldRetry(tries, e, deadline): 3677 tries += 1 3678 time.sleep( 3679 self.parent.exponentialBackoff(tries, deadline)) 3680 continue 3681 raise plumbing.convert_error_to_porcelain(e) from e 3682 tries = 0 3683 for plumbing_item in plumbing_response.healthchecks: 3684 yield plumbing.convert_healthcheck_to_porcelain( 3685 plumbing_item) 3686 if plumbing_response.meta.next_cursor == '': 3687 break 3688 req.meta.cursor = plumbing_response.meta.next_cursor 3689 3690 return generator(self, req) 3691 3692 3693class IdentityAliases: 3694 ''' 3695 IdentityAliases assign an alias to an account within an IdentitySet. 3696 The alias is used as the username when connecting to a identity supported resource. 3697 See `strongdm.models.IdentityAlias`. 3698 ''' 3699 def __init__(self, channel, client): 3700 self.parent = client 3701 self.stub = IdentityAliasesStub(channel) 3702 3703 def create(self, identity_alias, timeout=None): 3704 ''' 3705 Create registers a new IdentityAlias. 3706 ''' 3707 deadline = None if timeout is None else time.time() + timeout 3708 req = IdentityAliasCreateRequest() 3709 3710 if identity_alias is not None: 3711 req.identity_alias.CopyFrom( 3712 plumbing.convert_identity_alias_to_plumbing(identity_alias)) 3713 tries = 0 3714 plumbing_response = None 3715 while True: 3716 t = None if deadline is None else deadline - time.time() 3717 try: 3718 plumbing_response = self.stub.Create( 3719 req, 3720 metadata=self.parent.get_metadata('IdentityAliases.Create', 3721 req), 3722 timeout=t) 3723 except Exception as e: 3724 if self.parent.shouldRetry(tries, e, deadline): 3725 tries += 1 3726 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3727 continue 3728 raise plumbing.convert_error_to_porcelain(e) from e 3729 break 3730 3731 resp = models.IdentityAliasCreateResponse() 3732 resp.identity_alias = plumbing.convert_identity_alias_to_porcelain( 3733 plumbing_response.identity_alias) 3734 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 3735 plumbing_response.meta) 3736 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3737 plumbing_response.rate_limit) 3738 return resp 3739 3740 def get(self, id, timeout=None): 3741 ''' 3742 Get reads one IdentityAlias by ID. 3743 ''' 3744 deadline = None if timeout is None else time.time() + timeout 3745 req = IdentityAliasGetRequest() 3746 if self.parent.snapshot_datetime is not None: 3747 req.meta.CopyFrom(GetRequestMetadata()) 3748 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3749 3750 req.id = (id) 3751 tries = 0 3752 plumbing_response = None 3753 while True: 3754 t = None if deadline is None else deadline - time.time() 3755 try: 3756 plumbing_response = self.stub.Get( 3757 req, 3758 metadata=self.parent.get_metadata('IdentityAliases.Get', 3759 req), 3760 timeout=t) 3761 except Exception as e: 3762 if self.parent.shouldRetry(tries, e, deadline): 3763 tries += 1 3764 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3765 continue 3766 raise plumbing.convert_error_to_porcelain(e) from e 3767 break 3768 3769 resp = models.IdentityAliasGetResponse() 3770 resp.identity_alias = plumbing.convert_identity_alias_to_porcelain( 3771 plumbing_response.identity_alias) 3772 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3773 plumbing_response.meta) 3774 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3775 plumbing_response.rate_limit) 3776 return resp 3777 3778 def update(self, identity_alias, timeout=None): 3779 ''' 3780 Update replaces all the fields of a IdentityAlias by ID. 3781 ''' 3782 deadline = None if timeout is None else time.time() + timeout 3783 req = IdentityAliasUpdateRequest() 3784 3785 if identity_alias is not None: 3786 req.identity_alias.CopyFrom( 3787 plumbing.convert_identity_alias_to_plumbing(identity_alias)) 3788 tries = 0 3789 plumbing_response = None 3790 while True: 3791 t = None if deadline is None else deadline - time.time() 3792 try: 3793 plumbing_response = self.stub.Update( 3794 req, 3795 metadata=self.parent.get_metadata('IdentityAliases.Update', 3796 req), 3797 timeout=t) 3798 except Exception as e: 3799 if self.parent.shouldRetry(tries, e, deadline): 3800 tries += 1 3801 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3802 continue 3803 raise plumbing.convert_error_to_porcelain(e) from e 3804 break 3805 3806 resp = models.IdentityAliasUpdateResponse() 3807 resp.identity_alias = plumbing.convert_identity_alias_to_porcelain( 3808 plumbing_response.identity_alias) 3809 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 3810 plumbing_response.meta) 3811 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3812 plumbing_response.rate_limit) 3813 return resp 3814 3815 def delete(self, id, timeout=None): 3816 ''' 3817 Delete removes a IdentityAlias by ID. 3818 ''' 3819 deadline = None if timeout is None else time.time() + timeout 3820 req = IdentityAliasDeleteRequest() 3821 3822 req.id = (id) 3823 tries = 0 3824 plumbing_response = None 3825 while True: 3826 t = None if deadline is None else deadline - time.time() 3827 try: 3828 plumbing_response = self.stub.Delete( 3829 req, 3830 metadata=self.parent.get_metadata('IdentityAliases.Delete', 3831 req), 3832 timeout=t) 3833 except Exception as e: 3834 if self.parent.shouldRetry(tries, e, deadline): 3835 tries += 1 3836 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3837 continue 3838 raise plumbing.convert_error_to_porcelain(e) from e 3839 break 3840 3841 resp = models.IdentityAliasDeleteResponse() 3842 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3843 plumbing_response.meta) 3844 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3845 plumbing_response.rate_limit) 3846 return resp 3847 3848 def list(self, filter, *args, timeout=None): 3849 ''' 3850 List gets a list of IdentityAliases matching a given set of criteria. 3851 ''' 3852 deadline = None if timeout is None else time.time() + timeout 3853 req = IdentityAliasListRequest() 3854 req.meta.CopyFrom(ListRequestMetadata()) 3855 if self.parent.page_limit > 0: 3856 req.meta.limit = self.parent.page_limit 3857 if self.parent.snapshot_datetime is not None: 3858 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3859 3860 req.filter = plumbing.quote_filter_args(filter, *args) 3861 3862 def generator(svc, req): 3863 tries = 0 3864 while True: 3865 t = None if deadline is None else deadline - time.time() 3866 try: 3867 plumbing_response = svc.stub.List( 3868 req, 3869 metadata=svc.parent.get_metadata( 3870 'IdentityAliases.List', req), 3871 timeout=t) 3872 except Exception as e: 3873 if self.parent.shouldRetry(tries, e, deadline): 3874 tries += 1 3875 time.sleep( 3876 self.parent.exponentialBackoff(tries, deadline)) 3877 continue 3878 raise plumbing.convert_error_to_porcelain(e) from e 3879 tries = 0 3880 for plumbing_item in plumbing_response.identity_aliases: 3881 yield plumbing.convert_identity_alias_to_porcelain( 3882 plumbing_item) 3883 if plumbing_response.meta.next_cursor == '': 3884 break 3885 req.meta.cursor = plumbing_response.meta.next_cursor 3886 3887 return generator(self, req) 3888 3889 3890class SnapshotIdentityAliases: 3891 ''' 3892 SnapshotIdentityAliases exposes the read only methods of the IdentityAliases 3893 service for historical queries. 3894 ''' 3895 def __init__(self, identity_aliases): 3896 self.identity_aliases = identity_aliases 3897 3898 def get(self, id, timeout=None): 3899 ''' 3900 Get reads one IdentityAlias by ID. 3901 ''' 3902 return self.identity_aliases.get(id, timeout=timeout) 3903 3904 def list(self, filter, *args, timeout=None): 3905 ''' 3906 List gets a list of IdentityAliases matching a given set of criteria. 3907 ''' 3908 return self.identity_aliases.list(filter, *args, timeout=timeout) 3909 3910 3911class IdentityAliasesHistory: 3912 ''' 3913 IdentityAliasesHistory records all changes to the state of a IdentityAlias. 3914 See `strongdm.models.IdentityAliasHistory`. 3915 ''' 3916 def __init__(self, channel, client): 3917 self.parent = client 3918 self.stub = IdentityAliasesHistoryStub(channel) 3919 3920 def list(self, filter, *args, timeout=None): 3921 ''' 3922 List gets a list of IdentityAliasHistory records matching a given set of criteria. 3923 ''' 3924 deadline = None if timeout is None else time.time() + timeout 3925 req = IdentityAliasHistoryListRequest() 3926 req.meta.CopyFrom(ListRequestMetadata()) 3927 if self.parent.page_limit > 0: 3928 req.meta.limit = self.parent.page_limit 3929 if self.parent.snapshot_datetime is not None: 3930 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3931 3932 req.filter = plumbing.quote_filter_args(filter, *args) 3933 3934 def generator(svc, req): 3935 tries = 0 3936 while True: 3937 t = None if deadline is None else deadline - time.time() 3938 try: 3939 plumbing_response = svc.stub.List( 3940 req, 3941 metadata=svc.parent.get_metadata( 3942 'IdentityAliasesHistory.List', req), 3943 timeout=t) 3944 except Exception as e: 3945 if self.parent.shouldRetry(tries, e, deadline): 3946 tries += 1 3947 time.sleep( 3948 self.parent.exponentialBackoff(tries, deadline)) 3949 continue 3950 raise plumbing.convert_error_to_porcelain(e) from e 3951 tries = 0 3952 for plumbing_item in plumbing_response.history: 3953 yield plumbing.convert_identity_alias_history_to_porcelain( 3954 plumbing_item) 3955 if plumbing_response.meta.next_cursor == '': 3956 break 3957 req.meta.cursor = plumbing_response.meta.next_cursor 3958 3959 return generator(self, req) 3960 3961 3962class IdentitySets: 3963 ''' 3964 A IdentitySet is a named grouping of Identity Aliases for Accounts. 3965 An Account's relationship to a IdentitySet is defined via IdentityAlias objects. 3966 See `strongdm.models.IdentitySet`. 3967 ''' 3968 def __init__(self, channel, client): 3969 self.parent = client 3970 self.stub = IdentitySetsStub(channel) 3971 3972 def create(self, identity_set, timeout=None): 3973 ''' 3974 Create registers a new IdentitySet. 3975 ''' 3976 deadline = None if timeout is None else time.time() + timeout 3977 req = IdentitySetCreateRequest() 3978 3979 if identity_set is not None: 3980 req.identity_set.CopyFrom( 3981 plumbing.convert_identity_set_to_plumbing(identity_set)) 3982 tries = 0 3983 plumbing_response = None 3984 while True: 3985 t = None if deadline is None else deadline - time.time() 3986 try: 3987 plumbing_response = self.stub.Create( 3988 req, 3989 metadata=self.parent.get_metadata('IdentitySets.Create', 3990 req), 3991 timeout=t) 3992 except Exception as e: 3993 if self.parent.shouldRetry(tries, e, deadline): 3994 tries += 1 3995 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3996 continue 3997 raise plumbing.convert_error_to_porcelain(e) from e 3998 break 3999 4000 resp = models.IdentitySetCreateResponse() 4001 resp.identity_set = plumbing.convert_identity_set_to_porcelain( 4002 plumbing_response.identity_set) 4003 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4004 plumbing_response.meta) 4005 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4006 plumbing_response.rate_limit) 4007 return resp 4008 4009 def get(self, id, timeout=None): 4010 ''' 4011 Get reads one IdentitySet by ID. 4012 ''' 4013 deadline = None if timeout is None else time.time() + timeout 4014 req = IdentitySetGetRequest() 4015 if self.parent.snapshot_datetime is not None: 4016 req.meta.CopyFrom(GetRequestMetadata()) 4017 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4018 4019 req.id = (id) 4020 tries = 0 4021 plumbing_response = None 4022 while True: 4023 t = None if deadline is None else deadline - time.time() 4024 try: 4025 plumbing_response = self.stub.Get( 4026 req, 4027 metadata=self.parent.get_metadata('IdentitySets.Get', req), 4028 timeout=t) 4029 except Exception as e: 4030 if self.parent.shouldRetry(tries, e, deadline): 4031 tries += 1 4032 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4033 continue 4034 raise plumbing.convert_error_to_porcelain(e) from e 4035 break 4036 4037 resp = models.IdentitySetGetResponse() 4038 resp.identity_set = plumbing.convert_identity_set_to_porcelain( 4039 plumbing_response.identity_set) 4040 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4041 plumbing_response.meta) 4042 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4043 plumbing_response.rate_limit) 4044 return resp 4045 4046 def update(self, identity_set, timeout=None): 4047 ''' 4048 Update replaces all the fields of a IdentitySet by ID. 4049 ''' 4050 deadline = None if timeout is None else time.time() + timeout 4051 req = IdentitySetUpdateRequest() 4052 4053 if identity_set is not None: 4054 req.identity_set.CopyFrom( 4055 plumbing.convert_identity_set_to_plumbing(identity_set)) 4056 tries = 0 4057 plumbing_response = None 4058 while True: 4059 t = None if deadline is None else deadline - time.time() 4060 try: 4061 plumbing_response = self.stub.Update( 4062 req, 4063 metadata=self.parent.get_metadata('IdentitySets.Update', 4064 req), 4065 timeout=t) 4066 except Exception as e: 4067 if self.parent.shouldRetry(tries, e, deadline): 4068 tries += 1 4069 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4070 continue 4071 raise plumbing.convert_error_to_porcelain(e) from e 4072 break 4073 4074 resp = models.IdentitySetUpdateResponse() 4075 resp.identity_set = plumbing.convert_identity_set_to_porcelain( 4076 plumbing_response.identity_set) 4077 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 4078 plumbing_response.meta) 4079 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4080 plumbing_response.rate_limit) 4081 return resp 4082 4083 def delete(self, id, timeout=None): 4084 ''' 4085 Delete removes a IdentitySet by ID. 4086 ''' 4087 deadline = None if timeout is None else time.time() + timeout 4088 req = IdentitySetDeleteRequest() 4089 4090 req.id = (id) 4091 tries = 0 4092 plumbing_response = None 4093 while True: 4094 t = None if deadline is None else deadline - time.time() 4095 try: 4096 plumbing_response = self.stub.Delete( 4097 req, 4098 metadata=self.parent.get_metadata('IdentitySets.Delete', 4099 req), 4100 timeout=t) 4101 except Exception as e: 4102 if self.parent.shouldRetry(tries, e, deadline): 4103 tries += 1 4104 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4105 continue 4106 raise plumbing.convert_error_to_porcelain(e) from e 4107 break 4108 4109 resp = models.IdentitySetDeleteResponse() 4110 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 4111 plumbing_response.meta) 4112 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4113 plumbing_response.rate_limit) 4114 return resp 4115 4116 def list(self, filter, *args, timeout=None): 4117 ''' 4118 List gets a list of IdentitySets matching a given set of criteria. 4119 ''' 4120 deadline = None if timeout is None else time.time() + timeout 4121 req = IdentitySetListRequest() 4122 req.meta.CopyFrom(ListRequestMetadata()) 4123 if self.parent.page_limit > 0: 4124 req.meta.limit = self.parent.page_limit 4125 if self.parent.snapshot_datetime is not None: 4126 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4127 4128 req.filter = plumbing.quote_filter_args(filter, *args) 4129 4130 def generator(svc, req): 4131 tries = 0 4132 while True: 4133 t = None if deadline is None else deadline - time.time() 4134 try: 4135 plumbing_response = svc.stub.List( 4136 req, 4137 metadata=svc.parent.get_metadata( 4138 'IdentitySets.List', req), 4139 timeout=t) 4140 except Exception as e: 4141 if self.parent.shouldRetry(tries, e, deadline): 4142 tries += 1 4143 time.sleep( 4144 self.parent.exponentialBackoff(tries, deadline)) 4145 continue 4146 raise plumbing.convert_error_to_porcelain(e) from e 4147 tries = 0 4148 for plumbing_item in plumbing_response.identity_sets: 4149 yield plumbing.convert_identity_set_to_porcelain( 4150 plumbing_item) 4151 if plumbing_response.meta.next_cursor == '': 4152 break 4153 req.meta.cursor = plumbing_response.meta.next_cursor 4154 4155 return generator(self, req) 4156 4157 4158class SnapshotIdentitySets: 4159 ''' 4160 SnapshotIdentitySets exposes the read only methods of the IdentitySets 4161 service for historical queries. 4162 ''' 4163 def __init__(self, identity_sets): 4164 self.identity_sets = identity_sets 4165 4166 def get(self, id, timeout=None): 4167 ''' 4168 Get reads one IdentitySet by ID. 4169 ''' 4170 return self.identity_sets.get(id, timeout=timeout) 4171 4172 def list(self, filter, *args, timeout=None): 4173 ''' 4174 List gets a list of IdentitySets matching a given set of criteria. 4175 ''' 4176 return self.identity_sets.list(filter, *args, timeout=timeout) 4177 4178 4179class IdentitySetsHistory: 4180 ''' 4181 IdentitySetsHistory records all changes to the state of a IdentitySet. 4182 See `strongdm.models.IdentitySetHistory`. 4183 ''' 4184 def __init__(self, channel, client): 4185 self.parent = client 4186 self.stub = IdentitySetsHistoryStub(channel) 4187 4188 def list(self, filter, *args, timeout=None): 4189 ''' 4190 List gets a list of IdentitySetHistory records matching a given set of criteria. 4191 ''' 4192 deadline = None if timeout is None else time.time() + timeout 4193 req = IdentitySetHistoryListRequest() 4194 req.meta.CopyFrom(ListRequestMetadata()) 4195 if self.parent.page_limit > 0: 4196 req.meta.limit = self.parent.page_limit 4197 if self.parent.snapshot_datetime is not None: 4198 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4199 4200 req.filter = plumbing.quote_filter_args(filter, *args) 4201 4202 def generator(svc, req): 4203 tries = 0 4204 while True: 4205 t = None if deadline is None else deadline - time.time() 4206 try: 4207 plumbing_response = svc.stub.List( 4208 req, 4209 metadata=svc.parent.get_metadata( 4210 'IdentitySetsHistory.List', req), 4211 timeout=t) 4212 except Exception as e: 4213 if self.parent.shouldRetry(tries, e, deadline): 4214 tries += 1 4215 time.sleep( 4216 self.parent.exponentialBackoff(tries, deadline)) 4217 continue 4218 raise plumbing.convert_error_to_porcelain(e) from e 4219 tries = 0 4220 for plumbing_item in plumbing_response.history: 4221 yield plumbing.convert_identity_set_history_to_porcelain( 4222 plumbing_item) 4223 if plumbing_response.meta.next_cursor == '': 4224 break 4225 req.meta.cursor = plumbing_response.meta.next_cursor 4226 4227 return generator(self, req) 4228 4229 4230class ManagedSecrets: 4231 ''' 4232 ManagedSecret is a private vertical for creating, reading, updating, 4233 deleting, listing and rotating the managed secrets in the secrets engines as 4234 an authenticated user. 4235 See `strongdm.models.ManagedSecret`. 4236 ''' 4237 def __init__(self, channel, client): 4238 self.parent = client 4239 self.stub = ManagedSecretsStub(channel) 4240 4241 def list(self, filter, *args, timeout=None): 4242 ''' 4243 List returns Managed Secrets from a Secret Engine. 4244 ''' 4245 deadline = None if timeout is None else time.time() + timeout 4246 req = ManagedSecretListRequest() 4247 req.meta.CopyFrom(ListRequestMetadata()) 4248 if self.parent.page_limit > 0: 4249 req.meta.limit = self.parent.page_limit 4250 if self.parent.snapshot_datetime is not None: 4251 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4252 4253 req.filter = plumbing.quote_filter_args(filter, *args) 4254 4255 def generator(svc, req): 4256 tries = 0 4257 while True: 4258 t = None if deadline is None else deadline - time.time() 4259 try: 4260 plumbing_response = svc.stub.List( 4261 req, 4262 metadata=svc.parent.get_metadata( 4263 'ManagedSecrets.List', req), 4264 timeout=t) 4265 except Exception as e: 4266 if self.parent.shouldRetry(tries, e, deadline): 4267 tries += 1 4268 time.sleep( 4269 self.parent.exponentialBackoff(tries, deadline)) 4270 continue 4271 raise plumbing.convert_error_to_porcelain(e) from e 4272 tries = 0 4273 for plumbing_item in plumbing_response.managed_secrets: 4274 yield plumbing.convert_managed_secret_to_porcelain( 4275 plumbing_item) 4276 if plumbing_response.meta.next_cursor == '': 4277 break 4278 req.meta.cursor = plumbing_response.meta.next_cursor 4279 4280 return generator(self, req) 4281 4282 def list_by_actor(self, filter, *args, timeout=None): 4283 ''' 4284 List returns Managed Secrets for an Actor from a Secret Engine. 4285 ''' 4286 deadline = None if timeout is None else time.time() + timeout 4287 req = ManagedSecretListRequest() 4288 req.meta.CopyFrom(ListRequestMetadata()) 4289 if self.parent.page_limit > 0: 4290 req.meta.limit = self.parent.page_limit 4291 if self.parent.snapshot_datetime is not None: 4292 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4293 4294 req.filter = plumbing.quote_filter_args(filter, *args) 4295 4296 def generator(svc, req): 4297 tries = 0 4298 while True: 4299 t = None if deadline is None else deadline - time.time() 4300 try: 4301 plumbing_response = svc.stub.ListByActor( 4302 req, 4303 metadata=svc.parent.get_metadata( 4304 'ManagedSecrets.ListByActor', req), 4305 timeout=t) 4306 except Exception as e: 4307 if self.parent.shouldRetry(tries, e, deadline): 4308 tries += 1 4309 time.sleep( 4310 self.parent.exponentialBackoff(tries, deadline)) 4311 continue 4312 raise plumbing.convert_error_to_porcelain(e) from e 4313 tries = 0 4314 for plumbing_item in plumbing_response.managed_secrets: 4315 yield plumbing.convert_managed_secret_to_porcelain( 4316 plumbing_item) 4317 if plumbing_response.meta.next_cursor == '': 4318 break 4319 req.meta.cursor = plumbing_response.meta.next_cursor 4320 4321 return generator(self, req) 4322 4323 def create(self, managed_secret, timeout=None): 4324 ''' 4325 Create creates a Managed Secret 4326 ''' 4327 deadline = None if timeout is None else time.time() + timeout 4328 req = ManagedSecretCreateRequest() 4329 4330 if managed_secret is not None: 4331 req.managed_secret.CopyFrom( 4332 plumbing.convert_managed_secret_to_plumbing(managed_secret)) 4333 tries = 0 4334 plumbing_response = None 4335 while True: 4336 t = None if deadline is None else deadline - time.time() 4337 try: 4338 plumbing_response = self.stub.Create( 4339 req, 4340 metadata=self.parent.get_metadata('ManagedSecrets.Create', 4341 req), 4342 timeout=t) 4343 except Exception as e: 4344 if self.parent.shouldRetry(tries, e, deadline): 4345 tries += 1 4346 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4347 continue 4348 raise plumbing.convert_error_to_porcelain(e) from e 4349 break 4350 4351 resp = models.ManagedSecretCreateResponse() 4352 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 4353 plumbing_response.managed_secret) 4354 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4355 plumbing_response.meta) 4356 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4357 plumbing_response.rate_limit) 4358 return resp 4359 4360 def update(self, managed_secret, timeout=None): 4361 ''' 4362 Update updates a Managed Secret 4363 ''' 4364 deadline = None if timeout is None else time.time() + timeout 4365 req = ManagedSecretUpdateRequest() 4366 4367 if managed_secret is not None: 4368 req.managed_secret.CopyFrom( 4369 plumbing.convert_managed_secret_to_plumbing(managed_secret)) 4370 tries = 0 4371 plumbing_response = None 4372 while True: 4373 t = None if deadline is None else deadline - time.time() 4374 try: 4375 plumbing_response = self.stub.Update( 4376 req, 4377 metadata=self.parent.get_metadata('ManagedSecrets.Update', 4378 req), 4379 timeout=t) 4380 except Exception as e: 4381 if self.parent.shouldRetry(tries, e, deadline): 4382 tries += 1 4383 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4384 continue 4385 raise plumbing.convert_error_to_porcelain(e) from e 4386 break 4387 4388 resp = models.ManagedSecretUpdateResponse() 4389 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 4390 plumbing_response.managed_secret) 4391 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 4392 plumbing_response.meta) 4393 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4394 plumbing_response.rate_limit) 4395 return resp 4396 4397 def rotate(self, id, timeout=None): 4398 ''' 4399 Rotate forces rotation of Managed Secret 4400 ''' 4401 deadline = None if timeout is None else time.time() + timeout 4402 req = ManagedSecretRotateRequest() 4403 4404 req.id = (id) 4405 tries = 0 4406 plumbing_response = None 4407 while True: 4408 t = None if deadline is None else deadline - time.time() 4409 try: 4410 plumbing_response = self.stub.Rotate( 4411 req, 4412 metadata=self.parent.get_metadata('ManagedSecrets.Rotate', 4413 req), 4414 timeout=t) 4415 except Exception as e: 4416 if self.parent.shouldRetry(tries, e, deadline): 4417 tries += 1 4418 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4419 continue 4420 raise plumbing.convert_error_to_porcelain(e) from e 4421 break 4422 4423 resp = models.ManagedSecretRotateResponse() 4424 resp.meta = plumbing.convert_generic_response_metadata_to_porcelain( 4425 plumbing_response.meta) 4426 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4427 plumbing_response.rate_limit) 4428 return resp 4429 4430 def delete(self, id, timeout=None): 4431 ''' 4432 Delete deletes a Managed Secret 4433 ''' 4434 deadline = None if timeout is None else time.time() + timeout 4435 req = ManagedSecretDeleteRequest() 4436 4437 req.id = (id) 4438 tries = 0 4439 plumbing_response = None 4440 while True: 4441 t = None if deadline is None else deadline - time.time() 4442 try: 4443 plumbing_response = self.stub.Delete( 4444 req, 4445 metadata=self.parent.get_metadata('ManagedSecrets.Delete', 4446 req), 4447 timeout=t) 4448 except Exception as e: 4449 if self.parent.shouldRetry(tries, e, deadline): 4450 tries += 1 4451 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4452 continue 4453 raise plumbing.convert_error_to_porcelain(e) from e 4454 break 4455 4456 resp = models.ManagedSecretDeleteResponse() 4457 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4458 plumbing_response.rate_limit) 4459 return resp 4460 4461 def force_delete(self, id, timeout=None): 4462 ''' 4463 ForceDelete deletes a Managed Secret regardless of errors on external system 4464 ''' 4465 deadline = None if timeout is None else time.time() + timeout 4466 req = ManagedSecretDeleteRequest() 4467 4468 req.id = (id) 4469 tries = 0 4470 plumbing_response = None 4471 while True: 4472 t = None if deadline is None else deadline - time.time() 4473 try: 4474 plumbing_response = self.stub.ForceDelete( 4475 req, 4476 metadata=self.parent.get_metadata( 4477 'ManagedSecrets.ForceDelete', req), 4478 timeout=t) 4479 except Exception as e: 4480 if self.parent.shouldRetry(tries, e, deadline): 4481 tries += 1 4482 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4483 continue 4484 raise plumbing.convert_error_to_porcelain(e) from e 4485 break 4486 4487 resp = models.ManagedSecretDeleteResponse() 4488 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4489 plumbing_response.rate_limit) 4490 return resp 4491 4492 def get(self, id, timeout=None): 4493 ''' 4494 Get gets details of a Managed Secret without sensitive data 4495 ''' 4496 deadline = None if timeout is None else time.time() + timeout 4497 req = ManagedSecretGetRequest() 4498 if self.parent.snapshot_datetime is not None: 4499 req.meta.CopyFrom(GetRequestMetadata()) 4500 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4501 4502 req.id = (id) 4503 tries = 0 4504 plumbing_response = None 4505 while True: 4506 t = None if deadline is None else deadline - time.time() 4507 try: 4508 plumbing_response = self.stub.Get( 4509 req, 4510 metadata=self.parent.get_metadata('ManagedSecrets.Get', 4511 req), 4512 timeout=t) 4513 except Exception as e: 4514 if self.parent.shouldRetry(tries, e, deadline): 4515 tries += 1 4516 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4517 continue 4518 raise plumbing.convert_error_to_porcelain(e) from e 4519 break 4520 4521 resp = models.ManagedSecretGetResponse() 4522 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 4523 plumbing_response.managed_secret) 4524 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4525 plumbing_response.meta) 4526 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4527 plumbing_response.rate_limit) 4528 return resp 4529 4530 def retrieve(self, id, timeout=None): 4531 ''' 4532 Retrieve returns Managed Secret with sensitive data 4533 ''' 4534 deadline = None if timeout is None else time.time() + timeout 4535 req = ManagedSecretRetrieveRequest() 4536 4537 req.id = (id) 4538 tries = 0 4539 plumbing_response = None 4540 while True: 4541 t = None if deadline is None else deadline - time.time() 4542 try: 4543 plumbing_response = self.stub.Retrieve( 4544 req, 4545 metadata=self.parent.get_metadata( 4546 'ManagedSecrets.Retrieve', req), 4547 timeout=t) 4548 except Exception as e: 4549 if self.parent.shouldRetry(tries, e, deadline): 4550 tries += 1 4551 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4552 continue 4553 raise plumbing.convert_error_to_porcelain(e) from e 4554 break 4555 4556 resp = models.ManagedSecretRetrieveResponse() 4557 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 4558 plumbing_response.managed_secret) 4559 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4560 plumbing_response.meta) 4561 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4562 plumbing_response.rate_limit) 4563 return resp 4564 4565 def validate(self, id, timeout=None): 4566 ''' 4567 Validate returns the result of testing the stored credential against the 4568 secret engine. 4569 ''' 4570 deadline = None if timeout is None else time.time() + timeout 4571 req = ManagedSecretValidateRequest() 4572 4573 req.id = (id) 4574 tries = 0 4575 plumbing_response = None 4576 while True: 4577 t = None if deadline is None else deadline - time.time() 4578 try: 4579 plumbing_response = self.stub.Validate( 4580 req, 4581 metadata=self.parent.get_metadata( 4582 'ManagedSecrets.Validate', req), 4583 timeout=t) 4584 except Exception as e: 4585 if self.parent.shouldRetry(tries, e, deadline): 4586 tries += 1 4587 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4588 continue 4589 raise plumbing.convert_error_to_porcelain(e) from e 4590 break 4591 4592 resp = models.ManagedSecretValidateResponse() 4593 resp.invalid_info = (plumbing_response.invalid_info) 4594 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4595 plumbing_response.meta) 4596 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4597 plumbing_response.rate_limit) 4598 resp.valid = (plumbing_response.valid) 4599 return resp 4600 4601 def logs(self, filter, *args, timeout=None): 4602 ''' 4603 Logs returns the audit records for the managed secret. This may be replaced 4604 in the future. 4605 ''' 4606 deadline = None if timeout is None else time.time() + timeout 4607 req = ManagedSecretLogsRequest() 4608 req.meta.CopyFrom(ListRequestMetadata()) 4609 if self.parent.page_limit > 0: 4610 req.meta.limit = self.parent.page_limit 4611 if self.parent.snapshot_datetime is not None: 4612 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4613 4614 req.filter = plumbing.quote_filter_args(filter, *args) 4615 4616 def generator(svc, req): 4617 tries = 0 4618 while True: 4619 t = None if deadline is None else deadline - time.time() 4620 try: 4621 plumbing_response = svc.stub.Logs( 4622 req, 4623 metadata=svc.parent.get_metadata( 4624 'ManagedSecrets.Logs', req), 4625 timeout=t) 4626 except Exception as e: 4627 if self.parent.shouldRetry(tries, e, deadline): 4628 tries += 1 4629 time.sleep( 4630 self.parent.exponentialBackoff(tries, deadline)) 4631 continue 4632 raise plumbing.convert_error_to_porcelain(e) from e 4633 tries = 0 4634 for plumbing_item in plumbing_response.managed_secret_logs: 4635 yield plumbing.convert_managed_secret_log_to_porcelain( 4636 plumbing_item) 4637 if plumbing_response.meta.next_cursor == '': 4638 break 4639 req.meta.cursor = plumbing_response.meta.next_cursor 4640 4641 return generator(self, req) 4642 4643 4644class Nodes: 4645 ''' 4646 Nodes make up the StrongDM network, and allow your users to connect securely to your resources. 4647 There are three types of nodes: 4648 1. **Relay:** creates connectivity to your datasources, while maintaining the egress-only nature of your firewall 4649 2. **Gateway:** a relay that also listens for connections from StrongDM clients 4650 3. **Proxy Cluster:** a cluster of workers that together mediate access from clients to resources 4651 See: 4652 `strongdm.models.Gateway` 4653 `strongdm.models.ProxyCluster` 4654 `strongdm.models.Relay` 4655 ''' 4656 def __init__(self, channel, client): 4657 self.parent = client 4658 self.stub = NodesStub(channel) 4659 4660 def create(self, node, timeout=None): 4661 ''' 4662 Create registers a new Node. 4663 ''' 4664 deadline = None if timeout is None else time.time() + timeout 4665 req = NodeCreateRequest() 4666 4667 if node is not None: 4668 req.node.CopyFrom(plumbing.convert_node_to_plumbing(node)) 4669 tries = 0 4670 plumbing_response = None 4671 while True: 4672 t = None if deadline is None else deadline - time.time() 4673 try: 4674 plumbing_response = self.stub.Create( 4675 req, 4676 metadata=self.parent.get_metadata('Nodes.Create', req), 4677 timeout=t) 4678 except Exception as e: 4679 if self.parent.shouldRetry(tries, e, deadline): 4680 tries += 1 4681 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4682 continue 4683 raise plumbing.convert_error_to_porcelain(e) from e 4684 break 4685 4686 resp = models.NodeCreateResponse() 4687 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4688 plumbing_response.meta) 4689 resp.node = plumbing.convert_node_to_porcelain(plumbing_response.node) 4690 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4691 plumbing_response.rate_limit) 4692 resp.token = (plumbing_response.token) 4693 return resp 4694 4695 def get(self, id, timeout=None): 4696 ''' 4697 Get reads one Node by ID. 4698 ''' 4699 deadline = None if timeout is None else time.time() + timeout 4700 req = NodeGetRequest() 4701 if self.parent.snapshot_datetime is not None: 4702 req.meta.CopyFrom(GetRequestMetadata()) 4703 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4704 4705 req.id = (id) 4706 tries = 0 4707 plumbing_response = None 4708 while True: 4709 t = None if deadline is None else deadline - time.time() 4710 try: 4711 plumbing_response = self.stub.Get( 4712 req, 4713 metadata=self.parent.get_metadata('Nodes.Get', req), 4714 timeout=t) 4715 except Exception as e: 4716 if self.parent.shouldRetry(tries, e, deadline): 4717 tries += 1 4718 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4719 continue 4720 raise plumbing.convert_error_to_porcelain(e) from e 4721 break 4722 4723 resp = models.NodeGetResponse() 4724 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4725 plumbing_response.meta) 4726 resp.node = plumbing.convert_node_to_porcelain(plumbing_response.node) 4727 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4728 plumbing_response.rate_limit) 4729 return resp 4730 4731 def update(self, node, timeout=None): 4732 ''' 4733 Update replaces all the fields of a Node by ID. 4734 ''' 4735 deadline = None if timeout is None else time.time() + timeout 4736 req = NodeUpdateRequest() 4737 4738 if node is not None: 4739 req.node.CopyFrom(plumbing.convert_node_to_plumbing(node)) 4740 tries = 0 4741 plumbing_response = None 4742 while True: 4743 t = None if deadline is None else deadline - time.time() 4744 try: 4745 plumbing_response = self.stub.Update( 4746 req, 4747 metadata=self.parent.get_metadata('Nodes.Update', req), 4748 timeout=t) 4749 except Exception as e: 4750 if self.parent.shouldRetry(tries, e, deadline): 4751 tries += 1 4752 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4753 continue 4754 raise plumbing.convert_error_to_porcelain(e) from e 4755 break 4756 4757 resp = models.NodeUpdateResponse() 4758 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 4759 plumbing_response.meta) 4760 resp.node = plumbing.convert_node_to_porcelain(plumbing_response.node) 4761 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4762 plumbing_response.rate_limit) 4763 return resp 4764 4765 def delete(self, id, timeout=None): 4766 ''' 4767 Delete removes a Node by ID. 4768 ''' 4769 deadline = None if timeout is None else time.time() + timeout 4770 req = NodeDeleteRequest() 4771 4772 req.id = (id) 4773 tries = 0 4774 plumbing_response = None 4775 while True: 4776 t = None if deadline is None else deadline - time.time() 4777 try: 4778 plumbing_response = self.stub.Delete( 4779 req, 4780 metadata=self.parent.get_metadata('Nodes.Delete', req), 4781 timeout=t) 4782 except Exception as e: 4783 if self.parent.shouldRetry(tries, e, deadline): 4784 tries += 1 4785 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4786 continue 4787 raise plumbing.convert_error_to_porcelain(e) from e 4788 break 4789 4790 resp = models.NodeDeleteResponse() 4791 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 4792 plumbing_response.meta) 4793 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4794 plumbing_response.rate_limit) 4795 return resp 4796 4797 def list(self, filter, *args, timeout=None): 4798 ''' 4799 List gets a list of Nodes matching a given set of criteria. 4800 ''' 4801 deadline = None if timeout is None else time.time() + timeout 4802 req = NodeListRequest() 4803 req.meta.CopyFrom(ListRequestMetadata()) 4804 if self.parent.page_limit > 0: 4805 req.meta.limit = self.parent.page_limit 4806 if self.parent.snapshot_datetime is not None: 4807 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4808 4809 req.filter = plumbing.quote_filter_args(filter, *args) 4810 4811 def generator(svc, req): 4812 tries = 0 4813 while True: 4814 t = None if deadline is None else deadline - time.time() 4815 try: 4816 plumbing_response = svc.stub.List( 4817 req, 4818 metadata=svc.parent.get_metadata('Nodes.List', req), 4819 timeout=t) 4820 except Exception as e: 4821 if self.parent.shouldRetry(tries, e, deadline): 4822 tries += 1 4823 time.sleep( 4824 self.parent.exponentialBackoff(tries, deadline)) 4825 continue 4826 raise plumbing.convert_error_to_porcelain(e) from e 4827 tries = 0 4828 for plumbing_item in plumbing_response.nodes: 4829 yield plumbing.convert_node_to_porcelain(plumbing_item) 4830 if plumbing_response.meta.next_cursor == '': 4831 break 4832 req.meta.cursor = plumbing_response.meta.next_cursor 4833 4834 return generator(self, req) 4835 4836 def tcp_probe(self, node_id, host, port, timeout=None): 4837 ''' 4838 TCPProbe instructs a Node to connect to an address via TCP and report the 4839 result. 4840 ''' 4841 deadline = None if timeout is None else time.time() + timeout 4842 req = NodeTCPProbeRequest() 4843 4844 req.node_id = (node_id) 4845 req.host = (host) 4846 req.port = (port) 4847 tries = 0 4848 plumbing_response = None 4849 while True: 4850 t = None if deadline is None else deadline - time.time() 4851 try: 4852 plumbing_response = self.stub.TCPProbe( 4853 req, 4854 metadata=self.parent.get_metadata('Nodes.TCPProbe', req), 4855 timeout=t) 4856 except Exception as e: 4857 if self.parent.shouldRetry(tries, e, deadline): 4858 tries += 1 4859 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4860 continue 4861 raise plumbing.convert_error_to_porcelain(e) from e 4862 break 4863 4864 resp = models.NodeTCPProbeResponse() 4865 resp.error = (plumbing_response.error) 4866 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4867 plumbing_response.meta) 4868 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4869 plumbing_response.rate_limit) 4870 resp.succeeded = (plumbing_response.succeeded) 4871 return resp 4872 4873 4874class SnapshotNodes: 4875 ''' 4876 SnapshotNodes exposes the read only methods of the Nodes 4877 service for historical queries. 4878 ''' 4879 def __init__(self, nodes): 4880 self.nodes = nodes 4881 4882 def get(self, id, timeout=None): 4883 ''' 4884 Get reads one Node by ID. 4885 ''' 4886 return self.nodes.get(id, timeout=timeout) 4887 4888 def list(self, filter, *args, timeout=None): 4889 ''' 4890 List gets a list of Nodes matching a given set of criteria. 4891 ''' 4892 return self.nodes.list(filter, *args, timeout=timeout) 4893 4894 4895class NodesHistory: 4896 ''' 4897 NodesHistory records all changes to the state of a Node. 4898 See `strongdm.models.NodeHistory`. 4899 ''' 4900 def __init__(self, channel, client): 4901 self.parent = client 4902 self.stub = NodesHistoryStub(channel) 4903 4904 def list(self, filter, *args, timeout=None): 4905 ''' 4906 List gets a list of NodeHistory records matching a given set of criteria. 4907 ''' 4908 deadline = None if timeout is None else time.time() + timeout 4909 req = NodeHistoryListRequest() 4910 req.meta.CopyFrom(ListRequestMetadata()) 4911 if self.parent.page_limit > 0: 4912 req.meta.limit = self.parent.page_limit 4913 if self.parent.snapshot_datetime is not None: 4914 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4915 4916 req.filter = plumbing.quote_filter_args(filter, *args) 4917 4918 def generator(svc, req): 4919 tries = 0 4920 while True: 4921 t = None if deadline is None else deadline - time.time() 4922 try: 4923 plumbing_response = svc.stub.List( 4924 req, 4925 metadata=svc.parent.get_metadata( 4926 'NodesHistory.List', req), 4927 timeout=t) 4928 except Exception as e: 4929 if self.parent.shouldRetry(tries, e, deadline): 4930 tries += 1 4931 time.sleep( 4932 self.parent.exponentialBackoff(tries, deadline)) 4933 continue 4934 raise plumbing.convert_error_to_porcelain(e) from e 4935 tries = 0 4936 for plumbing_item in plumbing_response.history: 4937 yield plumbing.convert_node_history_to_porcelain( 4938 plumbing_item) 4939 if plumbing_response.meta.next_cursor == '': 4940 break 4941 req.meta.cursor = plumbing_response.meta.next_cursor 4942 4943 return generator(self, req) 4944 4945 4946class OrganizationHistory: 4947 ''' 4948 OrganizationHistory records all changes to the state of an Organization. 4949 See `strongdm.models.OrganizationHistoryRecord`. 4950 ''' 4951 def __init__(self, channel, client): 4952 self.parent = client 4953 self.stub = OrganizationHistoryStub(channel) 4954 4955 def list(self, filter, *args, timeout=None): 4956 ''' 4957 List gets a list of OrganizationHistory records matching a given set of criteria. 4958 ''' 4959 deadline = None if timeout is None else time.time() + timeout 4960 req = OrganizationHistoryListRequest() 4961 req.meta.CopyFrom(ListRequestMetadata()) 4962 if self.parent.page_limit > 0: 4963 req.meta.limit = self.parent.page_limit 4964 if self.parent.snapshot_datetime is not None: 4965 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4966 4967 req.filter = plumbing.quote_filter_args(filter, *args) 4968 4969 def generator(svc, req): 4970 tries = 0 4971 while True: 4972 t = None if deadline is None else deadline - time.time() 4973 try: 4974 plumbing_response = svc.stub.List( 4975 req, 4976 metadata=svc.parent.get_metadata( 4977 'OrganizationHistory.List', req), 4978 timeout=t) 4979 except Exception as e: 4980 if self.parent.shouldRetry(tries, e, deadline): 4981 tries += 1 4982 time.sleep( 4983 self.parent.exponentialBackoff(tries, deadline)) 4984 continue 4985 raise plumbing.convert_error_to_porcelain(e) from e 4986 tries = 0 4987 for plumbing_item in plumbing_response.history: 4988 yield plumbing.convert_organization_history_record_to_porcelain( 4989 plumbing_item) 4990 if plumbing_response.meta.next_cursor == '': 4991 break 4992 req.meta.cursor = plumbing_response.meta.next_cursor 4993 4994 return generator(self, req) 4995 4996 4997class Organizations: 4998 ''' 4999 Organizations exposes organization configuration. Most RPCs remain private to the 5000 go_private SDK; public MFA management is exposed to all public SDK targets. 5001 The terraform-provider target is opted out at the service level because the 5002 provider's data-source generator assumes every service has a List RPC; MFA is 5003 instead surfaced via a hand-written resource template. 5004 See `strongdm.models.Organization`. 5005 ''' 5006 def __init__(self, channel, client): 5007 self.parent = client 5008 self.stub = OrganizationsStub(channel) 5009 5010 def get_mfa(self, timeout=None): 5011 ''' 5012 GetMFA gets the organization's MFA configuration. 5013 ''' 5014 deadline = None if timeout is None else time.time() + timeout 5015 req = OrganizationGetMFARequest() 5016 5017 tries = 0 5018 plumbing_response = None 5019 while True: 5020 t = None if deadline is None else deadline - time.time() 5021 try: 5022 plumbing_response = self.stub.GetMFA( 5023 req, 5024 metadata=self.parent.get_metadata('Organizations.GetMFA', 5025 req), 5026 timeout=t) 5027 except Exception as e: 5028 if self.parent.shouldRetry(tries, e, deadline): 5029 tries += 1 5030 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5031 continue 5032 raise plumbing.convert_error_to_porcelain(e) from e 5033 break 5034 5035 resp = models.OrganizationGetMFAResponse() 5036 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5037 plumbing_response.meta) 5038 resp.mfa = plumbing.convert_mfa_config_to_porcelain( 5039 plumbing_response.mfa) 5040 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5041 plumbing_response.rate_limit) 5042 return resp 5043 5044 def update_mfa(self, mfa, timeout=None): 5045 ''' 5046 UpdateMFA updates the organization's MFA configuration. 5047 ''' 5048 deadline = None if timeout is None else time.time() + timeout 5049 req = OrganizationUpdateMFARequest() 5050 5051 if mfa is not None: 5052 req.mfa.CopyFrom(plumbing.convert_mfa_config_to_plumbing(mfa)) 5053 tries = 0 5054 plumbing_response = None 5055 while True: 5056 t = None if deadline is None else deadline - time.time() 5057 try: 5058 plumbing_response = self.stub.UpdateMFA( 5059 req, 5060 metadata=self.parent.get_metadata( 5061 'Organizations.UpdateMFA', req), 5062 timeout=t) 5063 except Exception as e: 5064 if self.parent.shouldRetry(tries, e, deadline): 5065 tries += 1 5066 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5067 continue 5068 raise plumbing.convert_error_to_porcelain(e) from e 5069 break 5070 5071 resp = models.OrganizationUpdateMFAResponse() 5072 resp.mfa = plumbing.convert_mfa_config_to_porcelain( 5073 plumbing_response.mfa) 5074 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5075 plumbing_response.rate_limit) 5076 return resp 5077 5078 def test_mfa(self, mfa, timeout=None): 5079 ''' 5080 TestMFA validates MFA connectivity without persisting changes. 5081 ''' 5082 deadline = None if timeout is None else time.time() + timeout 5083 req = OrganizationTestMFARequest() 5084 5085 if mfa is not None: 5086 req.mfa.CopyFrom(plumbing.convert_mfa_config_to_plumbing(mfa)) 5087 tries = 0 5088 plumbing_response = None 5089 while True: 5090 t = None if deadline is None else deadline - time.time() 5091 try: 5092 plumbing_response = self.stub.TestMFA( 5093 req, 5094 metadata=self.parent.get_metadata('Organizations.TestMFA', 5095 req), 5096 timeout=t) 5097 except Exception as e: 5098 if self.parent.shouldRetry(tries, e, deadline): 5099 tries += 1 5100 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5101 continue 5102 raise plumbing.convert_error_to_porcelain(e) from e 5103 break 5104 5105 resp = models.OrganizationTestMFAResponse() 5106 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5107 plumbing_response.rate_limit) 5108 return resp 5109 5110 5111class PeeringGroupNodes: 5112 ''' 5113 PeeringGroupNodes provides the building blocks necessary to obtain attach a node to a peering group. 5114 See `strongdm.models.PeeringGroupNode`. 5115 ''' 5116 def __init__(self, channel, client): 5117 self.parent = client 5118 self.stub = PeeringGroupNodesStub(channel) 5119 5120 def create(self, peering_group_node, timeout=None): 5121 ''' 5122 Create attaches a Node to a PeeringGroup 5123 ''' 5124 deadline = None if timeout is None else time.time() + timeout 5125 req = PeeringGroupNodeCreateRequest() 5126 5127 if peering_group_node is not None: 5128 req.peering_group_node.CopyFrom( 5129 plumbing.convert_peering_group_node_to_plumbing( 5130 peering_group_node)) 5131 tries = 0 5132 plumbing_response = None 5133 while True: 5134 t = None if deadline is None else deadline - time.time() 5135 try: 5136 plumbing_response = self.stub.Create( 5137 req, 5138 metadata=self.parent.get_metadata( 5139 'PeeringGroupNodes.Create', req), 5140 timeout=t) 5141 except Exception as e: 5142 if self.parent.shouldRetry(tries, e, deadline): 5143 tries += 1 5144 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5145 continue 5146 raise plumbing.convert_error_to_porcelain(e) from e 5147 break 5148 5149 resp = models.PeeringGroupNodeCreateResponse() 5150 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5151 plumbing_response.meta) 5152 resp.peering_group_node = plumbing.convert_peering_group_node_to_porcelain( 5153 plumbing_response.peering_group_node) 5154 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5155 plumbing_response.rate_limit) 5156 return resp 5157 5158 def delete(self, id, timeout=None): 5159 ''' 5160 Delete detaches a Node to a PeeringGroup. 5161 ''' 5162 deadline = None if timeout is None else time.time() + timeout 5163 req = PeeringGroupNodeDeleteRequest() 5164 5165 req.id = (id) 5166 tries = 0 5167 plumbing_response = None 5168 while True: 5169 t = None if deadline is None else deadline - time.time() 5170 try: 5171 plumbing_response = self.stub.Delete( 5172 req, 5173 metadata=self.parent.get_metadata( 5174 'PeeringGroupNodes.Delete', req), 5175 timeout=t) 5176 except Exception as e: 5177 if self.parent.shouldRetry(tries, e, deadline): 5178 tries += 1 5179 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5180 continue 5181 raise plumbing.convert_error_to_porcelain(e) from e 5182 break 5183 5184 resp = models.PeeringGroupNodeDeleteResponse() 5185 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 5186 plumbing_response.meta) 5187 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5188 plumbing_response.rate_limit) 5189 return resp 5190 5191 def get(self, id, timeout=None): 5192 ''' 5193 Get reads the information of one peering group to node attachment. 5194 ''' 5195 deadline = None if timeout is None else time.time() + timeout 5196 req = PeeringGroupNodeGetRequest() 5197 if self.parent.snapshot_datetime is not None: 5198 req.meta.CopyFrom(GetRequestMetadata()) 5199 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5200 5201 req.id = (id) 5202 tries = 0 5203 plumbing_response = None 5204 while True: 5205 t = None if deadline is None else deadline - time.time() 5206 try: 5207 plumbing_response = self.stub.Get( 5208 req, 5209 metadata=self.parent.get_metadata('PeeringGroupNodes.Get', 5210 req), 5211 timeout=t) 5212 except Exception as e: 5213 if self.parent.shouldRetry(tries, e, deadline): 5214 tries += 1 5215 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5216 continue 5217 raise plumbing.convert_error_to_porcelain(e) from e 5218 break 5219 5220 resp = models.PeeringGroupNodeGetResponse() 5221 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5222 plumbing_response.meta) 5223 resp.peering_group_node = plumbing.convert_peering_group_node_to_porcelain( 5224 plumbing_response.peering_group_node) 5225 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5226 plumbing_response.rate_limit) 5227 return resp 5228 5229 def list(self, filter, *args, timeout=None): 5230 ''' 5231 List gets a list of peering group node attachments. 5232 ''' 5233 deadline = None if timeout is None else time.time() + timeout 5234 req = PeeringGroupNodeListRequest() 5235 req.meta.CopyFrom(ListRequestMetadata()) 5236 if self.parent.page_limit > 0: 5237 req.meta.limit = self.parent.page_limit 5238 if self.parent.snapshot_datetime is not None: 5239 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5240 5241 req.filter = plumbing.quote_filter_args(filter, *args) 5242 5243 def generator(svc, req): 5244 tries = 0 5245 while True: 5246 t = None if deadline is None else deadline - time.time() 5247 try: 5248 plumbing_response = svc.stub.List( 5249 req, 5250 metadata=svc.parent.get_metadata( 5251 'PeeringGroupNodes.List', req), 5252 timeout=t) 5253 except Exception as e: 5254 if self.parent.shouldRetry(tries, e, deadline): 5255 tries += 1 5256 time.sleep( 5257 self.parent.exponentialBackoff(tries, deadline)) 5258 continue 5259 raise plumbing.convert_error_to_porcelain(e) from e 5260 tries = 0 5261 for plumbing_item in plumbing_response.peering_group_nodes: 5262 yield plumbing.convert_peering_group_node_to_porcelain( 5263 plumbing_item) 5264 if plumbing_response.meta.next_cursor == '': 5265 break 5266 req.meta.cursor = plumbing_response.meta.next_cursor 5267 5268 return generator(self, req) 5269 5270 5271class PeeringGroupPeers: 5272 ''' 5273 PeeringGroupPeers provides the building blocks necessary to link two peering groups. 5274 See `strongdm.models.PeeringGroupPeer`. 5275 ''' 5276 def __init__(self, channel, client): 5277 self.parent = client 5278 self.stub = PeeringGroupPeersStub(channel) 5279 5280 def create(self, peering_group_peer, timeout=None): 5281 ''' 5282 Create links two peering groups. 5283 ''' 5284 deadline = None if timeout is None else time.time() + timeout 5285 req = PeeringGroupPeerCreateRequest() 5286 5287 if peering_group_peer is not None: 5288 req.peering_group_peer.CopyFrom( 5289 plumbing.convert_peering_group_peer_to_plumbing( 5290 peering_group_peer)) 5291 tries = 0 5292 plumbing_response = None 5293 while True: 5294 t = None if deadline is None else deadline - time.time() 5295 try: 5296 plumbing_response = self.stub.Create( 5297 req, 5298 metadata=self.parent.get_metadata( 5299 'PeeringGroupPeers.Create', req), 5300 timeout=t) 5301 except Exception as e: 5302 if self.parent.shouldRetry(tries, e, deadline): 5303 tries += 1 5304 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5305 continue 5306 raise plumbing.convert_error_to_porcelain(e) from e 5307 break 5308 5309 resp = models.PeeringGroupPeerCreateResponse() 5310 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5311 plumbing_response.meta) 5312 resp.peering_group_peer = plumbing.convert_peering_group_peer_to_porcelain( 5313 plumbing_response.peering_group_peer) 5314 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5315 plumbing_response.rate_limit) 5316 return resp 5317 5318 def delete(self, id, timeout=None): 5319 ''' 5320 Delete unlinks two peering groups. 5321 ''' 5322 deadline = None if timeout is None else time.time() + timeout 5323 req = PeeringGroupPeerDeleteRequest() 5324 5325 req.id = (id) 5326 tries = 0 5327 plumbing_response = None 5328 while True: 5329 t = None if deadline is None else deadline - time.time() 5330 try: 5331 plumbing_response = self.stub.Delete( 5332 req, 5333 metadata=self.parent.get_metadata( 5334 'PeeringGroupPeers.Delete', req), 5335 timeout=t) 5336 except Exception as e: 5337 if self.parent.shouldRetry(tries, e, deadline): 5338 tries += 1 5339 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5340 continue 5341 raise plumbing.convert_error_to_porcelain(e) from e 5342 break 5343 5344 resp = models.PeeringGroupPeerDeleteResponse() 5345 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 5346 plumbing_response.meta) 5347 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5348 plumbing_response.rate_limit) 5349 return resp 5350 5351 def get(self, id, timeout=None): 5352 ''' 5353 Get reads the information of one peering group link. 5354 ''' 5355 deadline = None if timeout is None else time.time() + timeout 5356 req = PeeringGroupPeerGetRequest() 5357 if self.parent.snapshot_datetime is not None: 5358 req.meta.CopyFrom(GetRequestMetadata()) 5359 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5360 5361 req.id = (id) 5362 tries = 0 5363 plumbing_response = None 5364 while True: 5365 t = None if deadline is None else deadline - time.time() 5366 try: 5367 plumbing_response = self.stub.Get( 5368 req, 5369 metadata=self.parent.get_metadata('PeeringGroupPeers.Get', 5370 req), 5371 timeout=t) 5372 except Exception as e: 5373 if self.parent.shouldRetry(tries, e, deadline): 5374 tries += 1 5375 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5376 continue 5377 raise plumbing.convert_error_to_porcelain(e) from e 5378 break 5379 5380 resp = models.PeeringGroupPeerGetResponse() 5381 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5382 plumbing_response.meta) 5383 resp.peering_group_peer = plumbing.convert_peering_group_peer_to_porcelain( 5384 plumbing_response.peering_group_peer) 5385 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5386 plumbing_response.rate_limit) 5387 return resp 5388 5389 def list(self, filter, *args, timeout=None): 5390 ''' 5391 List gets a list of peering group links. 5392 ''' 5393 deadline = None if timeout is None else time.time() + timeout 5394 req = PeeringGroupPeerListRequest() 5395 req.meta.CopyFrom(ListRequestMetadata()) 5396 if self.parent.page_limit > 0: 5397 req.meta.limit = self.parent.page_limit 5398 if self.parent.snapshot_datetime is not None: 5399 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5400 5401 req.filter = plumbing.quote_filter_args(filter, *args) 5402 5403 def generator(svc, req): 5404 tries = 0 5405 while True: 5406 t = None if deadline is None else deadline - time.time() 5407 try: 5408 plumbing_response = svc.stub.List( 5409 req, 5410 metadata=svc.parent.get_metadata( 5411 'PeeringGroupPeers.List', req), 5412 timeout=t) 5413 except Exception as e: 5414 if self.parent.shouldRetry(tries, e, deadline): 5415 tries += 1 5416 time.sleep( 5417 self.parent.exponentialBackoff(tries, deadline)) 5418 continue 5419 raise plumbing.convert_error_to_porcelain(e) from e 5420 tries = 0 5421 for plumbing_item in plumbing_response.peering_group_peers: 5422 yield plumbing.convert_peering_group_peer_to_porcelain( 5423 plumbing_item) 5424 if plumbing_response.meta.next_cursor == '': 5425 break 5426 req.meta.cursor = plumbing_response.meta.next_cursor 5427 5428 return generator(self, req) 5429 5430 5431class PeeringGroupResources: 5432 ''' 5433 PeeringGroupResources provides the building blocks necessary to obtain attach a resource to a peering group. 5434 See `strongdm.models.PeeringGroupResource`. 5435 ''' 5436 def __init__(self, channel, client): 5437 self.parent = client 5438 self.stub = PeeringGroupResourcesStub(channel) 5439 5440 def create(self, peering_group_resource, timeout=None): 5441 ''' 5442 Create attaches a Resource to a PeeringGroup 5443 ''' 5444 deadline = None if timeout is None else time.time() + timeout 5445 req = PeeringGroupResourceCreateRequest() 5446 5447 if peering_group_resource is not None: 5448 req.peering_group_resource.CopyFrom( 5449 plumbing.convert_peering_group_resource_to_plumbing( 5450 peering_group_resource)) 5451 tries = 0 5452 plumbing_response = None 5453 while True: 5454 t = None if deadline is None else deadline - time.time() 5455 try: 5456 plumbing_response = self.stub.Create( 5457 req, 5458 metadata=self.parent.get_metadata( 5459 'PeeringGroupResources.Create', req), 5460 timeout=t) 5461 except Exception as e: 5462 if self.parent.shouldRetry(tries, e, deadline): 5463 tries += 1 5464 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5465 continue 5466 raise plumbing.convert_error_to_porcelain(e) from e 5467 break 5468 5469 resp = models.PeeringGroupResourceCreateResponse() 5470 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5471 plumbing_response.meta) 5472 resp.peering_group_resource = plumbing.convert_peering_group_resource_to_porcelain( 5473 plumbing_response.peering_group_resource) 5474 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5475 plumbing_response.rate_limit) 5476 return resp 5477 5478 def delete(self, id, timeout=None): 5479 ''' 5480 Delete detaches a Resource to a PeeringGroup 5481 ''' 5482 deadline = None if timeout is None else time.time() + timeout 5483 req = PeeringGroupResourceDeleteRequest() 5484 5485 req.id = (id) 5486 tries = 0 5487 plumbing_response = None 5488 while True: 5489 t = None if deadline is None else deadline - time.time() 5490 try: 5491 plumbing_response = self.stub.Delete( 5492 req, 5493 metadata=self.parent.get_metadata( 5494 'PeeringGroupResources.Delete', req), 5495 timeout=t) 5496 except Exception as e: 5497 if self.parent.shouldRetry(tries, e, deadline): 5498 tries += 1 5499 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5500 continue 5501 raise plumbing.convert_error_to_porcelain(e) from e 5502 break 5503 5504 resp = models.PeeringGroupResourceDeleteResponse() 5505 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 5506 plumbing_response.meta) 5507 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5508 plumbing_response.rate_limit) 5509 return resp 5510 5511 def get(self, id, timeout=None): 5512 ''' 5513 Get reads the information of one peering group to resource attachment. 5514 ''' 5515 deadline = None if timeout is None else time.time() + timeout 5516 req = PeeringGroupResourceGetRequest() 5517 if self.parent.snapshot_datetime is not None: 5518 req.meta.CopyFrom(GetRequestMetadata()) 5519 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5520 5521 req.id = (id) 5522 tries = 0 5523 plumbing_response = None 5524 while True: 5525 t = None if deadline is None else deadline - time.time() 5526 try: 5527 plumbing_response = self.stub.Get( 5528 req, 5529 metadata=self.parent.get_metadata( 5530 'PeeringGroupResources.Get', req), 5531 timeout=t) 5532 except Exception as e: 5533 if self.parent.shouldRetry(tries, e, deadline): 5534 tries += 1 5535 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5536 continue 5537 raise plumbing.convert_error_to_porcelain(e) from e 5538 break 5539 5540 resp = models.PeeringGroupResourceGetResponse() 5541 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5542 plumbing_response.meta) 5543 resp.peering_group_resource = plumbing.convert_peering_group_resource_to_porcelain( 5544 plumbing_response.peering_group_resource) 5545 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5546 plumbing_response.rate_limit) 5547 return resp 5548 5549 def list(self, filter, *args, timeout=None): 5550 ''' 5551 List gets a list of peering group resource attachments. 5552 ''' 5553 deadline = None if timeout is None else time.time() + timeout 5554 req = PeeringGroupResourceListRequest() 5555 req.meta.CopyFrom(ListRequestMetadata()) 5556 if self.parent.page_limit > 0: 5557 req.meta.limit = self.parent.page_limit 5558 if self.parent.snapshot_datetime is not None: 5559 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5560 5561 req.filter = plumbing.quote_filter_args(filter, *args) 5562 5563 def generator(svc, req): 5564 tries = 0 5565 while True: 5566 t = None if deadline is None else deadline - time.time() 5567 try: 5568 plumbing_response = svc.stub.List( 5569 req, 5570 metadata=svc.parent.get_metadata( 5571 'PeeringGroupResources.List', req), 5572 timeout=t) 5573 except Exception as e: 5574 if self.parent.shouldRetry(tries, e, deadline): 5575 tries += 1 5576 time.sleep( 5577 self.parent.exponentialBackoff(tries, deadline)) 5578 continue 5579 raise plumbing.convert_error_to_porcelain(e) from e 5580 tries = 0 5581 for plumbing_item in plumbing_response.peering_group_resources: 5582 yield plumbing.convert_peering_group_resource_to_porcelain( 5583 plumbing_item) 5584 if plumbing_response.meta.next_cursor == '': 5585 break 5586 req.meta.cursor = plumbing_response.meta.next_cursor 5587 5588 return generator(self, req) 5589 5590 5591class PeeringGroups: 5592 ''' 5593 PeeringGroups provides the building blocks necessary to obtain explicit network topology and routing. 5594 See `strongdm.models.PeeringGroup`. 5595 ''' 5596 def __init__(self, channel, client): 5597 self.parent = client 5598 self.stub = PeeringGroupsStub(channel) 5599 5600 def create(self, peering_group, timeout=None): 5601 ''' 5602 Create registers a new PeeringGroup. 5603 ''' 5604 deadline = None if timeout is None else time.time() + timeout 5605 req = PeeringGroupCreateRequest() 5606 5607 if peering_group is not None: 5608 req.peering_group.CopyFrom( 5609 plumbing.convert_peering_group_to_plumbing(peering_group)) 5610 tries = 0 5611 plumbing_response = None 5612 while True: 5613 t = None if deadline is None else deadline - time.time() 5614 try: 5615 plumbing_response = self.stub.Create( 5616 req, 5617 metadata=self.parent.get_metadata('PeeringGroups.Create', 5618 req), 5619 timeout=t) 5620 except Exception as e: 5621 if self.parent.shouldRetry(tries, e, deadline): 5622 tries += 1 5623 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5624 continue 5625 raise plumbing.convert_error_to_porcelain(e) from e 5626 break 5627 5628 resp = models.PeeringGroupCreateResponse() 5629 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5630 plumbing_response.meta) 5631 resp.peering_group = plumbing.convert_peering_group_to_porcelain( 5632 plumbing_response.peering_group) 5633 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5634 plumbing_response.rate_limit) 5635 return resp 5636 5637 def delete(self, id, timeout=None): 5638 ''' 5639 Delete removes a PeeringGroup by ID. 5640 ''' 5641 deadline = None if timeout is None else time.time() + timeout 5642 req = PeeringGroupDeleteRequest() 5643 5644 req.id = (id) 5645 tries = 0 5646 plumbing_response = None 5647 while True: 5648 t = None if deadline is None else deadline - time.time() 5649 try: 5650 plumbing_response = self.stub.Delete( 5651 req, 5652 metadata=self.parent.get_metadata('PeeringGroups.Delete', 5653 req), 5654 timeout=t) 5655 except Exception as e: 5656 if self.parent.shouldRetry(tries, e, deadline): 5657 tries += 1 5658 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5659 continue 5660 raise plumbing.convert_error_to_porcelain(e) from e 5661 break 5662 5663 resp = models.PeeringGroupDeleteResponse() 5664 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 5665 plumbing_response.meta) 5666 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5667 plumbing_response.rate_limit) 5668 return resp 5669 5670 def get(self, id, timeout=None): 5671 ''' 5672 Get reads one PeeringGroup by ID. It will load all its dependencies. 5673 ''' 5674 deadline = None if timeout is None else time.time() + timeout 5675 req = PeeringGroupGetRequest() 5676 if self.parent.snapshot_datetime is not None: 5677 req.meta.CopyFrom(GetRequestMetadata()) 5678 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5679 5680 req.id = (id) 5681 tries = 0 5682 plumbing_response = None 5683 while True: 5684 t = None if deadline is None else deadline - time.time() 5685 try: 5686 plumbing_response = self.stub.Get( 5687 req, 5688 metadata=self.parent.get_metadata('PeeringGroups.Get', 5689 req), 5690 timeout=t) 5691 except Exception as e: 5692 if self.parent.shouldRetry(tries, e, deadline): 5693 tries += 1 5694 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5695 continue 5696 raise plumbing.convert_error_to_porcelain(e) from e 5697 break 5698 5699 resp = models.PeeringGroupGetResponse() 5700 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5701 plumbing_response.meta) 5702 resp.peering_group = plumbing.convert_peering_group_to_porcelain( 5703 plumbing_response.peering_group) 5704 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5705 plumbing_response.rate_limit) 5706 return resp 5707 5708 def list(self, filter, *args, timeout=None): 5709 ''' 5710 List gets a list of Peering Groups. 5711 ''' 5712 deadline = None if timeout is None else time.time() + timeout 5713 req = PeeringGroupListRequest() 5714 req.meta.CopyFrom(ListRequestMetadata()) 5715 if self.parent.page_limit > 0: 5716 req.meta.limit = self.parent.page_limit 5717 if self.parent.snapshot_datetime is not None: 5718 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5719 5720 req.filter = plumbing.quote_filter_args(filter, *args) 5721 5722 def generator(svc, req): 5723 tries = 0 5724 while True: 5725 t = None if deadline is None else deadline - time.time() 5726 try: 5727 plumbing_response = svc.stub.List( 5728 req, 5729 metadata=svc.parent.get_metadata( 5730 'PeeringGroups.List', req), 5731 timeout=t) 5732 except Exception as e: 5733 if self.parent.shouldRetry(tries, e, deadline): 5734 tries += 1 5735 time.sleep( 5736 self.parent.exponentialBackoff(tries, deadline)) 5737 continue 5738 raise plumbing.convert_error_to_porcelain(e) from e 5739 tries = 0 5740 for plumbing_item in plumbing_response.peering_groups: 5741 yield plumbing.convert_peering_group_to_porcelain( 5742 plumbing_item) 5743 if plumbing_response.meta.next_cursor == '': 5744 break 5745 req.meta.cursor = plumbing_response.meta.next_cursor 5746 5747 return generator(self, req) 5748 5749 5750class Policies: 5751 ''' 5752 Policies are the collection of one or more statements that enforce fine-grained access 5753 control for the users of an organization. 5754 See `strongdm.models.Policy`. 5755 ''' 5756 def __init__(self, channel, client): 5757 self.parent = client 5758 self.stub = PoliciesStub(channel) 5759 5760 def create(self, policy, timeout=None): 5761 ''' 5762 Create creates a new Policy. 5763 ''' 5764 deadline = None if timeout is None else time.time() + timeout 5765 req = PolicyCreateRequest() 5766 5767 if policy is not None: 5768 req.policy.CopyFrom(plumbing.convert_policy_to_plumbing(policy)) 5769 tries = 0 5770 plumbing_response = None 5771 while True: 5772 t = None if deadline is None else deadline - time.time() 5773 try: 5774 plumbing_response = self.stub.Create( 5775 req, 5776 metadata=self.parent.get_metadata('Policies.Create', req), 5777 timeout=t) 5778 except Exception as e: 5779 if self.parent.shouldRetry(tries, e, deadline): 5780 tries += 1 5781 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5782 continue 5783 raise plumbing.convert_error_to_porcelain(e) from e 5784 break 5785 5786 resp = models.PolicyCreateResponse() 5787 resp.policy = plumbing.convert_policy_to_porcelain( 5788 plumbing_response.policy) 5789 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5790 plumbing_response.rate_limit) 5791 return resp 5792 5793 def delete(self, id, timeout=None): 5794 ''' 5795 Delete removes a Policy by ID. 5796 ''' 5797 deadline = None if timeout is None else time.time() + timeout 5798 req = PolicyDeleteRequest() 5799 5800 req.id = (id) 5801 tries = 0 5802 plumbing_response = None 5803 while True: 5804 t = None if deadline is None else deadline - time.time() 5805 try: 5806 plumbing_response = self.stub.Delete( 5807 req, 5808 metadata=self.parent.get_metadata('Policies.Delete', req), 5809 timeout=t) 5810 except Exception as e: 5811 if self.parent.shouldRetry(tries, e, deadline): 5812 tries += 1 5813 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5814 continue 5815 raise plumbing.convert_error_to_porcelain(e) from e 5816 break 5817 5818 resp = models.PolicyDeleteResponse() 5819 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5820 plumbing_response.rate_limit) 5821 return resp 5822 5823 def update(self, policy, timeout=None): 5824 ''' 5825 Update replaces all the fields of a Policy by ID. 5826 ''' 5827 deadline = None if timeout is None else time.time() + timeout 5828 req = PolicyUpdateRequest() 5829 5830 if policy is not None: 5831 req.policy.CopyFrom(plumbing.convert_policy_to_plumbing(policy)) 5832 tries = 0 5833 plumbing_response = None 5834 while True: 5835 t = None if deadline is None else deadline - time.time() 5836 try: 5837 plumbing_response = self.stub.Update( 5838 req, 5839 metadata=self.parent.get_metadata('Policies.Update', req), 5840 timeout=t) 5841 except Exception as e: 5842 if self.parent.shouldRetry(tries, e, deadline): 5843 tries += 1 5844 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5845 continue 5846 raise plumbing.convert_error_to_porcelain(e) from e 5847 break 5848 5849 resp = models.PolicyUpdateResponse() 5850 resp.policy = plumbing.convert_policy_to_porcelain( 5851 plumbing_response.policy) 5852 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5853 plumbing_response.rate_limit) 5854 return resp 5855 5856 def get(self, id, timeout=None): 5857 ''' 5858 Get reads one Policy by ID. 5859 ''' 5860 deadline = None if timeout is None else time.time() + timeout 5861 req = PolicyGetRequest() 5862 if self.parent.snapshot_datetime is not None: 5863 req.meta.CopyFrom(GetRequestMetadata()) 5864 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5865 5866 req.id = (id) 5867 tries = 0 5868 plumbing_response = None 5869 while True: 5870 t = None if deadline is None else deadline - time.time() 5871 try: 5872 plumbing_response = self.stub.Get( 5873 req, 5874 metadata=self.parent.get_metadata('Policies.Get', req), 5875 timeout=t) 5876 except Exception as e: 5877 if self.parent.shouldRetry(tries, e, deadline): 5878 tries += 1 5879 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5880 continue 5881 raise plumbing.convert_error_to_porcelain(e) from e 5882 break 5883 5884 resp = models.PolicyGetResponse() 5885 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5886 plumbing_response.meta) 5887 resp.policy = plumbing.convert_policy_to_porcelain( 5888 plumbing_response.policy) 5889 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5890 plumbing_response.rate_limit) 5891 return resp 5892 5893 def list(self, filter, *args, timeout=None): 5894 ''' 5895 List gets a list of Policy matching a given set of criteria 5896 ''' 5897 deadline = None if timeout is None else time.time() + timeout 5898 req = PolicyListRequest() 5899 req.meta.CopyFrom(ListRequestMetadata()) 5900 if self.parent.page_limit > 0: 5901 req.meta.limit = self.parent.page_limit 5902 if self.parent.snapshot_datetime is not None: 5903 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5904 5905 req.filter = plumbing.quote_filter_args(filter, *args) 5906 5907 def generator(svc, req): 5908 tries = 0 5909 while True: 5910 t = None if deadline is None else deadline - time.time() 5911 try: 5912 plumbing_response = svc.stub.List( 5913 req, 5914 metadata=svc.parent.get_metadata('Policies.List', req), 5915 timeout=t) 5916 except Exception as e: 5917 if self.parent.shouldRetry(tries, e, deadline): 5918 tries += 1 5919 time.sleep( 5920 self.parent.exponentialBackoff(tries, deadline)) 5921 continue 5922 raise plumbing.convert_error_to_porcelain(e) from e 5923 tries = 0 5924 for plumbing_item in plumbing_response.policies: 5925 yield plumbing.convert_policy_to_porcelain(plumbing_item) 5926 if plumbing_response.meta.next_cursor == '': 5927 break 5928 req.meta.cursor = plumbing_response.meta.next_cursor 5929 5930 return generator(self, req) 5931 5932 5933class SnapshotPolicies: 5934 ''' 5935 SnapshotPolicies exposes the read only methods of the Policies 5936 service for historical queries. 5937 ''' 5938 def __init__(self, policies): 5939 self.policies = policies 5940 5941 def get(self, id, timeout=None): 5942 ''' 5943 Get reads one Policy by ID. 5944 ''' 5945 return self.policies.get(id, timeout=timeout) 5946 5947 def list(self, filter, *args, timeout=None): 5948 ''' 5949 List gets a list of Policy matching a given set of criteria 5950 ''' 5951 return self.policies.list(filter, *args, timeout=timeout) 5952 5953 5954class PoliciesHistory: 5955 ''' 5956 PoliciesHistory records all changes to the state of a Policy. 5957 See `strongdm.models.PolicyHistory`. 5958 ''' 5959 def __init__(self, channel, client): 5960 self.parent = client 5961 self.stub = PoliciesHistoryStub(channel) 5962 5963 def list(self, filter, *args, timeout=None): 5964 ''' 5965 List gets a list of PolicyHistory records matching a given set of criteria. 5966 ''' 5967 deadline = None if timeout is None else time.time() + timeout 5968 req = PoliciesHistoryListRequest() 5969 req.meta.CopyFrom(ListRequestMetadata()) 5970 if self.parent.page_limit > 0: 5971 req.meta.limit = self.parent.page_limit 5972 if self.parent.snapshot_datetime is not None: 5973 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5974 5975 req.filter = plumbing.quote_filter_args(filter, *args) 5976 5977 def generator(svc, req): 5978 tries = 0 5979 while True: 5980 t = None if deadline is None else deadline - time.time() 5981 try: 5982 plumbing_response = svc.stub.List( 5983 req, 5984 metadata=svc.parent.get_metadata( 5985 'PoliciesHistory.List', req), 5986 timeout=t) 5987 except Exception as e: 5988 if self.parent.shouldRetry(tries, e, deadline): 5989 tries += 1 5990 time.sleep( 5991 self.parent.exponentialBackoff(tries, deadline)) 5992 continue 5993 raise plumbing.convert_error_to_porcelain(e) from e 5994 tries = 0 5995 for plumbing_item in plumbing_response.history: 5996 yield plumbing.convert_policy_history_to_porcelain( 5997 plumbing_item) 5998 if plumbing_response.meta.next_cursor == '': 5999 break 6000 req.meta.cursor = plumbing_response.meta.next_cursor 6001 6002 return generator(self, req) 6003 6004 6005class ProxyClusterKeys: 6006 ''' 6007 Proxy Cluster Keys are authentication keys for all proxies within a cluster. 6008 The proxies within a cluster share the same key. One cluster can have 6009 multiple keys in order to facilitate key rotation. 6010 See `strongdm.models.ProxyClusterKey`. 6011 ''' 6012 def __init__(self, channel, client): 6013 self.parent = client 6014 self.stub = ProxyClusterKeysStub(channel) 6015 6016 def create(self, proxy_cluster_key, timeout=None): 6017 ''' 6018 Create registers a new ProxyClusterKey. 6019 ''' 6020 deadline = None if timeout is None else time.time() + timeout 6021 req = ProxyClusterKeyCreateRequest() 6022 6023 if proxy_cluster_key is not None: 6024 req.proxy_cluster_key.CopyFrom( 6025 plumbing.convert_proxy_cluster_key_to_plumbing( 6026 proxy_cluster_key)) 6027 tries = 0 6028 plumbing_response = None 6029 while True: 6030 t = None if deadline is None else deadline - time.time() 6031 try: 6032 plumbing_response = self.stub.Create( 6033 req, 6034 metadata=self.parent.get_metadata( 6035 'ProxyClusterKeys.Create', req), 6036 timeout=t) 6037 except Exception as e: 6038 if self.parent.shouldRetry(tries, e, deadline): 6039 tries += 1 6040 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6041 continue 6042 raise plumbing.convert_error_to_porcelain(e) from e 6043 break 6044 6045 resp = models.ProxyClusterKeyCreateResponse() 6046 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 6047 plumbing_response.meta) 6048 resp.proxy_cluster_key = plumbing.convert_proxy_cluster_key_to_porcelain( 6049 plumbing_response.proxy_cluster_key) 6050 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6051 plumbing_response.rate_limit) 6052 resp.secret_key = (plumbing_response.secret_key) 6053 return resp 6054 6055 def get(self, id, timeout=None): 6056 ''' 6057 Get reads one ProxyClusterKey by ID. 6058 ''' 6059 deadline = None if timeout is None else time.time() + timeout 6060 req = ProxyClusterKeyGetRequest() 6061 if self.parent.snapshot_datetime is not None: 6062 req.meta.CopyFrom(GetRequestMetadata()) 6063 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6064 6065 req.id = (id) 6066 tries = 0 6067 plumbing_response = None 6068 while True: 6069 t = None if deadline is None else deadline - time.time() 6070 try: 6071 plumbing_response = self.stub.Get( 6072 req, 6073 metadata=self.parent.get_metadata('ProxyClusterKeys.Get', 6074 req), 6075 timeout=t) 6076 except Exception as e: 6077 if self.parent.shouldRetry(tries, e, deadline): 6078 tries += 1 6079 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6080 continue 6081 raise plumbing.convert_error_to_porcelain(e) from e 6082 break 6083 6084 resp = models.ProxyClusterKeyGetResponse() 6085 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 6086 plumbing_response.meta) 6087 resp.proxy_cluster_key = plumbing.convert_proxy_cluster_key_to_porcelain( 6088 plumbing_response.proxy_cluster_key) 6089 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6090 plumbing_response.rate_limit) 6091 return resp 6092 6093 def delete(self, id, timeout=None): 6094 ''' 6095 Delete removes a ProxyClusterKey by ID. 6096 ''' 6097 deadline = None if timeout is None else time.time() + timeout 6098 req = ProxyClusterKeyDeleteRequest() 6099 6100 req.id = (id) 6101 tries = 0 6102 plumbing_response = None 6103 while True: 6104 t = None if deadline is None else deadline - time.time() 6105 try: 6106 plumbing_response = self.stub.Delete( 6107 req, 6108 metadata=self.parent.get_metadata( 6109 'ProxyClusterKeys.Delete', req), 6110 timeout=t) 6111 except Exception as e: 6112 if self.parent.shouldRetry(tries, e, deadline): 6113 tries += 1 6114 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6115 continue 6116 raise plumbing.convert_error_to_porcelain(e) from e 6117 break 6118 6119 resp = models.ProxyClusterKeyDeleteResponse() 6120 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 6121 plumbing_response.meta) 6122 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6123 plumbing_response.rate_limit) 6124 return resp 6125 6126 def list(self, filter, *args, timeout=None): 6127 ''' 6128 List gets a list of ProxyClusterKeys matching a given set of criteria. 6129 ''' 6130 deadline = None if timeout is None else time.time() + timeout 6131 req = ProxyClusterKeyListRequest() 6132 req.meta.CopyFrom(ListRequestMetadata()) 6133 if self.parent.page_limit > 0: 6134 req.meta.limit = self.parent.page_limit 6135 if self.parent.snapshot_datetime is not None: 6136 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6137 6138 req.filter = plumbing.quote_filter_args(filter, *args) 6139 6140 def generator(svc, req): 6141 tries = 0 6142 while True: 6143 t = None if deadline is None else deadline - time.time() 6144 try: 6145 plumbing_response = svc.stub.List( 6146 req, 6147 metadata=svc.parent.get_metadata( 6148 'ProxyClusterKeys.List', req), 6149 timeout=t) 6150 except Exception as e: 6151 if self.parent.shouldRetry(tries, e, deadline): 6152 tries += 1 6153 time.sleep( 6154 self.parent.exponentialBackoff(tries, deadline)) 6155 continue 6156 raise plumbing.convert_error_to_porcelain(e) from e 6157 tries = 0 6158 for plumbing_item in plumbing_response.proxy_cluster_keys: 6159 yield plumbing.convert_proxy_cluster_key_to_porcelain( 6160 plumbing_item) 6161 if plumbing_response.meta.next_cursor == '': 6162 break 6163 req.meta.cursor = plumbing_response.meta.next_cursor 6164 6165 return generator(self, req) 6166 6167 6168class SnapshotProxyClusterKeys: 6169 ''' 6170 SnapshotProxyClusterKeys exposes the read only methods of the ProxyClusterKeys 6171 service for historical queries. 6172 ''' 6173 def __init__(self, proxy_cluster_keys): 6174 self.proxy_cluster_keys = proxy_cluster_keys 6175 6176 def get(self, id, timeout=None): 6177 ''' 6178 Get reads one ProxyClusterKey by ID. 6179 ''' 6180 return self.proxy_cluster_keys.get(id, timeout=timeout) 6181 6182 def list(self, filter, *args, timeout=None): 6183 ''' 6184 List gets a list of ProxyClusterKeys matching a given set of criteria. 6185 ''' 6186 return self.proxy_cluster_keys.list(filter, *args, timeout=timeout) 6187 6188 6189class Queries: 6190 ''' 6191 A Query is a record of a single client request to a resource, such as a SQL query. 6192 Long-running SSH, RDP, or Kubernetes interactive sessions also count as queries. 6193 The Queries service is read-only. 6194 See `strongdm.models.Query`. 6195 ''' 6196 def __init__(self, channel, client): 6197 self.parent = client 6198 self.stub = QueriesStub(channel) 6199 6200 def list(self, filter, *args, timeout=None): 6201 ''' 6202 List gets a list of Queries matching a given set of criteria. 6203 ''' 6204 deadline = None if timeout is None else time.time() + timeout 6205 req = QueryListRequest() 6206 req.meta.CopyFrom(ListRequestMetadata()) 6207 if self.parent.page_limit > 0: 6208 req.meta.limit = self.parent.page_limit 6209 if self.parent.snapshot_datetime is not None: 6210 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6211 6212 req.filter = plumbing.quote_filter_args(filter, *args) 6213 6214 def generator(svc, req): 6215 tries = 0 6216 while True: 6217 t = None if deadline is None else deadline - time.time() 6218 try: 6219 plumbing_response = svc.stub.List( 6220 req, 6221 metadata=svc.parent.get_metadata('Queries.List', req), 6222 timeout=t) 6223 except Exception as e: 6224 if self.parent.shouldRetry(tries, e, deadline): 6225 tries += 1 6226 time.sleep( 6227 self.parent.exponentialBackoff(tries, deadline)) 6228 continue 6229 raise plumbing.convert_error_to_porcelain(e) from e 6230 tries = 0 6231 for plumbing_item in plumbing_response.queries: 6232 yield plumbing.convert_query_to_porcelain(plumbing_item) 6233 if plumbing_response.meta.next_cursor == '': 6234 break 6235 req.meta.cursor = plumbing_response.meta.next_cursor 6236 6237 return generator(self, req) 6238 6239 6240class RemoteIdentities: 6241 ''' 6242 RemoteIdentities assign a resource directly to an account, giving the account the permission to connect to that resource. 6243 See `strongdm.models.RemoteIdentity`. 6244 ''' 6245 def __init__(self, channel, client): 6246 self.parent = client 6247 self.stub = RemoteIdentitiesStub(channel) 6248 6249 def create(self, remote_identity, timeout=None): 6250 ''' 6251 Create registers a new RemoteIdentity. 6252 ''' 6253 deadline = None if timeout is None else time.time() + timeout 6254 req = RemoteIdentityCreateRequest() 6255 6256 if remote_identity is not None: 6257 req.remote_identity.CopyFrom( 6258 plumbing.convert_remote_identity_to_plumbing(remote_identity)) 6259 tries = 0 6260 plumbing_response = None 6261 while True: 6262 t = None if deadline is None else deadline - time.time() 6263 try: 6264 plumbing_response = self.stub.Create( 6265 req, 6266 metadata=self.parent.get_metadata( 6267 'RemoteIdentities.Create', req), 6268 timeout=t) 6269 except Exception as e: 6270 if self.parent.shouldRetry(tries, e, deadline): 6271 tries += 1 6272 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6273 continue 6274 raise plumbing.convert_error_to_porcelain(e) from e 6275 break 6276 6277 resp = models.RemoteIdentityCreateResponse() 6278 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 6279 plumbing_response.meta) 6280 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6281 plumbing_response.rate_limit) 6282 resp.remote_identity = plumbing.convert_remote_identity_to_porcelain( 6283 plumbing_response.remote_identity) 6284 return resp 6285 6286 def get(self, id, timeout=None): 6287 ''' 6288 Get reads one RemoteIdentity by ID. 6289 ''' 6290 deadline = None if timeout is None else time.time() + timeout 6291 req = RemoteIdentityGetRequest() 6292 if self.parent.snapshot_datetime is not None: 6293 req.meta.CopyFrom(GetRequestMetadata()) 6294 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6295 6296 req.id = (id) 6297 tries = 0 6298 plumbing_response = None 6299 while True: 6300 t = None if deadline is None else deadline - time.time() 6301 try: 6302 plumbing_response = self.stub.Get( 6303 req, 6304 metadata=self.parent.get_metadata('RemoteIdentities.Get', 6305 req), 6306 timeout=t) 6307 except Exception as e: 6308 if self.parent.shouldRetry(tries, e, deadline): 6309 tries += 1 6310 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6311 continue 6312 raise plumbing.convert_error_to_porcelain(e) from e 6313 break 6314 6315 resp = models.RemoteIdentityGetResponse() 6316 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 6317 plumbing_response.meta) 6318 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6319 plumbing_response.rate_limit) 6320 resp.remote_identity = plumbing.convert_remote_identity_to_porcelain( 6321 plumbing_response.remote_identity) 6322 return resp 6323 6324 def update(self, remote_identity, timeout=None): 6325 ''' 6326 Update replaces all the fields of a RemoteIdentity by ID. 6327 ''' 6328 deadline = None if timeout is None else time.time() + timeout 6329 req = RemoteIdentityUpdateRequest() 6330 6331 if remote_identity is not None: 6332 req.remote_identity.CopyFrom( 6333 plumbing.convert_remote_identity_to_plumbing(remote_identity)) 6334 tries = 0 6335 plumbing_response = None 6336 while True: 6337 t = None if deadline is None else deadline - time.time() 6338 try: 6339 plumbing_response = self.stub.Update( 6340 req, 6341 metadata=self.parent.get_metadata( 6342 'RemoteIdentities.Update', req), 6343 timeout=t) 6344 except Exception as e: 6345 if self.parent.shouldRetry(tries, e, deadline): 6346 tries += 1 6347 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6348 continue 6349 raise plumbing.convert_error_to_porcelain(e) from e 6350 break 6351 6352 resp = models.RemoteIdentityUpdateResponse() 6353 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 6354 plumbing_response.meta) 6355 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6356 plumbing_response.rate_limit) 6357 resp.remote_identity = plumbing.convert_remote_identity_to_porcelain( 6358 plumbing_response.remote_identity) 6359 return resp 6360 6361 def delete(self, id, timeout=None): 6362 ''' 6363 Delete removes a RemoteIdentity by ID. 6364 ''' 6365 deadline = None if timeout is None else time.time() + timeout 6366 req = RemoteIdentityDeleteRequest() 6367 6368 req.id = (id) 6369 tries = 0 6370 plumbing_response = None 6371 while True: 6372 t = None if deadline is None else deadline - time.time() 6373 try: 6374 plumbing_response = self.stub.Delete( 6375 req, 6376 metadata=self.parent.get_metadata( 6377 'RemoteIdentities.Delete', req), 6378 timeout=t) 6379 except Exception as e: 6380 if self.parent.shouldRetry(tries, e, deadline): 6381 tries += 1 6382 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6383 continue 6384 raise plumbing.convert_error_to_porcelain(e) from e 6385 break 6386 6387 resp = models.RemoteIdentityDeleteResponse() 6388 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 6389 plumbing_response.meta) 6390 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6391 plumbing_response.rate_limit) 6392 return resp 6393 6394 def list(self, filter, *args, timeout=None): 6395 ''' 6396 List gets a list of RemoteIdentities matching a given set of criteria. 6397 ''' 6398 deadline = None if timeout is None else time.time() + timeout 6399 req = RemoteIdentityListRequest() 6400 req.meta.CopyFrom(ListRequestMetadata()) 6401 if self.parent.page_limit > 0: 6402 req.meta.limit = self.parent.page_limit 6403 if self.parent.snapshot_datetime is not None: 6404 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6405 6406 req.filter = plumbing.quote_filter_args(filter, *args) 6407 6408 def generator(svc, req): 6409 tries = 0 6410 while True: 6411 t = None if deadline is None else deadline - time.time() 6412 try: 6413 plumbing_response = svc.stub.List( 6414 req, 6415 metadata=svc.parent.get_metadata( 6416 'RemoteIdentities.List', req), 6417 timeout=t) 6418 except Exception as e: 6419 if self.parent.shouldRetry(tries, e, deadline): 6420 tries += 1 6421 time.sleep( 6422 self.parent.exponentialBackoff(tries, deadline)) 6423 continue 6424 raise plumbing.convert_error_to_porcelain(e) from e 6425 tries = 0 6426 for plumbing_item in plumbing_response.remote_identities: 6427 yield plumbing.convert_remote_identity_to_porcelain( 6428 plumbing_item) 6429 if plumbing_response.meta.next_cursor == '': 6430 break 6431 req.meta.cursor = plumbing_response.meta.next_cursor 6432 6433 return generator(self, req) 6434 6435 6436class SnapshotRemoteIdentities: 6437 ''' 6438 SnapshotRemoteIdentities exposes the read only methods of the RemoteIdentities 6439 service for historical queries. 6440 ''' 6441 def __init__(self, remote_identities): 6442 self.remote_identities = remote_identities 6443 6444 def get(self, id, timeout=None): 6445 ''' 6446 Get reads one RemoteIdentity by ID. 6447 ''' 6448 return self.remote_identities.get(id, timeout=timeout) 6449 6450 def list(self, filter, *args, timeout=None): 6451 ''' 6452 List gets a list of RemoteIdentities matching a given set of criteria. 6453 ''' 6454 return self.remote_identities.list(filter, *args, timeout=timeout) 6455 6456 6457class RemoteIdentitiesHistory: 6458 ''' 6459 RemoteIdentitiesHistory records all changes to the state of a RemoteIdentity. 6460 See `strongdm.models.RemoteIdentityHistory`. 6461 ''' 6462 def __init__(self, channel, client): 6463 self.parent = client 6464 self.stub = RemoteIdentitiesHistoryStub(channel) 6465 6466 def list(self, filter, *args, timeout=None): 6467 ''' 6468 List gets a list of RemoteIdentityHistory records matching a given set of criteria. 6469 ''' 6470 deadline = None if timeout is None else time.time() + timeout 6471 req = RemoteIdentityHistoryListRequest() 6472 req.meta.CopyFrom(ListRequestMetadata()) 6473 if self.parent.page_limit > 0: 6474 req.meta.limit = self.parent.page_limit 6475 if self.parent.snapshot_datetime is not None: 6476 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6477 6478 req.filter = plumbing.quote_filter_args(filter, *args) 6479 6480 def generator(svc, req): 6481 tries = 0 6482 while True: 6483 t = None if deadline is None else deadline - time.time() 6484 try: 6485 plumbing_response = svc.stub.List( 6486 req, 6487 metadata=svc.parent.get_metadata( 6488 'RemoteIdentitiesHistory.List', req), 6489 timeout=t) 6490 except Exception as e: 6491 if self.parent.shouldRetry(tries, e, deadline): 6492 tries += 1 6493 time.sleep( 6494 self.parent.exponentialBackoff(tries, deadline)) 6495 continue 6496 raise plumbing.convert_error_to_porcelain(e) from e 6497 tries = 0 6498 for plumbing_item in plumbing_response.history: 6499 yield plumbing.convert_remote_identity_history_to_porcelain( 6500 plumbing_item) 6501 if plumbing_response.meta.next_cursor == '': 6502 break 6503 req.meta.cursor = plumbing_response.meta.next_cursor 6504 6505 return generator(self, req) 6506 6507 6508class RemoteIdentityGroups: 6509 ''' 6510 A RemoteIdentityGroup is a named grouping of Remote Identities for Accounts. 6511 An Account's relationship to a RemoteIdentityGroup is defined via RemoteIdentity objects. 6512 See `strongdm.models.RemoteIdentityGroup`. 6513 ''' 6514 def __init__(self, channel, client): 6515 self.parent = client 6516 self.stub = RemoteIdentityGroupsStub(channel) 6517 6518 def get(self, id, timeout=None): 6519 ''' 6520 Get reads one RemoteIdentityGroup by ID. 6521 ''' 6522 deadline = None if timeout is None else time.time() + timeout 6523 req = RemoteIdentityGroupGetRequest() 6524 if self.parent.snapshot_datetime is not None: 6525 req.meta.CopyFrom(GetRequestMetadata()) 6526 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6527 6528 req.id = (id) 6529 tries = 0 6530 plumbing_response = None 6531 while True: 6532 t = None if deadline is None else deadline - time.time() 6533 try: 6534 plumbing_response = self.stub.Get( 6535 req, 6536 metadata=self.parent.get_metadata( 6537 'RemoteIdentityGroups.Get', req), 6538 timeout=t) 6539 except Exception as e: 6540 if self.parent.shouldRetry(tries, e, deadline): 6541 tries += 1 6542 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6543 continue 6544 raise plumbing.convert_error_to_porcelain(e) from e 6545 break 6546 6547 resp = models.RemoteIdentityGroupGetResponse() 6548 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 6549 plumbing_response.meta) 6550 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6551 plumbing_response.rate_limit) 6552 resp.remote_identity_group = plumbing.convert_remote_identity_group_to_porcelain( 6553 plumbing_response.remote_identity_group) 6554 return resp 6555 6556 def list(self, filter, *args, timeout=None): 6557 ''' 6558 List gets a list of RemoteIdentityGroups matching a given set of criteria. 6559 ''' 6560 deadline = None if timeout is None else time.time() + timeout 6561 req = RemoteIdentityGroupListRequest() 6562 req.meta.CopyFrom(ListRequestMetadata()) 6563 if self.parent.page_limit > 0: 6564 req.meta.limit = self.parent.page_limit 6565 if self.parent.snapshot_datetime is not None: 6566 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6567 6568 req.filter = plumbing.quote_filter_args(filter, *args) 6569 6570 def generator(svc, req): 6571 tries = 0 6572 while True: 6573 t = None if deadline is None else deadline - time.time() 6574 try: 6575 plumbing_response = svc.stub.List( 6576 req, 6577 metadata=svc.parent.get_metadata( 6578 'RemoteIdentityGroups.List', req), 6579 timeout=t) 6580 except Exception as e: 6581 if self.parent.shouldRetry(tries, e, deadline): 6582 tries += 1 6583 time.sleep( 6584 self.parent.exponentialBackoff(tries, deadline)) 6585 continue 6586 raise plumbing.convert_error_to_porcelain(e) from e 6587 tries = 0 6588 for plumbing_item in plumbing_response.remote_identity_groups: 6589 yield plumbing.convert_remote_identity_group_to_porcelain( 6590 plumbing_item) 6591 if plumbing_response.meta.next_cursor == '': 6592 break 6593 req.meta.cursor = plumbing_response.meta.next_cursor 6594 6595 return generator(self, req) 6596 6597 6598class SnapshotRemoteIdentityGroups: 6599 ''' 6600 SnapshotRemoteIdentityGroups exposes the read only methods of the RemoteIdentityGroups 6601 service for historical queries. 6602 ''' 6603 def __init__(self, remote_identity_groups): 6604 self.remote_identity_groups = remote_identity_groups 6605 6606 def get(self, id, timeout=None): 6607 ''' 6608 Get reads one RemoteIdentityGroup by ID. 6609 ''' 6610 return self.remote_identity_groups.get(id, timeout=timeout) 6611 6612 def list(self, filter, *args, timeout=None): 6613 ''' 6614 List gets a list of RemoteIdentityGroups matching a given set of criteria. 6615 ''' 6616 return self.remote_identity_groups.list(filter, *args, timeout=timeout) 6617 6618 6619class RemoteIdentityGroupsHistory: 6620 ''' 6621 RemoteIdentityGroupsHistory records all changes to the state of a RemoteIdentityGroup. 6622 See `strongdm.models.RemoteIdentityGroupHistory`. 6623 ''' 6624 def __init__(self, channel, client): 6625 self.parent = client 6626 self.stub = RemoteIdentityGroupsHistoryStub(channel) 6627 6628 def list(self, filter, *args, timeout=None): 6629 ''' 6630 List gets a list of RemoteIdentityGroupHistory records matching a given set of criteria. 6631 ''' 6632 deadline = None if timeout is None else time.time() + timeout 6633 req = RemoteIdentityGroupHistoryListRequest() 6634 req.meta.CopyFrom(ListRequestMetadata()) 6635 if self.parent.page_limit > 0: 6636 req.meta.limit = self.parent.page_limit 6637 if self.parent.snapshot_datetime is not None: 6638 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6639 6640 req.filter = plumbing.quote_filter_args(filter, *args) 6641 6642 def generator(svc, req): 6643 tries = 0 6644 while True: 6645 t = None if deadline is None else deadline - time.time() 6646 try: 6647 plumbing_response = svc.stub.List( 6648 req, 6649 metadata=svc.parent.get_metadata( 6650 'RemoteIdentityGroupsHistory.List', req), 6651 timeout=t) 6652 except Exception as e: 6653 if self.parent.shouldRetry(tries, e, deadline): 6654 tries += 1 6655 time.sleep( 6656 self.parent.exponentialBackoff(tries, deadline)) 6657 continue 6658 raise plumbing.convert_error_to_porcelain(e) from e 6659 tries = 0 6660 for plumbing_item in plumbing_response.history: 6661 yield plumbing.convert_remote_identity_group_history_to_porcelain( 6662 plumbing_item) 6663 if plumbing_response.meta.next_cursor == '': 6664 break 6665 req.meta.cursor = plumbing_response.meta.next_cursor 6666 6667 return generator(self, req) 6668 6669 6670class Replays: 6671 ''' 6672 A Replay captures the data transferred over a long-running SSH, RDP, or Kubernetes interactive session 6673 (otherwise referred to as a query). The Replays service is read-only. 6674 See `strongdm.models.ReplayChunk`. 6675 ''' 6676 def __init__(self, channel, client): 6677 self.parent = client 6678 self.stub = ReplaysStub(channel) 6679 6680 def list(self, filter, *args, timeout=None): 6681 ''' 6682 List gets a list of ReplayChunks for the Query ID specified by the filter criteria. 6683 ''' 6684 deadline = None if timeout is None else time.time() + timeout 6685 req = ReplayListRequest() 6686 req.meta.CopyFrom(ListRequestMetadata()) 6687 if self.parent.page_limit > 0: 6688 req.meta.limit = self.parent.page_limit 6689 if self.parent.snapshot_datetime is not None: 6690 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6691 6692 req.filter = plumbing.quote_filter_args(filter, *args) 6693 6694 def generator(svc, req): 6695 tries = 0 6696 while True: 6697 t = None if deadline is None else deadline - time.time() 6698 try: 6699 plumbing_response = svc.stub.List( 6700 req, 6701 metadata=svc.parent.get_metadata('Replays.List', req), 6702 timeout=t) 6703 except Exception as e: 6704 if self.parent.shouldRetry(tries, e, deadline): 6705 tries += 1 6706 time.sleep( 6707 self.parent.exponentialBackoff(tries, deadline)) 6708 continue 6709 raise plumbing.convert_error_to_porcelain(e) from e 6710 tries = 0 6711 for plumbing_item in plumbing_response.chunks: 6712 yield plumbing.convert_replay_chunk_to_porcelain( 6713 plumbing_item) 6714 if plumbing_response.meta.next_cursor == '': 6715 break 6716 req.meta.cursor = plumbing_response.meta.next_cursor 6717 6718 return generator(self, req) 6719 6720 6721class RequestableAccountEntitlements: 6722 ''' 6723 RequestableAccountEntitlements enumerates the resources that an account is permitted to request access to. 6724 The RequestableAccountEntitlements service is read-only. 6725 See `strongdm.models.RequestableAccountEntitlement`. 6726 ''' 6727 def __init__(self, channel, client): 6728 self.parent = client 6729 self.stub = RequestableAccountEntitlementsStub(channel) 6730 6731 def list(self, account_id, filter, *args, timeout=None): 6732 ''' 6733 List gets a list of RequestableAccountEntitlement records matching a given set of criteria. 6734 ''' 6735 deadline = None if timeout is None else time.time() + timeout 6736 req = RequestableAccountEntitlementListRequest() 6737 req.meta.CopyFrom(ListRequestMetadata()) 6738 if self.parent.page_limit > 0: 6739 req.meta.limit = self.parent.page_limit 6740 if self.parent.snapshot_datetime is not None: 6741 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6742 6743 req.account_id = (account_id) 6744 req.filter = plumbing.quote_filter_args(filter, *args) 6745 6746 def generator(svc, req): 6747 tries = 0 6748 while True: 6749 t = None if deadline is None else deadline - time.time() 6750 try: 6751 plumbing_response = svc.stub.List( 6752 req, 6753 metadata=svc.parent.get_metadata( 6754 'RequestableAccountEntitlements.List', req), 6755 timeout=t) 6756 except Exception as e: 6757 if self.parent.shouldRetry(tries, e, deadline): 6758 tries += 1 6759 time.sleep( 6760 self.parent.exponentialBackoff(tries, deadline)) 6761 continue 6762 raise plumbing.convert_error_to_porcelain(e) from e 6763 tries = 0 6764 for plumbing_item in plumbing_response.requestable_account_entitlements: 6765 yield plumbing.convert_requestable_account_entitlement_to_porcelain( 6766 plumbing_item) 6767 if plumbing_response.meta.next_cursor == '': 6768 break 6769 req.meta.cursor = plumbing_response.meta.next_cursor 6770 6771 return generator(self, req) 6772 6773 6774class SnapshotRequestableAccountEntitlements: 6775 ''' 6776 SnapshotRequestableAccountEntitlements exposes the read only methods of the RequestableAccountEntitlements 6777 service for historical queries. 6778 ''' 6779 def __init__(self, requestable_account_entitlements): 6780 self.requestable_account_entitlements = requestable_account_entitlements 6781 6782 def list(self, account_id, filter, *args, timeout=None): 6783 ''' 6784 List gets a list of RequestableAccountEntitlement records matching a given set of criteria. 6785 ''' 6786 return self.requestable_account_entitlements.list(account_id, 6787 filter, 6788 *args, 6789 timeout=timeout) 6790 6791 6792class RequestableResourceEntitlements: 6793 ''' 6794 RequestableResourceEntitlements enumerates the accounts that are permitted to request access to a given resource. 6795 The RequestableResourceEntitlements service is read-only. 6796 See `strongdm.models.RequestableResourceEntitlement`. 6797 ''' 6798 def __init__(self, channel, client): 6799 self.parent = client 6800 self.stub = RequestableResourceEntitlementsStub(channel) 6801 6802 def list(self, resource_id, filter, *args, timeout=None): 6803 ''' 6804 List gets a list of RequestableResourceEntitlement records matching a given set of criteria. 6805 ''' 6806 deadline = None if timeout is None else time.time() + timeout 6807 req = RequestableResourceEntitlementListRequest() 6808 req.meta.CopyFrom(ListRequestMetadata()) 6809 if self.parent.page_limit > 0: 6810 req.meta.limit = self.parent.page_limit 6811 if self.parent.snapshot_datetime is not None: 6812 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6813 6814 req.resource_id = (resource_id) 6815 req.filter = plumbing.quote_filter_args(filter, *args) 6816 6817 def generator(svc, req): 6818 tries = 0 6819 while True: 6820 t = None if deadline is None else deadline - time.time() 6821 try: 6822 plumbing_response = svc.stub.List( 6823 req, 6824 metadata=svc.parent.get_metadata( 6825 'RequestableResourceEntitlements.List', req), 6826 timeout=t) 6827 except Exception as e: 6828 if self.parent.shouldRetry(tries, e, deadline): 6829 tries += 1 6830 time.sleep( 6831 self.parent.exponentialBackoff(tries, deadline)) 6832 continue 6833 raise plumbing.convert_error_to_porcelain(e) from e 6834 tries = 0 6835 for plumbing_item in plumbing_response.requestable_resource_entitlements: 6836 yield plumbing.convert_requestable_resource_entitlement_to_porcelain( 6837 plumbing_item) 6838 if plumbing_response.meta.next_cursor == '': 6839 break 6840 req.meta.cursor = plumbing_response.meta.next_cursor 6841 6842 return generator(self, req) 6843 6844 6845class SnapshotRequestableResourceEntitlements: 6846 ''' 6847 SnapshotRequestableResourceEntitlements exposes the read only methods of the RequestableResourceEntitlements 6848 service for historical queries. 6849 ''' 6850 def __init__(self, requestable_resource_entitlements): 6851 self.requestable_resource_entitlements = requestable_resource_entitlements 6852 6853 def list(self, resource_id, filter, *args, timeout=None): 6854 ''' 6855 List gets a list of RequestableResourceEntitlement records matching a given set of criteria. 6856 ''' 6857 return self.requestable_resource_entitlements.list(resource_id, 6858 filter, 6859 *args, 6860 timeout=timeout) 6861 6862 6863class RequestableRoleEntitlements: 6864 ''' 6865 RequestableRoleEntitlements enumerates the resources that a role permits its members to request access to. 6866 The RequestableRoleEntitlements service is read-only. 6867 See `strongdm.models.RequestableRoleEntitlement`. 6868 ''' 6869 def __init__(self, channel, client): 6870 self.parent = client 6871 self.stub = RequestableRoleEntitlementsStub(channel) 6872 6873 def list(self, role_id, filter, *args, timeout=None): 6874 ''' 6875 List gets a list of RequestableRoleEntitlement records matching a given set of criteria. 6876 ''' 6877 deadline = None if timeout is None else time.time() + timeout 6878 req = RequestableRoleEntitlementListRequest() 6879 req.meta.CopyFrom(ListRequestMetadata()) 6880 if self.parent.page_limit > 0: 6881 req.meta.limit = self.parent.page_limit 6882 if self.parent.snapshot_datetime is not None: 6883 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6884 6885 req.role_id = (role_id) 6886 req.filter = plumbing.quote_filter_args(filter, *args) 6887 6888 def generator(svc, req): 6889 tries = 0 6890 while True: 6891 t = None if deadline is None else deadline - time.time() 6892 try: 6893 plumbing_response = svc.stub.List( 6894 req, 6895 metadata=svc.parent.get_metadata( 6896 'RequestableRoleEntitlements.List', req), 6897 timeout=t) 6898 except Exception as e: 6899 if self.parent.shouldRetry(tries, e, deadline): 6900 tries += 1 6901 time.sleep( 6902 self.parent.exponentialBackoff(tries, deadline)) 6903 continue 6904 raise plumbing.convert_error_to_porcelain(e) from e 6905 tries = 0 6906 for plumbing_item in plumbing_response.requestable_role_entitlements: 6907 yield plumbing.convert_requestable_role_entitlement_to_porcelain( 6908 plumbing_item) 6909 if plumbing_response.meta.next_cursor == '': 6910 break 6911 req.meta.cursor = plumbing_response.meta.next_cursor 6912 6913 return generator(self, req) 6914 6915 6916class SnapshotRequestableRoleEntitlements: 6917 ''' 6918 SnapshotRequestableRoleEntitlements exposes the read only methods of the RequestableRoleEntitlements 6919 service for historical queries. 6920 ''' 6921 def __init__(self, requestable_role_entitlements): 6922 self.requestable_role_entitlements = requestable_role_entitlements 6923 6924 def list(self, role_id, filter, *args, timeout=None): 6925 ''' 6926 List gets a list of RequestableRoleEntitlement records matching a given set of criteria. 6927 ''' 6928 return self.requestable_role_entitlements.list(role_id, 6929 filter, 6930 *args, 6931 timeout=timeout) 6932 6933 6934class Resources: 6935 ''' 6936 Resources are databases, servers, clusters, websites, or clouds that strongDM 6937 delegates access to. 6938 See: 6939 `strongdm.models.Aerospike` 6940 `strongdm.models.AKS` 6941 `strongdm.models.AKSBasicAuth` 6942 `strongdm.models.AKSServiceAccount` 6943 `strongdm.models.AKSServiceAccountUserImpersonation` 6944 `strongdm.models.AKSUserImpersonation` 6945 `strongdm.models.AmazonEKS` 6946 `strongdm.models.AmazonEKSInstanceProfile` 6947 `strongdm.models.AmazonEKSInstanceProfileUserImpersonation` 6948 `strongdm.models.AmazonEKSUserImpersonation` 6949 `strongdm.models.AmazonES` 6950 `strongdm.models.AmazonESIAM` 6951 `strongdm.models.AmazonMQAMQP091` 6952 `strongdm.models.AMQP` 6953 `strongdm.models.Athena` 6954 `strongdm.models.AthenaIAM` 6955 `strongdm.models.AuroraMysql` 6956 `strongdm.models.AuroraMysqlIAM` 6957 `strongdm.models.AuroraPostgres` 6958 `strongdm.models.AuroraPostgresIAM` 6959 `strongdm.models.AWS` 6960 `strongdm.models.AWSConsole` 6961 `strongdm.models.AWSConsoleStaticKeyPair` 6962 `strongdm.models.AWSInstanceProfile` 6963 `strongdm.models.Azure` 6964 `strongdm.models.AzureCertificate` 6965 `strongdm.models.AzureMysql` 6966 `strongdm.models.AzureMysqlManagedIdentity` 6967 `strongdm.models.AzurePostgres` 6968 `strongdm.models.AzurePostgresManagedIdentity` 6969 `strongdm.models.BigQuery` 6970 `strongdm.models.Cassandra` 6971 `strongdm.models.Citus` 6972 `strongdm.models.ClickHouseHTTP` 6973 `strongdm.models.ClickHouseMySQL` 6974 `strongdm.models.ClickHouseTCP` 6975 `strongdm.models.Clustrix` 6976 `strongdm.models.Cockroach` 6977 `strongdm.models.CouchbaseDatabase` 6978 `strongdm.models.CouchbaseWebUI` 6979 `strongdm.models.Databricks` 6980 `strongdm.models.DB2I` 6981 `strongdm.models.DB2LUW` 6982 `strongdm.models.DocumentDBHost` 6983 `strongdm.models.DocumentDBHostIAM` 6984 `strongdm.models.DocumentDBReplicaSet` 6985 `strongdm.models.DocumentDBReplicaSetIAM` 6986 `strongdm.models.Druid` 6987 `strongdm.models.DynamoDB` 6988 `strongdm.models.DynamoDBIAM` 6989 `strongdm.models.Elastic` 6990 `strongdm.models.ElasticacheRedis` 6991 `strongdm.models.ElasticacheRedisIAM` 6992 `strongdm.models.EntraID` 6993 `strongdm.models.GCP` 6994 `strongdm.models.GCPConsole` 6995 `strongdm.models.GCPWIF` 6996 `strongdm.models.GoogleGKE` 6997 `strongdm.models.GoogleGKEUserImpersonation` 6998 `strongdm.models.GoogleGroups` 6999 `strongdm.models.GoogleSpanner` 7000 `strongdm.models.Greenplum` 7001 `strongdm.models.HTTPAuth` 7002 `strongdm.models.HTTPBasicAuth` 7003 `strongdm.models.HTTPNoAuth` 7004 `strongdm.models.Kubernetes` 7005 `strongdm.models.KubernetesBasicAuth` 7006 `strongdm.models.KubernetesPodIdentity` 7007 `strongdm.models.KubernetesServiceAccount` 7008 `strongdm.models.KubernetesServiceAccountUserImpersonation` 7009 `strongdm.models.KubernetesUserImpersonation` 7010 `strongdm.models.LLM` 7011 `strongdm.models.Maria` 7012 `strongdm.models.MCPGatewayNoAuth` 7013 `strongdm.models.MCPGatewayOAuth` 7014 `strongdm.models.MCPGatewayOAuthDCR` 7015 `strongdm.models.MCPGatewayPAT` 7016 `strongdm.models.Memcached` 7017 `strongdm.models.Memsql` 7018 `strongdm.models.MongoHost` 7019 `strongdm.models.MongoLegacyHost` 7020 `strongdm.models.MongoLegacyReplicaset` 7021 `strongdm.models.MongoReplicaSet` 7022 `strongdm.models.MongoShardedCluster` 7023 `strongdm.models.MTLSMysql` 7024 `strongdm.models.MTLSPostgres` 7025 `strongdm.models.Mysql` 7026 `strongdm.models.Neptune` 7027 `strongdm.models.NeptuneIAM` 7028 `strongdm.models.OktaGroups` 7029 `strongdm.models.Oracle` 7030 `strongdm.models.OracleNNE` 7031 `strongdm.models.Postgres` 7032 `strongdm.models.Presto` 7033 `strongdm.models.RabbitMQAMQP091` 7034 `strongdm.models.RawTCP` 7035 `strongdm.models.RDP` 7036 `strongdm.models.RDPCert` 7037 `strongdm.models.RDSPostgresIAM` 7038 `strongdm.models.Redis` 7039 `strongdm.models.RedisCluster` 7040 `strongdm.models.Redshift` 7041 `strongdm.models.RedshiftIAM` 7042 `strongdm.models.RedshiftServerlessIAM` 7043 `strongdm.models.SingleStore` 7044 `strongdm.models.Snowflake` 7045 `strongdm.models.Snowsight` 7046 `strongdm.models.SQLServer` 7047 `strongdm.models.SQLServerAzureAD` 7048 `strongdm.models.SQLServerKerberosAD` 7049 `strongdm.models.SSH` 7050 `strongdm.models.SSHCert` 7051 `strongdm.models.SSHCustomerKey` 7052 `strongdm.models.SSHPassword` 7053 `strongdm.models.Sybase` 7054 `strongdm.models.SybaseIQ` 7055 `strongdm.models.Teradata` 7056 `strongdm.models.Trino` 7057 `strongdm.models.Vertica` 7058 ''' 7059 def __init__(self, channel, client): 7060 self.parent = client 7061 self.stub = ResourcesStub(channel) 7062 7063 def enumerate_tags(self, filter, *args, timeout=None): 7064 ''' 7065 EnumerateTags gets a list of the filter matching tags. 7066 ''' 7067 deadline = None if timeout is None else time.time() + timeout 7068 req = EnumerateTagsRequest() 7069 req.meta.CopyFrom(ListRequestMetadata()) 7070 if self.parent.page_limit > 0: 7071 req.meta.limit = self.parent.page_limit 7072 if self.parent.snapshot_datetime is not None: 7073 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7074 7075 req.filter = plumbing.quote_filter_args(filter, *args) 7076 7077 def generator(svc, req): 7078 tries = 0 7079 while True: 7080 t = None if deadline is None else deadline - time.time() 7081 try: 7082 plumbing_response = svc.stub.EnumerateTags( 7083 req, 7084 metadata=svc.parent.get_metadata( 7085 'Resources.EnumerateTags', req), 7086 timeout=t) 7087 except Exception as e: 7088 if self.parent.shouldRetry(tries, e, deadline): 7089 tries += 1 7090 time.sleep( 7091 self.parent.exponentialBackoff(tries, deadline)) 7092 continue 7093 raise plumbing.convert_error_to_porcelain(e) from e 7094 tries = 0 7095 for plumbing_item in plumbing_response.matches: 7096 yield plumbing.convert_tag_to_porcelain(plumbing_item) 7097 if plumbing_response.meta.next_cursor == '': 7098 break 7099 req.meta.cursor = plumbing_response.meta.next_cursor 7100 7101 return generator(self, req) 7102 7103 def create(self, resource, timeout=None): 7104 ''' 7105 Create registers a new Resource. 7106 ''' 7107 deadline = None if timeout is None else time.time() + timeout 7108 req = ResourceCreateRequest() 7109 7110 if resource is not None: 7111 req.resource.CopyFrom( 7112 plumbing.convert_resource_to_plumbing(resource)) 7113 tries = 0 7114 plumbing_response = None 7115 while True: 7116 t = None if deadline is None else deadline - time.time() 7117 try: 7118 plumbing_response = self.stub.Create( 7119 req, 7120 metadata=self.parent.get_metadata('Resources.Create', req), 7121 timeout=t) 7122 except Exception as e: 7123 if self.parent.shouldRetry(tries, e, deadline): 7124 tries += 1 7125 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7126 continue 7127 raise plumbing.convert_error_to_porcelain(e) from e 7128 break 7129 7130 resp = models.ResourceCreateResponse() 7131 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 7132 plumbing_response.meta) 7133 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7134 plumbing_response.rate_limit) 7135 resp.resource = plumbing.convert_resource_to_porcelain( 7136 plumbing_response.resource) 7137 return resp 7138 7139 def get(self, id, timeout=None): 7140 ''' 7141 Get reads one Resource by ID. 7142 ''' 7143 deadline = None if timeout is None else time.time() + timeout 7144 req = ResourceGetRequest() 7145 if self.parent.snapshot_datetime is not None: 7146 req.meta.CopyFrom(GetRequestMetadata()) 7147 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7148 7149 req.id = (id) 7150 tries = 0 7151 plumbing_response = None 7152 while True: 7153 t = None if deadline is None else deadline - time.time() 7154 try: 7155 plumbing_response = self.stub.Get( 7156 req, 7157 metadata=self.parent.get_metadata('Resources.Get', req), 7158 timeout=t) 7159 except Exception as e: 7160 if self.parent.shouldRetry(tries, e, deadline): 7161 tries += 1 7162 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7163 continue 7164 raise plumbing.convert_error_to_porcelain(e) from e 7165 break 7166 7167 resp = models.ResourceGetResponse() 7168 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 7169 plumbing_response.meta) 7170 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7171 plumbing_response.rate_limit) 7172 resp.resource = plumbing.convert_resource_to_porcelain( 7173 plumbing_response.resource) 7174 return resp 7175 7176 def update(self, resource, timeout=None): 7177 ''' 7178 Update replaces all the fields of a Resource by ID. 7179 ''' 7180 deadline = None if timeout is None else time.time() + timeout 7181 req = ResourceUpdateRequest() 7182 7183 if resource is not None: 7184 req.resource.CopyFrom( 7185 plumbing.convert_resource_to_plumbing(resource)) 7186 tries = 0 7187 plumbing_response = None 7188 while True: 7189 t = None if deadline is None else deadline - time.time() 7190 try: 7191 plumbing_response = self.stub.Update( 7192 req, 7193 metadata=self.parent.get_metadata('Resources.Update', req), 7194 timeout=t) 7195 except Exception as e: 7196 if self.parent.shouldRetry(tries, e, deadline): 7197 tries += 1 7198 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7199 continue 7200 raise plumbing.convert_error_to_porcelain(e) from e 7201 break 7202 7203 resp = models.ResourceUpdateResponse() 7204 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 7205 plumbing_response.meta) 7206 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7207 plumbing_response.rate_limit) 7208 resp.resource = plumbing.convert_resource_to_porcelain( 7209 plumbing_response.resource) 7210 return resp 7211 7212 def delete(self, id, timeout=None): 7213 ''' 7214 Delete removes a Resource by ID. 7215 ''' 7216 deadline = None if timeout is None else time.time() + timeout 7217 req = ResourceDeleteRequest() 7218 7219 req.id = (id) 7220 tries = 0 7221 plumbing_response = None 7222 while True: 7223 t = None if deadline is None else deadline - time.time() 7224 try: 7225 plumbing_response = self.stub.Delete( 7226 req, 7227 metadata=self.parent.get_metadata('Resources.Delete', req), 7228 timeout=t) 7229 except Exception as e: 7230 if self.parent.shouldRetry(tries, e, deadline): 7231 tries += 1 7232 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7233 continue 7234 raise plumbing.convert_error_to_porcelain(e) from e 7235 break 7236 7237 resp = models.ResourceDeleteResponse() 7238 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 7239 plumbing_response.meta) 7240 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7241 plumbing_response.rate_limit) 7242 return resp 7243 7244 def list(self, filter, *args, timeout=None): 7245 ''' 7246 List gets a list of Resources matching a given set of criteria. 7247 ''' 7248 deadline = None if timeout is None else time.time() + timeout 7249 req = ResourceListRequest() 7250 req.meta.CopyFrom(ListRequestMetadata()) 7251 if self.parent.page_limit > 0: 7252 req.meta.limit = self.parent.page_limit 7253 if self.parent.snapshot_datetime is not None: 7254 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7255 7256 req.filter = plumbing.quote_filter_args(filter, *args) 7257 7258 def generator(svc, req): 7259 tries = 0 7260 while True: 7261 t = None if deadline is None else deadline - time.time() 7262 try: 7263 plumbing_response = svc.stub.List( 7264 req, 7265 metadata=svc.parent.get_metadata( 7266 'Resources.List', req), 7267 timeout=t) 7268 except Exception as e: 7269 if self.parent.shouldRetry(tries, e, deadline): 7270 tries += 1 7271 time.sleep( 7272 self.parent.exponentialBackoff(tries, deadline)) 7273 continue 7274 raise plumbing.convert_error_to_porcelain(e) from e 7275 tries = 0 7276 for plumbing_item in plumbing_response.resources: 7277 yield plumbing.convert_resource_to_porcelain(plumbing_item) 7278 if plumbing_response.meta.next_cursor == '': 7279 break 7280 req.meta.cursor = plumbing_response.meta.next_cursor 7281 7282 return generator(self, req) 7283 7284 def healthcheck(self, id, timeout=None): 7285 ''' 7286 Healthcheck triggers a remote healthcheck. It may take minutes to propagate across a 7287 large network of Nodes. The call will return immediately, and the updated health of the 7288 Resource can be retrieved via Get or List. 7289 ''' 7290 deadline = None if timeout is None else time.time() + timeout 7291 req = ResourceHealthcheckRequest() 7292 7293 req.id = (id) 7294 tries = 0 7295 plumbing_response = None 7296 while True: 7297 t = None if deadline is None else deadline - time.time() 7298 try: 7299 plumbing_response = self.stub.Healthcheck( 7300 req, 7301 metadata=self.parent.get_metadata('Resources.Healthcheck', 7302 req), 7303 timeout=t) 7304 except Exception as e: 7305 if self.parent.shouldRetry(tries, e, deadline): 7306 tries += 1 7307 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7308 continue 7309 raise plumbing.convert_error_to_porcelain(e) from e 7310 break 7311 7312 resp = models.ResourceHealthcheckResponse() 7313 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 7314 plumbing_response.meta) 7315 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7316 plumbing_response.rate_limit) 7317 return resp 7318 7319 7320class SnapshotResources: 7321 ''' 7322 SnapshotResources exposes the read only methods of the Resources 7323 service for historical queries. 7324 ''' 7325 def __init__(self, resources): 7326 self.resources = resources 7327 7328 def get(self, id, timeout=None): 7329 ''' 7330 Get reads one Resource by ID. 7331 ''' 7332 return self.resources.get(id, timeout=timeout) 7333 7334 def list(self, filter, *args, timeout=None): 7335 ''' 7336 List gets a list of Resources matching a given set of criteria. 7337 ''' 7338 return self.resources.list(filter, *args, timeout=timeout) 7339 7340 7341class ResourcesHistory: 7342 ''' 7343 ResourcesHistory records all changes to the state of a Resource. 7344 See `strongdm.models.ResourceHistory`. 7345 ''' 7346 def __init__(self, channel, client): 7347 self.parent = client 7348 self.stub = ResourcesHistoryStub(channel) 7349 7350 def list(self, filter, *args, timeout=None): 7351 ''' 7352 List gets a list of ResourceHistory records matching a given set of criteria. 7353 ''' 7354 deadline = None if timeout is None else time.time() + timeout 7355 req = ResourceHistoryListRequest() 7356 req.meta.CopyFrom(ListRequestMetadata()) 7357 if self.parent.page_limit > 0: 7358 req.meta.limit = self.parent.page_limit 7359 if self.parent.snapshot_datetime is not None: 7360 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7361 7362 req.filter = plumbing.quote_filter_args(filter, *args) 7363 7364 def generator(svc, req): 7365 tries = 0 7366 while True: 7367 t = None if deadline is None else deadline - time.time() 7368 try: 7369 plumbing_response = svc.stub.List( 7370 req, 7371 metadata=svc.parent.get_metadata( 7372 'ResourcesHistory.List', req), 7373 timeout=t) 7374 except Exception as e: 7375 if self.parent.shouldRetry(tries, e, deadline): 7376 tries += 1 7377 time.sleep( 7378 self.parent.exponentialBackoff(tries, deadline)) 7379 continue 7380 raise plumbing.convert_error_to_porcelain(e) from e 7381 tries = 0 7382 for plumbing_item in plumbing_response.history: 7383 yield plumbing.convert_resource_history_to_porcelain( 7384 plumbing_item) 7385 if plumbing_response.meta.next_cursor == '': 7386 break 7387 req.meta.cursor = plumbing_response.meta.next_cursor 7388 7389 return generator(self, req) 7390 7391 7392class RoleResources: 7393 ''' 7394 RoleResources enumerates the resources to which roles have access. 7395 The RoleResources service is read-only. 7396 See `strongdm.models.RoleResource`. 7397 ''' 7398 def __init__(self, channel, client): 7399 self.parent = client 7400 self.stub = RoleResourcesStub(channel) 7401 7402 def list(self, filter, *args, timeout=None): 7403 ''' 7404 List gets a list of RoleResource records matching a given set of criteria. 7405 ''' 7406 deadline = None if timeout is None else time.time() + timeout 7407 req = RoleResourceListRequest() 7408 req.meta.CopyFrom(ListRequestMetadata()) 7409 if self.parent.page_limit > 0: 7410 req.meta.limit = self.parent.page_limit 7411 if self.parent.snapshot_datetime is not None: 7412 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7413 7414 req.filter = plumbing.quote_filter_args(filter, *args) 7415 7416 def generator(svc, req): 7417 tries = 0 7418 while True: 7419 t = None if deadline is None else deadline - time.time() 7420 try: 7421 plumbing_response = svc.stub.List( 7422 req, 7423 metadata=svc.parent.get_metadata( 7424 'RoleResources.List', req), 7425 timeout=t) 7426 except Exception as e: 7427 if self.parent.shouldRetry(tries, e, deadline): 7428 tries += 1 7429 time.sleep( 7430 self.parent.exponentialBackoff(tries, deadline)) 7431 continue 7432 raise plumbing.convert_error_to_porcelain(e) from e 7433 tries = 0 7434 for plumbing_item in plumbing_response.role_resources: 7435 yield plumbing.convert_role_resource_to_porcelain( 7436 plumbing_item) 7437 if plumbing_response.meta.next_cursor == '': 7438 break 7439 req.meta.cursor = plumbing_response.meta.next_cursor 7440 7441 return generator(self, req) 7442 7443 7444class SnapshotRoleResources: 7445 ''' 7446 SnapshotRoleResources exposes the read only methods of the RoleResources 7447 service for historical queries. 7448 ''' 7449 def __init__(self, role_resources): 7450 self.role_resources = role_resources 7451 7452 def list(self, filter, *args, timeout=None): 7453 ''' 7454 List gets a list of RoleResource records matching a given set of criteria. 7455 ''' 7456 return self.role_resources.list(filter, *args, timeout=timeout) 7457 7458 7459class RoleResourcesHistory: 7460 ''' 7461 RoleResourcesHistory records all changes to the state of a RoleResource. 7462 See `strongdm.models.RoleResourceHistory`. 7463 ''' 7464 def __init__(self, channel, client): 7465 self.parent = client 7466 self.stub = RoleResourcesHistoryStub(channel) 7467 7468 def list(self, filter, *args, timeout=None): 7469 ''' 7470 List gets a list of RoleResourceHistory records matching a given set of criteria. 7471 ''' 7472 deadline = None if timeout is None else time.time() + timeout 7473 req = RoleResourceHistoryListRequest() 7474 req.meta.CopyFrom(ListRequestMetadata()) 7475 if self.parent.page_limit > 0: 7476 req.meta.limit = self.parent.page_limit 7477 if self.parent.snapshot_datetime is not None: 7478 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7479 7480 req.filter = plumbing.quote_filter_args(filter, *args) 7481 7482 def generator(svc, req): 7483 tries = 0 7484 while True: 7485 t = None if deadline is None else deadline - time.time() 7486 try: 7487 plumbing_response = svc.stub.List( 7488 req, 7489 metadata=svc.parent.get_metadata( 7490 'RoleResourcesHistory.List', req), 7491 timeout=t) 7492 except Exception as e: 7493 if self.parent.shouldRetry(tries, e, deadline): 7494 tries += 1 7495 time.sleep( 7496 self.parent.exponentialBackoff(tries, deadline)) 7497 continue 7498 raise plumbing.convert_error_to_porcelain(e) from e 7499 tries = 0 7500 for plumbing_item in plumbing_response.history: 7501 yield plumbing.convert_role_resource_history_to_porcelain( 7502 plumbing_item) 7503 if plumbing_response.meta.next_cursor == '': 7504 break 7505 req.meta.cursor = plumbing_response.meta.next_cursor 7506 7507 return generator(self, req) 7508 7509 7510class RolesHistory: 7511 ''' 7512 RolesHistory records all changes to the state of a Role. 7513 See `strongdm.models.RoleHistory`. 7514 ''' 7515 def __init__(self, channel, client): 7516 self.parent = client 7517 self.stub = RolesHistoryStub(channel) 7518 7519 def list(self, filter, *args, timeout=None): 7520 ''' 7521 List gets a list of RoleHistory records matching a given set of criteria. 7522 ''' 7523 deadline = None if timeout is None else time.time() + timeout 7524 req = RoleHistoryListRequest() 7525 req.meta.CopyFrom(ListRequestMetadata()) 7526 if self.parent.page_limit > 0: 7527 req.meta.limit = self.parent.page_limit 7528 if self.parent.snapshot_datetime is not None: 7529 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7530 7531 req.filter = plumbing.quote_filter_args(filter, *args) 7532 7533 def generator(svc, req): 7534 tries = 0 7535 while True: 7536 t = None if deadline is None else deadline - time.time() 7537 try: 7538 plumbing_response = svc.stub.List( 7539 req, 7540 metadata=svc.parent.get_metadata( 7541 'RolesHistory.List', req), 7542 timeout=t) 7543 except Exception as e: 7544 if self.parent.shouldRetry(tries, e, deadline): 7545 tries += 1 7546 time.sleep( 7547 self.parent.exponentialBackoff(tries, deadline)) 7548 continue 7549 raise plumbing.convert_error_to_porcelain(e) from e 7550 tries = 0 7551 for plumbing_item in plumbing_response.history: 7552 yield plumbing.convert_role_history_to_porcelain( 7553 plumbing_item) 7554 if plumbing_response.meta.next_cursor == '': 7555 break 7556 req.meta.cursor = plumbing_response.meta.next_cursor 7557 7558 return generator(self, req) 7559 7560 7561class SecretStores: 7562 ''' 7563 SecretStores are servers where resource secrets (passwords, keys) are stored. 7564 See: 7565 `strongdm.models.ActiveDirectoryStore` 7566 `strongdm.models.AWSStore` 7567 `strongdm.models.AWSCertX509Store` 7568 `strongdm.models.AzureStore` 7569 `strongdm.models.CyberarkConjurStore` 7570 `strongdm.models.CyberarkPAMStore` 7571 `strongdm.models.CyberarkPAMExperimentalStore` 7572 `strongdm.models.DelineaStore` 7573 `strongdm.models.DelineaDSVStore` 7574 `strongdm.models.GCPStore` 7575 `strongdm.models.GCPCertX509Store` 7576 `strongdm.models.KeyfactorSSHStore` 7577 `strongdm.models.KeyfactorX509Store` 7578 `strongdm.models.StrongVaultStore` 7579 `strongdm.models.VaultAppRoleStore` 7580 `strongdm.models.VaultAppRoleCertSSHStore` 7581 `strongdm.models.VaultAppRoleCertX509Store` 7582 `strongdm.models.VaultAWSEC2Store` 7583 `strongdm.models.VaultAWSEC2CertSSHStore` 7584 `strongdm.models.VaultAWSEC2CertX509Store` 7585 `strongdm.models.VaultAWSIAMStore` 7586 `strongdm.models.VaultAWSIAMCertSSHStore` 7587 `strongdm.models.VaultAWSIAMCertX509Store` 7588 `strongdm.models.VaultTLSStore` 7589 `strongdm.models.VaultTLSCertSSHStore` 7590 `strongdm.models.VaultTLSCertX509Store` 7591 `strongdm.models.VaultTokenStore` 7592 `strongdm.models.VaultTokenCertSSHStore` 7593 `strongdm.models.VaultTokenCertX509Store` 7594 ''' 7595 def __init__(self, channel, client): 7596 self.parent = client 7597 self.stub = SecretStoresStub(channel) 7598 7599 def create(self, secret_store, timeout=None): 7600 deadline = None if timeout is None else time.time() + timeout 7601 req = SecretStoreCreateRequest() 7602 7603 if secret_store is not None: 7604 req.secret_store.CopyFrom( 7605 plumbing.convert_secret_store_to_plumbing(secret_store)) 7606 tries = 0 7607 plumbing_response = None 7608 while True: 7609 t = None if deadline is None else deadline - time.time() 7610 try: 7611 plumbing_response = self.stub.Create( 7612 req, 7613 metadata=self.parent.get_metadata('SecretStores.Create', 7614 req), 7615 timeout=t) 7616 except Exception as e: 7617 if self.parent.shouldRetry(tries, e, deadline): 7618 tries += 1 7619 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7620 continue 7621 raise plumbing.convert_error_to_porcelain(e) from e 7622 break 7623 7624 resp = models.SecretStoreCreateResponse() 7625 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 7626 plumbing_response.meta) 7627 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7628 plumbing_response.rate_limit) 7629 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 7630 plumbing_response.secret_store) 7631 return resp 7632 7633 def get(self, id, timeout=None): 7634 ''' 7635 Get reads one SecretStore by ID. 7636 ''' 7637 deadline = None if timeout is None else time.time() + timeout 7638 req = SecretStoreGetRequest() 7639 if self.parent.snapshot_datetime is not None: 7640 req.meta.CopyFrom(GetRequestMetadata()) 7641 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7642 7643 req.id = (id) 7644 tries = 0 7645 plumbing_response = None 7646 while True: 7647 t = None if deadline is None else deadline - time.time() 7648 try: 7649 plumbing_response = self.stub.Get( 7650 req, 7651 metadata=self.parent.get_metadata('SecretStores.Get', req), 7652 timeout=t) 7653 except Exception as e: 7654 if self.parent.shouldRetry(tries, e, deadline): 7655 tries += 1 7656 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7657 continue 7658 raise plumbing.convert_error_to_porcelain(e) from e 7659 break 7660 7661 resp = models.SecretStoreGetResponse() 7662 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 7663 plumbing_response.meta) 7664 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7665 plumbing_response.rate_limit) 7666 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 7667 plumbing_response.secret_store) 7668 return resp 7669 7670 def update(self, secret_store, timeout=None): 7671 ''' 7672 Update replaces all the fields of a SecretStore by ID. 7673 ''' 7674 deadline = None if timeout is None else time.time() + timeout 7675 req = SecretStoreUpdateRequest() 7676 7677 if secret_store is not None: 7678 req.secret_store.CopyFrom( 7679 plumbing.convert_secret_store_to_plumbing(secret_store)) 7680 tries = 0 7681 plumbing_response = None 7682 while True: 7683 t = None if deadline is None else deadline - time.time() 7684 try: 7685 plumbing_response = self.stub.Update( 7686 req, 7687 metadata=self.parent.get_metadata('SecretStores.Update', 7688 req), 7689 timeout=t) 7690 except Exception as e: 7691 if self.parent.shouldRetry(tries, e, deadline): 7692 tries += 1 7693 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7694 continue 7695 raise plumbing.convert_error_to_porcelain(e) from e 7696 break 7697 7698 resp = models.SecretStoreUpdateResponse() 7699 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 7700 plumbing_response.meta) 7701 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7702 plumbing_response.rate_limit) 7703 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 7704 plumbing_response.secret_store) 7705 return resp 7706 7707 def delete(self, id, timeout=None): 7708 ''' 7709 Delete removes a SecretStore by ID. 7710 ''' 7711 deadline = None if timeout is None else time.time() + timeout 7712 req = SecretStoreDeleteRequest() 7713 7714 req.id = (id) 7715 tries = 0 7716 plumbing_response = None 7717 while True: 7718 t = None if deadline is None else deadline - time.time() 7719 try: 7720 plumbing_response = self.stub.Delete( 7721 req, 7722 metadata=self.parent.get_metadata('SecretStores.Delete', 7723 req), 7724 timeout=t) 7725 except Exception as e: 7726 if self.parent.shouldRetry(tries, e, deadline): 7727 tries += 1 7728 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7729 continue 7730 raise plumbing.convert_error_to_porcelain(e) from e 7731 break 7732 7733 resp = models.SecretStoreDeleteResponse() 7734 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 7735 plumbing_response.meta) 7736 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7737 plumbing_response.rate_limit) 7738 return resp 7739 7740 def list(self, filter, *args, timeout=None): 7741 ''' 7742 List gets a list of SecretStores matching a given set of criteria. 7743 ''' 7744 deadline = None if timeout is None else time.time() + timeout 7745 req = SecretStoreListRequest() 7746 req.meta.CopyFrom(ListRequestMetadata()) 7747 if self.parent.page_limit > 0: 7748 req.meta.limit = self.parent.page_limit 7749 if self.parent.snapshot_datetime is not None: 7750 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7751 7752 req.filter = plumbing.quote_filter_args(filter, *args) 7753 7754 def generator(svc, req): 7755 tries = 0 7756 while True: 7757 t = None if deadline is None else deadline - time.time() 7758 try: 7759 plumbing_response = svc.stub.List( 7760 req, 7761 metadata=svc.parent.get_metadata( 7762 'SecretStores.List', req), 7763 timeout=t) 7764 except Exception as e: 7765 if self.parent.shouldRetry(tries, e, deadline): 7766 tries += 1 7767 time.sleep( 7768 self.parent.exponentialBackoff(tries, deadline)) 7769 continue 7770 raise plumbing.convert_error_to_porcelain(e) from e 7771 tries = 0 7772 for plumbing_item in plumbing_response.secret_stores: 7773 yield plumbing.convert_secret_store_to_porcelain( 7774 plumbing_item) 7775 if plumbing_response.meta.next_cursor == '': 7776 break 7777 req.meta.cursor = plumbing_response.meta.next_cursor 7778 7779 return generator(self, req) 7780 7781 7782class SnapshotSecretStores: 7783 ''' 7784 SnapshotSecretStores exposes the read only methods of the SecretStores 7785 service for historical queries. 7786 ''' 7787 def __init__(self, secret_stores): 7788 self.secret_stores = secret_stores 7789 7790 def get(self, id, timeout=None): 7791 ''' 7792 Get reads one SecretStore by ID. 7793 ''' 7794 return self.secret_stores.get(id, timeout=timeout) 7795 7796 def list(self, filter, *args, timeout=None): 7797 ''' 7798 List gets a list of SecretStores matching a given set of criteria. 7799 ''' 7800 return self.secret_stores.list(filter, *args, timeout=timeout) 7801 7802 7803class SecretEngines: 7804 ''' 7805 7806 See: 7807 `strongdm.models.ActiveDirectoryEngine` 7808 `strongdm.models.KeyValueEngine` 7809 `strongdm.models.MysqlEngine` 7810 `strongdm.models.PostgresEngine` 7811 `strongdm.models.SqlserverEngine` 7812 ''' 7813 def __init__(self, channel, client): 7814 self.parent = client 7815 self.stub = SecretEnginesStub(channel) 7816 7817 def list(self, filter, *args, timeout=None): 7818 ''' 7819 List returns a list of Secret Engines 7820 ''' 7821 deadline = None if timeout is None else time.time() + timeout 7822 req = SecretEngineListRequest() 7823 req.meta.CopyFrom(ListRequestMetadata()) 7824 if self.parent.page_limit > 0: 7825 req.meta.limit = self.parent.page_limit 7826 if self.parent.snapshot_datetime is not None: 7827 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7828 7829 req.filter = plumbing.quote_filter_args(filter, *args) 7830 7831 def generator(svc, req): 7832 tries = 0 7833 while True: 7834 t = None if deadline is None else deadline - time.time() 7835 try: 7836 plumbing_response = svc.stub.List( 7837 req, 7838 metadata=svc.parent.get_metadata( 7839 'SecretEngines.List', req), 7840 timeout=t) 7841 except Exception as e: 7842 if self.parent.shouldRetry(tries, e, deadline): 7843 tries += 1 7844 time.sleep( 7845 self.parent.exponentialBackoff(tries, deadline)) 7846 continue 7847 raise plumbing.convert_error_to_porcelain(e) from e 7848 tries = 0 7849 for plumbing_item in plumbing_response.secret_engines: 7850 yield plumbing.convert_secret_engine_to_porcelain( 7851 plumbing_item) 7852 if plumbing_response.meta.next_cursor == '': 7853 break 7854 req.meta.cursor = plumbing_response.meta.next_cursor 7855 7856 return generator(self, req) 7857 7858 def get(self, id, timeout=None): 7859 ''' 7860 Get returns a secret engine details 7861 ''' 7862 deadline = None if timeout is None else time.time() + timeout 7863 req = SecretEngineGetRequest() 7864 if self.parent.snapshot_datetime is not None: 7865 req.meta.CopyFrom(GetRequestMetadata()) 7866 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7867 7868 req.id = (id) 7869 tries = 0 7870 plumbing_response = None 7871 while True: 7872 t = None if deadline is None else deadline - time.time() 7873 try: 7874 plumbing_response = self.stub.Get( 7875 req, 7876 metadata=self.parent.get_metadata('SecretEngines.Get', 7877 req), 7878 timeout=t) 7879 except Exception as e: 7880 if self.parent.shouldRetry(tries, e, deadline): 7881 tries += 1 7882 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7883 continue 7884 raise plumbing.convert_error_to_porcelain(e) from e 7885 break 7886 7887 resp = models.SecretEngineGetResponse() 7888 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 7889 plumbing_response.meta) 7890 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7891 plumbing_response.rate_limit) 7892 resp.secret_engine = plumbing.convert_secret_engine_to_porcelain( 7893 plumbing_response.secret_engine) 7894 return resp 7895 7896 def create(self, secret_engine, timeout=None): 7897 ''' 7898 Create creates a secret engine 7899 ''' 7900 deadline = None if timeout is None else time.time() + timeout 7901 req = SecretEngineCreateRequest() 7902 7903 if secret_engine is not None: 7904 req.secret_engine.CopyFrom( 7905 plumbing.convert_secret_engine_to_plumbing(secret_engine)) 7906 tries = 0 7907 plumbing_response = None 7908 while True: 7909 t = None if deadline is None else deadline - time.time() 7910 try: 7911 plumbing_response = self.stub.Create( 7912 req, 7913 metadata=self.parent.get_metadata('SecretEngines.Create', 7914 req), 7915 timeout=t) 7916 except Exception as e: 7917 if self.parent.shouldRetry(tries, e, deadline): 7918 tries += 1 7919 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7920 continue 7921 raise plumbing.convert_error_to_porcelain(e) from e 7922 break 7923 7924 resp = models.SecretEngineCreateResponse() 7925 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 7926 plumbing_response.meta) 7927 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7928 plumbing_response.rate_limit) 7929 resp.secret_engine = plumbing.convert_secret_engine_to_porcelain( 7930 plumbing_response.secret_engine) 7931 return resp 7932 7933 def update(self, secret_engine, timeout=None): 7934 ''' 7935 Update updates a secret engine 7936 ''' 7937 deadline = None if timeout is None else time.time() + timeout 7938 req = SecretEngineUpdateRequest() 7939 7940 if secret_engine is not None: 7941 req.secret_engine.CopyFrom( 7942 plumbing.convert_secret_engine_to_plumbing(secret_engine)) 7943 tries = 0 7944 plumbing_response = None 7945 while True: 7946 t = None if deadline is None else deadline - time.time() 7947 try: 7948 plumbing_response = self.stub.Update( 7949 req, 7950 metadata=self.parent.get_metadata('SecretEngines.Update', 7951 req), 7952 timeout=t) 7953 except Exception as e: 7954 if self.parent.shouldRetry(tries, e, deadline): 7955 tries += 1 7956 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7957 continue 7958 raise plumbing.convert_error_to_porcelain(e) from e 7959 break 7960 7961 resp = models.SecretEngineUpdateResponse() 7962 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 7963 plumbing_response.meta) 7964 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7965 plumbing_response.rate_limit) 7966 resp.secret_engine = plumbing.convert_secret_engine_to_porcelain( 7967 plumbing_response.secret_engine) 7968 return resp 7969 7970 def delete(self, id, timeout=None): 7971 ''' 7972 Delete deletes a secret engine 7973 ''' 7974 deadline = None if timeout is None else time.time() + timeout 7975 req = SecretEngineDeleteRequest() 7976 7977 req.id = (id) 7978 tries = 0 7979 plumbing_response = None 7980 while True: 7981 t = None if deadline is None else deadline - time.time() 7982 try: 7983 plumbing_response = self.stub.Delete( 7984 req, 7985 metadata=self.parent.get_metadata('SecretEngines.Delete', 7986 req), 7987 timeout=t) 7988 except Exception as e: 7989 if self.parent.shouldRetry(tries, e, deadline): 7990 tries += 1 7991 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7992 continue 7993 raise plumbing.convert_error_to_porcelain(e) from e 7994 break 7995 7996 resp = models.SecretEngineDeleteResponse() 7997 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7998 plumbing_response.rate_limit) 7999 return resp 8000 8001 def list_secret_stores(self, filter, *args, timeout=None): 8002 ''' 8003 ListSecretStores returns a list of Secret Stores that can be used as a backing store 8004 for Secret Engine 8005 ''' 8006 deadline = None if timeout is None else time.time() + timeout 8007 req = SecretStoreListRequest() 8008 req.meta.CopyFrom(ListRequestMetadata()) 8009 if self.parent.page_limit > 0: 8010 req.meta.limit = self.parent.page_limit 8011 if self.parent.snapshot_datetime is not None: 8012 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8013 8014 req.filter = plumbing.quote_filter_args(filter, *args) 8015 8016 def generator(svc, req): 8017 tries = 0 8018 while True: 8019 t = None if deadline is None else deadline - time.time() 8020 try: 8021 plumbing_response = svc.stub.ListSecretStores( 8022 req, 8023 metadata=svc.parent.get_metadata( 8024 'SecretEngines.ListSecretStores', req), 8025 timeout=t) 8026 except Exception as e: 8027 if self.parent.shouldRetry(tries, e, deadline): 8028 tries += 1 8029 time.sleep( 8030 self.parent.exponentialBackoff(tries, deadline)) 8031 continue 8032 raise plumbing.convert_error_to_porcelain(e) from e 8033 tries = 0 8034 for plumbing_item in plumbing_response.secret_stores: 8035 yield plumbing.convert_secret_store_to_porcelain( 8036 plumbing_item) 8037 if plumbing_response.meta.next_cursor == '': 8038 break 8039 req.meta.cursor = plumbing_response.meta.next_cursor 8040 8041 return generator(self, req) 8042 8043 def generate_keys(self, secret_engine_id, timeout=None): 8044 ''' 8045 GenerateKeys generates a private key, stores it in a secret store and stores a public key in a secret engine 8046 ''' 8047 deadline = None if timeout is None else time.time() + timeout 8048 req = GenerateKeysRequest() 8049 8050 req.secret_engine_id = (secret_engine_id) 8051 tries = 0 8052 plumbing_response = None 8053 while True: 8054 t = None if deadline is None else deadline - time.time() 8055 try: 8056 plumbing_response = self.stub.GenerateKeys( 8057 req, 8058 metadata=self.parent.get_metadata( 8059 'SecretEngines.GenerateKeys', req), 8060 timeout=t) 8061 except Exception as e: 8062 if self.parent.shouldRetry(tries, e, deadline): 8063 tries += 1 8064 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8065 continue 8066 raise plumbing.convert_error_to_porcelain(e) from e 8067 break 8068 8069 resp = models.GenerateKeysResponse() 8070 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8071 plumbing_response.rate_limit) 8072 return resp 8073 8074 def healthcheck(self, secret_engine_id, timeout=None): 8075 ''' 8076 Healthcheck triggers a healthcheck for all nodes serving a secret engine 8077 ''' 8078 deadline = None if timeout is None else time.time() + timeout 8079 req = HealthcheckRequest() 8080 8081 req.secret_engine_id = (secret_engine_id) 8082 tries = 0 8083 plumbing_response = None 8084 while True: 8085 t = None if deadline is None else deadline - time.time() 8086 try: 8087 plumbing_response = self.stub.Healthcheck( 8088 req, 8089 metadata=self.parent.get_metadata( 8090 'SecretEngines.Healthcheck', req), 8091 timeout=t) 8092 except Exception as e: 8093 if self.parent.shouldRetry(tries, e, deadline): 8094 tries += 1 8095 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8096 continue 8097 raise plumbing.convert_error_to_porcelain(e) from e 8098 break 8099 8100 resp = models.HealthcheckResponse() 8101 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8102 plumbing_response.rate_limit) 8103 resp.status = plumbing.convert_repeated_healthcheck_status_to_porcelain( 8104 plumbing_response.status) 8105 return resp 8106 8107 def rotate(self, id, password_policy, timeout=None): 8108 ''' 8109 Rotate rotates secret engine's credentials 8110 ''' 8111 deadline = None if timeout is None else time.time() + timeout 8112 req = SecretEngineRotateRequest() 8113 8114 req.id = (id) 8115 if password_policy is not None: 8116 req.password_policy.CopyFrom( 8117 plumbing.convert_secret_engine_password_policy_to_plumbing( 8118 password_policy)) 8119 tries = 0 8120 plumbing_response = None 8121 while True: 8122 t = None if deadline is None else deadline - time.time() 8123 try: 8124 plumbing_response = self.stub.Rotate( 8125 req, 8126 metadata=self.parent.get_metadata('SecretEngines.Rotate', 8127 req), 8128 timeout=t) 8129 except Exception as e: 8130 if self.parent.shouldRetry(tries, e, deadline): 8131 tries += 1 8132 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8133 continue 8134 raise plumbing.convert_error_to_porcelain(e) from e 8135 break 8136 8137 resp = models.SecretEngineRotateResponse() 8138 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8139 plumbing_response.rate_limit) 8140 return resp 8141 8142 8143class SecretStoreHealths: 8144 ''' 8145 SecretStoreHealths exposes health states for secret stores. 8146 See `strongdm.models.SecretStoreHealth`. 8147 ''' 8148 def __init__(self, channel, client): 8149 self.parent = client 8150 self.stub = SecretStoreHealthsStub(channel) 8151 8152 def list(self, filter, *args, timeout=None): 8153 ''' 8154 List reports the health status of node to secret store pairs. 8155 ''' 8156 deadline = None if timeout is None else time.time() + timeout 8157 req = SecretStoreHealthListRequest() 8158 req.meta.CopyFrom(ListRequestMetadata()) 8159 if self.parent.page_limit > 0: 8160 req.meta.limit = self.parent.page_limit 8161 if self.parent.snapshot_datetime is not None: 8162 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8163 8164 req.filter = plumbing.quote_filter_args(filter, *args) 8165 8166 def generator(svc, req): 8167 tries = 0 8168 while True: 8169 t = None if deadline is None else deadline - time.time() 8170 try: 8171 plumbing_response = svc.stub.List( 8172 req, 8173 metadata=svc.parent.get_metadata( 8174 'SecretStoreHealths.List', req), 8175 timeout=t) 8176 except Exception as e: 8177 if self.parent.shouldRetry(tries, e, deadline): 8178 tries += 1 8179 time.sleep( 8180 self.parent.exponentialBackoff(tries, deadline)) 8181 continue 8182 raise plumbing.convert_error_to_porcelain(e) from e 8183 tries = 0 8184 for plumbing_item in plumbing_response.secret_store_healths: 8185 yield plumbing.convert_secret_store_health_to_porcelain( 8186 plumbing_item) 8187 if plumbing_response.meta.next_cursor == '': 8188 break 8189 req.meta.cursor = plumbing_response.meta.next_cursor 8190 8191 return generator(self, req) 8192 8193 def healthcheck(self, secret_store_id, timeout=None): 8194 ''' 8195 Healthcheck triggers a remote healthcheck request for a secret store. It may take minutes 8196 to propagate across a large network of Nodes. The call will return immediately, and the 8197 updated health of the Secret Store can be retrieved via List. 8198 ''' 8199 deadline = None if timeout is None else time.time() + timeout 8200 req = SecretStoreHealthcheckRequest() 8201 8202 req.secret_store_id = (secret_store_id) 8203 tries = 0 8204 plumbing_response = None 8205 while True: 8206 t = None if deadline is None else deadline - time.time() 8207 try: 8208 plumbing_response = self.stub.Healthcheck( 8209 req, 8210 metadata=self.parent.get_metadata( 8211 'SecretStoreHealths.Healthcheck', req), 8212 timeout=t) 8213 except Exception as e: 8214 if self.parent.shouldRetry(tries, e, deadline): 8215 tries += 1 8216 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8217 continue 8218 raise plumbing.convert_error_to_porcelain(e) from e 8219 break 8220 8221 resp = models.SecretStoreHealthcheckResponse() 8222 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8223 plumbing_response.rate_limit) 8224 return resp 8225 8226 8227class SecretStoresHistory: 8228 ''' 8229 SecretStoresHistory records all changes to the state of a SecretStore. 8230 See `strongdm.models.SecretStoreHistory`. 8231 ''' 8232 def __init__(self, channel, client): 8233 self.parent = client 8234 self.stub = SecretStoresHistoryStub(channel) 8235 8236 def list(self, filter, *args, timeout=None): 8237 ''' 8238 List gets a list of SecretStoreHistory records matching a given set of criteria. 8239 ''' 8240 deadline = None if timeout is None else time.time() + timeout 8241 req = SecretStoreHistoryListRequest() 8242 req.meta.CopyFrom(ListRequestMetadata()) 8243 if self.parent.page_limit > 0: 8244 req.meta.limit = self.parent.page_limit 8245 if self.parent.snapshot_datetime is not None: 8246 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8247 8248 req.filter = plumbing.quote_filter_args(filter, *args) 8249 8250 def generator(svc, req): 8251 tries = 0 8252 while True: 8253 t = None if deadline is None else deadline - time.time() 8254 try: 8255 plumbing_response = svc.stub.List( 8256 req, 8257 metadata=svc.parent.get_metadata( 8258 'SecretStoresHistory.List', req), 8259 timeout=t) 8260 except Exception as e: 8261 if self.parent.shouldRetry(tries, e, deadline): 8262 tries += 1 8263 time.sleep( 8264 self.parent.exponentialBackoff(tries, deadline)) 8265 continue 8266 raise plumbing.convert_error_to_porcelain(e) from e 8267 tries = 0 8268 for plumbing_item in plumbing_response.history: 8269 yield plumbing.convert_secret_store_history_to_porcelain( 8270 plumbing_item) 8271 if plumbing_response.meta.next_cursor == '': 8272 break 8273 req.meta.cursor = plumbing_response.meta.next_cursor 8274 8275 return generator(self, req) 8276 8277 8278class WorkflowApprovers: 8279 ''' 8280 WorkflowApprovers is an account or a role with the ability to approve requests bound to a workflow. 8281 See `strongdm.models.WorkflowApprover`. 8282 ''' 8283 def __init__(self, channel, client): 8284 self.parent = client 8285 self.stub = WorkflowApproversStub(channel) 8286 8287 def create(self, workflow_approver, timeout=None): 8288 ''' 8289 Create creates a new workflow approver 8290 ''' 8291 deadline = None if timeout is None else time.time() + timeout 8292 req = WorkflowApproversCreateRequest() 8293 8294 if workflow_approver is not None: 8295 req.workflow_approver.CopyFrom( 8296 plumbing.convert_workflow_approver_to_plumbing( 8297 workflow_approver)) 8298 tries = 0 8299 plumbing_response = None 8300 while True: 8301 t = None if deadline is None else deadline - time.time() 8302 try: 8303 plumbing_response = self.stub.Create( 8304 req, 8305 metadata=self.parent.get_metadata( 8306 'WorkflowApprovers.Create', req), 8307 timeout=t) 8308 except Exception as e: 8309 if self.parent.shouldRetry(tries, e, deadline): 8310 tries += 1 8311 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8312 continue 8313 raise plumbing.convert_error_to_porcelain(e) from e 8314 break 8315 8316 resp = models.WorkflowApproversCreateResponse() 8317 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8318 plumbing_response.rate_limit) 8319 resp.workflow_approver = plumbing.convert_workflow_approver_to_porcelain( 8320 plumbing_response.workflow_approver) 8321 return resp 8322 8323 def get(self, id, timeout=None): 8324 ''' 8325 Get reads one workflow approver by ID. 8326 ''' 8327 deadline = None if timeout is None else time.time() + timeout 8328 req = WorkflowApproverGetRequest() 8329 if self.parent.snapshot_datetime is not None: 8330 req.meta.CopyFrom(GetRequestMetadata()) 8331 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8332 8333 req.id = (id) 8334 tries = 0 8335 plumbing_response = None 8336 while True: 8337 t = None if deadline is None else deadline - time.time() 8338 try: 8339 plumbing_response = self.stub.Get( 8340 req, 8341 metadata=self.parent.get_metadata('WorkflowApprovers.Get', 8342 req), 8343 timeout=t) 8344 except Exception as e: 8345 if self.parent.shouldRetry(tries, e, deadline): 8346 tries += 1 8347 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8348 continue 8349 raise plumbing.convert_error_to_porcelain(e) from e 8350 break 8351 8352 resp = models.WorkflowApproverGetResponse() 8353 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 8354 plumbing_response.meta) 8355 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8356 plumbing_response.rate_limit) 8357 resp.workflow_approver = plumbing.convert_workflow_approver_to_porcelain( 8358 plumbing_response.workflow_approver) 8359 return resp 8360 8361 def delete(self, id, timeout=None): 8362 ''' 8363 Delete deletes a workflow approver 8364 ''' 8365 deadline = None if timeout is None else time.time() + timeout 8366 req = WorkflowApproversDeleteRequest() 8367 8368 req.id = (id) 8369 tries = 0 8370 plumbing_response = None 8371 while True: 8372 t = None if deadline is None else deadline - time.time() 8373 try: 8374 plumbing_response = self.stub.Delete( 8375 req, 8376 metadata=self.parent.get_metadata( 8377 'WorkflowApprovers.Delete', req), 8378 timeout=t) 8379 except Exception as e: 8380 if self.parent.shouldRetry(tries, e, deadline): 8381 tries += 1 8382 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8383 continue 8384 raise plumbing.convert_error_to_porcelain(e) from e 8385 break 8386 8387 resp = models.WorkflowApproversDeleteResponse() 8388 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8389 plumbing_response.rate_limit) 8390 return resp 8391 8392 def list(self, filter, *args, timeout=None): 8393 ''' 8394 Lists existing workflow approvers. 8395 ''' 8396 deadline = None if timeout is None else time.time() + timeout 8397 req = WorkflowApproversListRequest() 8398 req.meta.CopyFrom(ListRequestMetadata()) 8399 if self.parent.page_limit > 0: 8400 req.meta.limit = self.parent.page_limit 8401 if self.parent.snapshot_datetime is not None: 8402 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8403 8404 req.filter = plumbing.quote_filter_args(filter, *args) 8405 8406 def generator(svc, req): 8407 tries = 0 8408 while True: 8409 t = None if deadline is None else deadline - time.time() 8410 try: 8411 plumbing_response = svc.stub.List( 8412 req, 8413 metadata=svc.parent.get_metadata( 8414 'WorkflowApprovers.List', req), 8415 timeout=t) 8416 except Exception as e: 8417 if self.parent.shouldRetry(tries, e, deadline): 8418 tries += 1 8419 time.sleep( 8420 self.parent.exponentialBackoff(tries, deadline)) 8421 continue 8422 raise plumbing.convert_error_to_porcelain(e) from e 8423 tries = 0 8424 for plumbing_item in plumbing_response.workflow_approvers: 8425 yield plumbing.convert_workflow_approver_to_porcelain( 8426 plumbing_item) 8427 if plumbing_response.meta.next_cursor == '': 8428 break 8429 req.meta.cursor = plumbing_response.meta.next_cursor 8430 8431 return generator(self, req) 8432 8433 8434class SnapshotWorkflowApprovers: 8435 ''' 8436 SnapshotWorkflowApprovers exposes the read only methods of the WorkflowApprovers 8437 service for historical queries. 8438 ''' 8439 def __init__(self, workflow_approvers): 8440 self.workflow_approvers = workflow_approvers 8441 8442 def get(self, id, timeout=None): 8443 ''' 8444 Get reads one workflow approver by ID. 8445 ''' 8446 return self.workflow_approvers.get(id, timeout=timeout) 8447 8448 def list(self, filter, *args, timeout=None): 8449 ''' 8450 Lists existing workflow approvers. 8451 ''' 8452 return self.workflow_approvers.list(filter, *args, timeout=timeout) 8453 8454 8455class WorkflowApproversHistory: 8456 ''' 8457 WorkflowApproversHistory provides records of all changes to the state of a WorkflowApprover. 8458 See `strongdm.models.WorkflowApproverHistory`. 8459 ''' 8460 def __init__(self, channel, client): 8461 self.parent = client 8462 self.stub = WorkflowApproversHistoryStub(channel) 8463 8464 def list(self, filter, *args, timeout=None): 8465 ''' 8466 List gets a list of WorkflowApproversHistory records matching a given set of criteria. 8467 ''' 8468 deadline = None if timeout is None else time.time() + timeout 8469 req = WorkflowApproversHistoryListRequest() 8470 req.meta.CopyFrom(ListRequestMetadata()) 8471 if self.parent.page_limit > 0: 8472 req.meta.limit = self.parent.page_limit 8473 if self.parent.snapshot_datetime is not None: 8474 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8475 8476 req.filter = plumbing.quote_filter_args(filter, *args) 8477 8478 def generator(svc, req): 8479 tries = 0 8480 while True: 8481 t = None if deadline is None else deadline - time.time() 8482 try: 8483 plumbing_response = svc.stub.List( 8484 req, 8485 metadata=svc.parent.get_metadata( 8486 'WorkflowApproversHistory.List', req), 8487 timeout=t) 8488 except Exception as e: 8489 if self.parent.shouldRetry(tries, e, deadline): 8490 tries += 1 8491 time.sleep( 8492 self.parent.exponentialBackoff(tries, deadline)) 8493 continue 8494 raise plumbing.convert_error_to_porcelain(e) from e 8495 tries = 0 8496 for plumbing_item in plumbing_response.history: 8497 yield plumbing.convert_workflow_approver_history_to_porcelain( 8498 plumbing_item) 8499 if plumbing_response.meta.next_cursor == '': 8500 break 8501 req.meta.cursor = plumbing_response.meta.next_cursor 8502 8503 return generator(self, req) 8504 8505 8506class WorkflowRoles: 8507 ''' 8508 WorkflowRole links a role to a workflow. The linked roles indicate which roles a user must be a part of 8509 to request access to a resource via the workflow. 8510 See `strongdm.models.WorkflowRole`. 8511 ''' 8512 def __init__(self, channel, client): 8513 self.parent = client 8514 self.stub = WorkflowRolesStub(channel) 8515 8516 def create(self, workflow_role, timeout=None): 8517 ''' 8518 Create creates a new workflow role 8519 ''' 8520 deadline = None if timeout is None else time.time() + timeout 8521 req = WorkflowRolesCreateRequest() 8522 8523 if workflow_role is not None: 8524 req.workflow_role.CopyFrom( 8525 plumbing.convert_workflow_role_to_plumbing(workflow_role)) 8526 tries = 0 8527 plumbing_response = None 8528 while True: 8529 t = None if deadline is None else deadline - time.time() 8530 try: 8531 plumbing_response = self.stub.Create( 8532 req, 8533 metadata=self.parent.get_metadata('WorkflowRoles.Create', 8534 req), 8535 timeout=t) 8536 except Exception as e: 8537 if self.parent.shouldRetry(tries, e, deadline): 8538 tries += 1 8539 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8540 continue 8541 raise plumbing.convert_error_to_porcelain(e) from e 8542 break 8543 8544 resp = models.WorkflowRolesCreateResponse() 8545 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8546 plumbing_response.rate_limit) 8547 resp.workflow_role = plumbing.convert_workflow_role_to_porcelain( 8548 plumbing_response.workflow_role) 8549 return resp 8550 8551 def get(self, id, timeout=None): 8552 ''' 8553 Get reads one workflow role by ID. 8554 ''' 8555 deadline = None if timeout is None else time.time() + timeout 8556 req = WorkflowRoleGetRequest() 8557 if self.parent.snapshot_datetime is not None: 8558 req.meta.CopyFrom(GetRequestMetadata()) 8559 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8560 8561 req.id = (id) 8562 tries = 0 8563 plumbing_response = None 8564 while True: 8565 t = None if deadline is None else deadline - time.time() 8566 try: 8567 plumbing_response = self.stub.Get( 8568 req, 8569 metadata=self.parent.get_metadata('WorkflowRoles.Get', 8570 req), 8571 timeout=t) 8572 except Exception as e: 8573 if self.parent.shouldRetry(tries, e, deadline): 8574 tries += 1 8575 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8576 continue 8577 raise plumbing.convert_error_to_porcelain(e) from e 8578 break 8579 8580 resp = models.WorkflowRoleGetResponse() 8581 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 8582 plumbing_response.meta) 8583 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8584 plumbing_response.rate_limit) 8585 resp.workflow_role = plumbing.convert_workflow_role_to_porcelain( 8586 plumbing_response.workflow_role) 8587 return resp 8588 8589 def delete(self, id, timeout=None): 8590 ''' 8591 Delete deletes a workflow role 8592 ''' 8593 deadline = None if timeout is None else time.time() + timeout 8594 req = WorkflowRolesDeleteRequest() 8595 8596 req.id = (id) 8597 tries = 0 8598 plumbing_response = None 8599 while True: 8600 t = None if deadline is None else deadline - time.time() 8601 try: 8602 plumbing_response = self.stub.Delete( 8603 req, 8604 metadata=self.parent.get_metadata('WorkflowRoles.Delete', 8605 req), 8606 timeout=t) 8607 except Exception as e: 8608 if self.parent.shouldRetry(tries, e, deadline): 8609 tries += 1 8610 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8611 continue 8612 raise plumbing.convert_error_to_porcelain(e) from e 8613 break 8614 8615 resp = models.WorkflowRolesDeleteResponse() 8616 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8617 plumbing_response.rate_limit) 8618 return resp 8619 8620 def list(self, filter, *args, timeout=None): 8621 ''' 8622 Lists existing workflow roles. 8623 ''' 8624 deadline = None if timeout is None else time.time() + timeout 8625 req = WorkflowRolesListRequest() 8626 req.meta.CopyFrom(ListRequestMetadata()) 8627 if self.parent.page_limit > 0: 8628 req.meta.limit = self.parent.page_limit 8629 if self.parent.snapshot_datetime is not None: 8630 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8631 8632 req.filter = plumbing.quote_filter_args(filter, *args) 8633 8634 def generator(svc, req): 8635 tries = 0 8636 while True: 8637 t = None if deadline is None else deadline - time.time() 8638 try: 8639 plumbing_response = svc.stub.List( 8640 req, 8641 metadata=svc.parent.get_metadata( 8642 'WorkflowRoles.List', req), 8643 timeout=t) 8644 except Exception as e: 8645 if self.parent.shouldRetry(tries, e, deadline): 8646 tries += 1 8647 time.sleep( 8648 self.parent.exponentialBackoff(tries, deadline)) 8649 continue 8650 raise plumbing.convert_error_to_porcelain(e) from e 8651 tries = 0 8652 for plumbing_item in plumbing_response.workflow_role: 8653 yield plumbing.convert_workflow_role_to_porcelain( 8654 plumbing_item) 8655 if plumbing_response.meta.next_cursor == '': 8656 break 8657 req.meta.cursor = plumbing_response.meta.next_cursor 8658 8659 return generator(self, req) 8660 8661 8662class SnapshotWorkflowRoles: 8663 ''' 8664 SnapshotWorkflowRoles exposes the read only methods of the WorkflowRoles 8665 service for historical queries. 8666 ''' 8667 def __init__(self, workflow_roles): 8668 self.workflow_roles = workflow_roles 8669 8670 def get(self, id, timeout=None): 8671 ''' 8672 Get reads one workflow role by ID. 8673 ''' 8674 return self.workflow_roles.get(id, timeout=timeout) 8675 8676 def list(self, filter, *args, timeout=None): 8677 ''' 8678 Lists existing workflow roles. 8679 ''' 8680 return self.workflow_roles.list(filter, *args, timeout=timeout) 8681 8682 8683class WorkflowRolesHistory: 8684 ''' 8685 WorkflowRolesHistory provides records of all changes to the state of a WorkflowRole 8686 See `strongdm.models.WorkflowRoleHistory`. 8687 ''' 8688 def __init__(self, channel, client): 8689 self.parent = client 8690 self.stub = WorkflowRolesHistoryStub(channel) 8691 8692 def list(self, filter, *args, timeout=None): 8693 ''' 8694 List gets a list of WorkflowRolesHistory records matching a given set of criteria. 8695 ''' 8696 deadline = None if timeout is None else time.time() + timeout 8697 req = WorkflowRolesHistoryListRequest() 8698 req.meta.CopyFrom(ListRequestMetadata()) 8699 if self.parent.page_limit > 0: 8700 req.meta.limit = self.parent.page_limit 8701 if self.parent.snapshot_datetime is not None: 8702 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8703 8704 req.filter = plumbing.quote_filter_args(filter, *args) 8705 8706 def generator(svc, req): 8707 tries = 0 8708 while True: 8709 t = None if deadline is None else deadline - time.time() 8710 try: 8711 plumbing_response = svc.stub.List( 8712 req, 8713 metadata=svc.parent.get_metadata( 8714 'WorkflowRolesHistory.List', req), 8715 timeout=t) 8716 except Exception as e: 8717 if self.parent.shouldRetry(tries, e, deadline): 8718 tries += 1 8719 time.sleep( 8720 self.parent.exponentialBackoff(tries, deadline)) 8721 continue 8722 raise plumbing.convert_error_to_porcelain(e) from e 8723 tries = 0 8724 for plumbing_item in plumbing_response.history: 8725 yield plumbing.convert_workflow_role_history_to_porcelain( 8726 plumbing_item) 8727 if plumbing_response.meta.next_cursor == '': 8728 break 8729 req.meta.cursor = plumbing_response.meta.next_cursor 8730 8731 return generator(self, req) 8732 8733 8734class Workflows: 8735 ''' 8736 Workflows are the collection of rules that define the resources to which access can be requested, 8737 the users that can request that access, and the mechanism for approving those requests which can either 8738 be automatic approval or a set of users authorized to approve the requests. 8739 See `strongdm.models.Workflow`. 8740 ''' 8741 def __init__(self, channel, client): 8742 self.parent = client 8743 self.stub = WorkflowsStub(channel) 8744 8745 def create(self, workflow, timeout=None): 8746 ''' 8747 Create creates a new workflow and requires a name for the workflow. 8748 ''' 8749 deadline = None if timeout is None else time.time() + timeout 8750 req = WorkflowCreateRequest() 8751 8752 if workflow is not None: 8753 req.workflow.CopyFrom( 8754 plumbing.convert_workflow_to_plumbing(workflow)) 8755 tries = 0 8756 plumbing_response = None 8757 while True: 8758 t = None if deadline is None else deadline - time.time() 8759 try: 8760 plumbing_response = self.stub.Create( 8761 req, 8762 metadata=self.parent.get_metadata('Workflows.Create', req), 8763 timeout=t) 8764 except Exception as e: 8765 if self.parent.shouldRetry(tries, e, deadline): 8766 tries += 1 8767 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8768 continue 8769 raise plumbing.convert_error_to_porcelain(e) from e 8770 break 8771 8772 resp = models.WorkflowCreateResponse() 8773 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8774 plumbing_response.rate_limit) 8775 resp.workflow = plumbing.convert_workflow_to_porcelain( 8776 plumbing_response.workflow) 8777 return resp 8778 8779 def get(self, id, timeout=None): 8780 ''' 8781 Get reads one workflow by ID. 8782 ''' 8783 deadline = None if timeout is None else time.time() + timeout 8784 req = WorkflowGetRequest() 8785 if self.parent.snapshot_datetime is not None: 8786 req.meta.CopyFrom(GetRequestMetadata()) 8787 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8788 8789 req.id = (id) 8790 tries = 0 8791 plumbing_response = None 8792 while True: 8793 t = None if deadline is None else deadline - time.time() 8794 try: 8795 plumbing_response = self.stub.Get( 8796 req, 8797 metadata=self.parent.get_metadata('Workflows.Get', req), 8798 timeout=t) 8799 except Exception as e: 8800 if self.parent.shouldRetry(tries, e, deadline): 8801 tries += 1 8802 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8803 continue 8804 raise plumbing.convert_error_to_porcelain(e) from e 8805 break 8806 8807 resp = models.WorkflowGetResponse() 8808 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 8809 plumbing_response.meta) 8810 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8811 plumbing_response.rate_limit) 8812 resp.workflow = plumbing.convert_workflow_to_porcelain( 8813 plumbing_response.workflow) 8814 return resp 8815 8816 def delete(self, id, timeout=None): 8817 ''' 8818 Delete deletes an existing workflow. 8819 ''' 8820 deadline = None if timeout is None else time.time() + timeout 8821 req = WorkflowDeleteRequest() 8822 8823 req.id = (id) 8824 tries = 0 8825 plumbing_response = None 8826 while True: 8827 t = None if deadline is None else deadline - time.time() 8828 try: 8829 plumbing_response = self.stub.Delete( 8830 req, 8831 metadata=self.parent.get_metadata('Workflows.Delete', req), 8832 timeout=t) 8833 except Exception as e: 8834 if self.parent.shouldRetry(tries, e, deadline): 8835 tries += 1 8836 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8837 continue 8838 raise plumbing.convert_error_to_porcelain(e) from e 8839 break 8840 8841 resp = models.WorkflowDeleteResponse() 8842 resp.id = (plumbing_response.id) 8843 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8844 plumbing_response.rate_limit) 8845 return resp 8846 8847 def update(self, workflow, timeout=None): 8848 ''' 8849 Update updates an existing workflow. 8850 ''' 8851 deadline = None if timeout is None else time.time() + timeout 8852 req = WorkflowUpdateRequest() 8853 8854 if workflow is not None: 8855 req.workflow.CopyFrom( 8856 plumbing.convert_workflow_to_plumbing(workflow)) 8857 tries = 0 8858 plumbing_response = None 8859 while True: 8860 t = None if deadline is None else deadline - time.time() 8861 try: 8862 plumbing_response = self.stub.Update( 8863 req, 8864 metadata=self.parent.get_metadata('Workflows.Update', req), 8865 timeout=t) 8866 except Exception as e: 8867 if self.parent.shouldRetry(tries, e, deadline): 8868 tries += 1 8869 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8870 continue 8871 raise plumbing.convert_error_to_porcelain(e) from e 8872 break 8873 8874 resp = models.WorkflowUpdateResponse() 8875 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8876 plumbing_response.rate_limit) 8877 resp.workflow = plumbing.convert_workflow_to_porcelain( 8878 plumbing_response.workflow) 8879 return resp 8880 8881 def list(self, filter, *args, timeout=None): 8882 ''' 8883 Lists existing workflows. 8884 ''' 8885 deadline = None if timeout is None else time.time() + timeout 8886 req = WorkflowListRequest() 8887 req.meta.CopyFrom(ListRequestMetadata()) 8888 if self.parent.page_limit > 0: 8889 req.meta.limit = self.parent.page_limit 8890 if self.parent.snapshot_datetime is not None: 8891 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8892 8893 req.filter = plumbing.quote_filter_args(filter, *args) 8894 8895 def generator(svc, req): 8896 tries = 0 8897 while True: 8898 t = None if deadline is None else deadline - time.time() 8899 try: 8900 plumbing_response = svc.stub.List( 8901 req, 8902 metadata=svc.parent.get_metadata( 8903 'Workflows.List', req), 8904 timeout=t) 8905 except Exception as e: 8906 if self.parent.shouldRetry(tries, e, deadline): 8907 tries += 1 8908 time.sleep( 8909 self.parent.exponentialBackoff(tries, deadline)) 8910 continue 8911 raise plumbing.convert_error_to_porcelain(e) from e 8912 tries = 0 8913 for plumbing_item in plumbing_response.workflows: 8914 yield plumbing.convert_workflow_to_porcelain(plumbing_item) 8915 if plumbing_response.meta.next_cursor == '': 8916 break 8917 req.meta.cursor = plumbing_response.meta.next_cursor 8918 8919 return generator(self, req) 8920 8921 8922class SnapshotWorkflows: 8923 ''' 8924 SnapshotWorkflows exposes the read only methods of the Workflows 8925 service for historical queries. 8926 ''' 8927 def __init__(self, workflows): 8928 self.workflows = workflows 8929 8930 def get(self, id, timeout=None): 8931 ''' 8932 Get reads one workflow by ID. 8933 ''' 8934 return self.workflows.get(id, timeout=timeout) 8935 8936 def list(self, filter, *args, timeout=None): 8937 ''' 8938 Lists existing workflows. 8939 ''' 8940 return self.workflows.list(filter, *args, timeout=timeout) 8941 8942 8943class WorkflowsHistory: 8944 ''' 8945 WorkflowsHistory provides records of all changes to the state of a Workflow. 8946 See `strongdm.models.WorkflowHistory`. 8947 ''' 8948 def __init__(self, channel, client): 8949 self.parent = client 8950 self.stub = WorkflowsHistoryStub(channel) 8951 8952 def list(self, filter, *args, timeout=None): 8953 ''' 8954 List gets a list of WorkflowHistory records matching a given set of criteria. 8955 ''' 8956 deadline = None if timeout is None else time.time() + timeout 8957 req = WorkflowHistoryListRequest() 8958 req.meta.CopyFrom(ListRequestMetadata()) 8959 if self.parent.page_limit > 0: 8960 req.meta.limit = self.parent.page_limit 8961 if self.parent.snapshot_datetime is not None: 8962 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8963 8964 req.filter = plumbing.quote_filter_args(filter, *args) 8965 8966 def generator(svc, req): 8967 tries = 0 8968 while True: 8969 t = None if deadline is None else deadline - time.time() 8970 try: 8971 plumbing_response = svc.stub.List( 8972 req, 8973 metadata=svc.parent.get_metadata( 8974 'WorkflowsHistory.List', req), 8975 timeout=t) 8976 except Exception as e: 8977 if self.parent.shouldRetry(tries, e, deadline): 8978 tries += 1 8979 time.sleep( 8980 self.parent.exponentialBackoff(tries, deadline)) 8981 continue 8982 raise plumbing.convert_error_to_porcelain(e) from e 8983 tries = 0 8984 for plumbing_item in plumbing_response.history: 8985 yield plumbing.convert_workflow_history_to_porcelain( 8986 plumbing_item) 8987 if plumbing_response.meta.next_cursor == '': 8988 break 8989 req.meta.cursor = plumbing_response.meta.next_cursor 8990 8991 return generator(self, req)
def
deprecated(func)
193def deprecated(func): 194 """This is a decorator which can be used to mark functions 195 as deprecated. It will result in a warning being emitted 196 when the function is used.""" 197 @functools.wraps(func) 198 def new_func(*args, **kwargs): 199 warnings.warn("Call to deprecated function {}.".format(func.__name__), 200 category=DeprecationWarning, 201 stacklevel=2) 202 return func(*args, **kwargs) 203 204 return new_func
This is a decorator which can be used to mark functions as deprecated. It will result in a warning being emitted when the function is used.
class
AccessRequests:
207class AccessRequests: 208 ''' 209 AccessRequests are requests for access to a resource that may match a Workflow. 210 See `strongdm.models.AccessRequest`. 211 ''' 212 def __init__(self, channel, client): 213 self.parent = client 214 self.stub = AccessRequestsStub(channel) 215 216 def list(self, filter, *args, timeout=None): 217 ''' 218 Lists existing access requests. 219 ''' 220 deadline = None if timeout is None else time.time() + timeout 221 req = AccessRequestListRequest() 222 req.meta.CopyFrom(ListRequestMetadata()) 223 if self.parent.page_limit > 0: 224 req.meta.limit = self.parent.page_limit 225 if self.parent.snapshot_datetime is not None: 226 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 227 228 req.filter = plumbing.quote_filter_args(filter, *args) 229 230 def generator(svc, req): 231 tries = 0 232 while True: 233 t = None if deadline is None else deadline - time.time() 234 try: 235 plumbing_response = svc.stub.List( 236 req, 237 metadata=svc.parent.get_metadata( 238 'AccessRequests.List', req), 239 timeout=t) 240 except Exception as e: 241 if self.parent.shouldRetry(tries, e, deadline): 242 tries += 1 243 time.sleep( 244 self.parent.exponentialBackoff(tries, deadline)) 245 continue 246 raise plumbing.convert_error_to_porcelain(e) from e 247 tries = 0 248 for plumbing_item in plumbing_response.access_requests: 249 yield plumbing.convert_access_request_to_porcelain( 250 plumbing_item) 251 if plumbing_response.meta.next_cursor == '': 252 break 253 req.meta.cursor = plumbing_response.meta.next_cursor 254 255 return generator(self, req)
AccessRequests are requests for access to a resource that may match a Workflow.
See strongdm.models.AccessRequest.
def
list(self, filter, *args, timeout=None)
216 def list(self, filter, *args, timeout=None): 217 ''' 218 Lists existing access requests. 219 ''' 220 deadline = None if timeout is None else time.time() + timeout 221 req = AccessRequestListRequest() 222 req.meta.CopyFrom(ListRequestMetadata()) 223 if self.parent.page_limit > 0: 224 req.meta.limit = self.parent.page_limit 225 if self.parent.snapshot_datetime is not None: 226 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 227 228 req.filter = plumbing.quote_filter_args(filter, *args) 229 230 def generator(svc, req): 231 tries = 0 232 while True: 233 t = None if deadline is None else deadline - time.time() 234 try: 235 plumbing_response = svc.stub.List( 236 req, 237 metadata=svc.parent.get_metadata( 238 'AccessRequests.List', req), 239 timeout=t) 240 except Exception as e: 241 if self.parent.shouldRetry(tries, e, deadline): 242 tries += 1 243 time.sleep( 244 self.parent.exponentialBackoff(tries, deadline)) 245 continue 246 raise plumbing.convert_error_to_porcelain(e) from e 247 tries = 0 248 for plumbing_item in plumbing_response.access_requests: 249 yield plumbing.convert_access_request_to_porcelain( 250 plumbing_item) 251 if plumbing_response.meta.next_cursor == '': 252 break 253 req.meta.cursor = plumbing_response.meta.next_cursor 254 255 return generator(self, req)
Lists existing access requests.
class
SnapshotAccessRequests:
258class SnapshotAccessRequests: 259 ''' 260 SnapshotAccessRequests exposes the read only methods of the AccessRequests 261 service for historical queries. 262 ''' 263 def __init__(self, access_requests): 264 self.access_requests = access_requests 265 266 def list(self, filter, *args, timeout=None): 267 ''' 268 Lists existing access requests. 269 ''' 270 return self.access_requests.list(filter, *args, timeout=timeout)
SnapshotAccessRequests exposes the read only methods of the AccessRequests service for historical queries.
class
AccessRequestEventsHistory:
273class AccessRequestEventsHistory: 274 ''' 275 AccessRequestEventsHistory provides records of all changes to the state of an AccessRequest. 276 See `strongdm.models.AccessRequestEventHistory`. 277 ''' 278 def __init__(self, channel, client): 279 self.parent = client 280 self.stub = AccessRequestEventsHistoryStub(channel) 281 282 def list(self, filter, *args, timeout=None): 283 ''' 284 List gets a list of AccessRequestEventHistory records matching a given set of criteria. 285 ''' 286 deadline = None if timeout is None else time.time() + timeout 287 req = AccessRequestEventHistoryListRequest() 288 req.meta.CopyFrom(ListRequestMetadata()) 289 if self.parent.page_limit > 0: 290 req.meta.limit = self.parent.page_limit 291 if self.parent.snapshot_datetime is not None: 292 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 293 294 req.filter = plumbing.quote_filter_args(filter, *args) 295 296 def generator(svc, req): 297 tries = 0 298 while True: 299 t = None if deadline is None else deadline - time.time() 300 try: 301 plumbing_response = svc.stub.List( 302 req, 303 metadata=svc.parent.get_metadata( 304 'AccessRequestEventsHistory.List', req), 305 timeout=t) 306 except Exception as e: 307 if self.parent.shouldRetry(tries, e, deadline): 308 tries += 1 309 time.sleep( 310 self.parent.exponentialBackoff(tries, deadline)) 311 continue 312 raise plumbing.convert_error_to_porcelain(e) from e 313 tries = 0 314 for plumbing_item in plumbing_response.history: 315 yield plumbing.convert_access_request_event_history_to_porcelain( 316 plumbing_item) 317 if plumbing_response.meta.next_cursor == '': 318 break 319 req.meta.cursor = plumbing_response.meta.next_cursor 320 321 return generator(self, req)
AccessRequestEventsHistory provides records of all changes to the state of an AccessRequest.
See strongdm.models.AccessRequestEventHistory.
def
list(self, filter, *args, timeout=None)
282 def list(self, filter, *args, timeout=None): 283 ''' 284 List gets a list of AccessRequestEventHistory records matching a given set of criteria. 285 ''' 286 deadline = None if timeout is None else time.time() + timeout 287 req = AccessRequestEventHistoryListRequest() 288 req.meta.CopyFrom(ListRequestMetadata()) 289 if self.parent.page_limit > 0: 290 req.meta.limit = self.parent.page_limit 291 if self.parent.snapshot_datetime is not None: 292 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 293 294 req.filter = plumbing.quote_filter_args(filter, *args) 295 296 def generator(svc, req): 297 tries = 0 298 while True: 299 t = None if deadline is None else deadline - time.time() 300 try: 301 plumbing_response = svc.stub.List( 302 req, 303 metadata=svc.parent.get_metadata( 304 'AccessRequestEventsHistory.List', req), 305 timeout=t) 306 except Exception as e: 307 if self.parent.shouldRetry(tries, e, deadline): 308 tries += 1 309 time.sleep( 310 self.parent.exponentialBackoff(tries, deadline)) 311 continue 312 raise plumbing.convert_error_to_porcelain(e) from e 313 tries = 0 314 for plumbing_item in plumbing_response.history: 315 yield plumbing.convert_access_request_event_history_to_porcelain( 316 plumbing_item) 317 if plumbing_response.meta.next_cursor == '': 318 break 319 req.meta.cursor = plumbing_response.meta.next_cursor 320 321 return generator(self, req)
List gets a list of AccessRequestEventHistory records matching a given set of criteria.
class
AccessRequestsHistory:
324class AccessRequestsHistory: 325 ''' 326 AccessRequestsHistory provides records of all changes to the state of an AccessRequest. 327 See `strongdm.models.AccessRequestHistory`. 328 ''' 329 def __init__(self, channel, client): 330 self.parent = client 331 self.stub = AccessRequestsHistoryStub(channel) 332 333 def list(self, filter, *args, timeout=None): 334 ''' 335 List gets a list of AccessRequestHistory records matching a given set of criteria. 336 ''' 337 deadline = None if timeout is None else time.time() + timeout 338 req = AccessRequestHistoryListRequest() 339 req.meta.CopyFrom(ListRequestMetadata()) 340 if self.parent.page_limit > 0: 341 req.meta.limit = self.parent.page_limit 342 if self.parent.snapshot_datetime is not None: 343 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 344 345 req.filter = plumbing.quote_filter_args(filter, *args) 346 347 def generator(svc, req): 348 tries = 0 349 while True: 350 t = None if deadline is None else deadline - time.time() 351 try: 352 plumbing_response = svc.stub.List( 353 req, 354 metadata=svc.parent.get_metadata( 355 'AccessRequestsHistory.List', req), 356 timeout=t) 357 except Exception as e: 358 if self.parent.shouldRetry(tries, e, deadline): 359 tries += 1 360 time.sleep( 361 self.parent.exponentialBackoff(tries, deadline)) 362 continue 363 raise plumbing.convert_error_to_porcelain(e) from e 364 tries = 0 365 for plumbing_item in plumbing_response.history: 366 yield plumbing.convert_access_request_history_to_porcelain( 367 plumbing_item) 368 if plumbing_response.meta.next_cursor == '': 369 break 370 req.meta.cursor = plumbing_response.meta.next_cursor 371 372 return generator(self, req)
AccessRequestsHistory provides records of all changes to the state of an AccessRequest.
See strongdm.models.AccessRequestHistory.
def
list(self, filter, *args, timeout=None)
333 def list(self, filter, *args, timeout=None): 334 ''' 335 List gets a list of AccessRequestHistory records matching a given set of criteria. 336 ''' 337 deadline = None if timeout is None else time.time() + timeout 338 req = AccessRequestHistoryListRequest() 339 req.meta.CopyFrom(ListRequestMetadata()) 340 if self.parent.page_limit > 0: 341 req.meta.limit = self.parent.page_limit 342 if self.parent.snapshot_datetime is not None: 343 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 344 345 req.filter = plumbing.quote_filter_args(filter, *args) 346 347 def generator(svc, req): 348 tries = 0 349 while True: 350 t = None if deadline is None else deadline - time.time() 351 try: 352 plumbing_response = svc.stub.List( 353 req, 354 metadata=svc.parent.get_metadata( 355 'AccessRequestsHistory.List', req), 356 timeout=t) 357 except Exception as e: 358 if self.parent.shouldRetry(tries, e, deadline): 359 tries += 1 360 time.sleep( 361 self.parent.exponentialBackoff(tries, deadline)) 362 continue 363 raise plumbing.convert_error_to_porcelain(e) from e 364 tries = 0 365 for plumbing_item in plumbing_response.history: 366 yield plumbing.convert_access_request_history_to_porcelain( 367 plumbing_item) 368 if plumbing_response.meta.next_cursor == '': 369 break 370 req.meta.cursor = plumbing_response.meta.next_cursor 371 372 return generator(self, req)
List gets a list of AccessRequestHistory records matching a given set of criteria.
class
AccountAttachments:
375class AccountAttachments: 376 ''' 377 AccountAttachments assign an account to a role. 378 See `strongdm.models.AccountAttachment`. 379 ''' 380 def __init__(self, channel, client): 381 self.parent = client 382 self.stub = AccountAttachmentsStub(channel) 383 384 def create(self, account_attachment, timeout=None): 385 ''' 386 Create registers a new AccountAttachment. 387 ''' 388 deadline = None if timeout is None else time.time() + timeout 389 req = AccountAttachmentCreateRequest() 390 391 if account_attachment is not None: 392 req.account_attachment.CopyFrom( 393 plumbing.convert_account_attachment_to_plumbing( 394 account_attachment)) 395 tries = 0 396 plumbing_response = None 397 while True: 398 t = None if deadline is None else deadline - time.time() 399 try: 400 plumbing_response = self.stub.Create( 401 req, 402 metadata=self.parent.get_metadata( 403 'AccountAttachments.Create', req), 404 timeout=t) 405 except Exception as e: 406 if self.parent.shouldRetry(tries, e, deadline): 407 tries += 1 408 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 409 continue 410 raise plumbing.convert_error_to_porcelain(e) from e 411 break 412 413 resp = models.AccountAttachmentCreateResponse() 414 resp.account_attachment = plumbing.convert_account_attachment_to_porcelain( 415 plumbing_response.account_attachment) 416 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 417 plumbing_response.meta) 418 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 419 plumbing_response.rate_limit) 420 return resp 421 422 def get(self, id, timeout=None): 423 ''' 424 Get reads one AccountAttachment by ID. 425 ''' 426 deadline = None if timeout is None else time.time() + timeout 427 req = AccountAttachmentGetRequest() 428 if self.parent.snapshot_datetime is not None: 429 req.meta.CopyFrom(GetRequestMetadata()) 430 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 431 432 req.id = (id) 433 tries = 0 434 plumbing_response = None 435 while True: 436 t = None if deadline is None else deadline - time.time() 437 try: 438 plumbing_response = self.stub.Get( 439 req, 440 metadata=self.parent.get_metadata('AccountAttachments.Get', 441 req), 442 timeout=t) 443 except Exception as e: 444 if self.parent.shouldRetry(tries, e, deadline): 445 tries += 1 446 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 447 continue 448 raise plumbing.convert_error_to_porcelain(e) from e 449 break 450 451 resp = models.AccountAttachmentGetResponse() 452 resp.account_attachment = plumbing.convert_account_attachment_to_porcelain( 453 plumbing_response.account_attachment) 454 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 455 plumbing_response.meta) 456 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 457 plumbing_response.rate_limit) 458 return resp 459 460 def delete(self, id, timeout=None): 461 ''' 462 Delete removes a AccountAttachment by ID. 463 ''' 464 deadline = None if timeout is None else time.time() + timeout 465 req = AccountAttachmentDeleteRequest() 466 467 req.id = (id) 468 tries = 0 469 plumbing_response = None 470 while True: 471 t = None if deadline is None else deadline - time.time() 472 try: 473 plumbing_response = self.stub.Delete( 474 req, 475 metadata=self.parent.get_metadata( 476 'AccountAttachments.Delete', req), 477 timeout=t) 478 except Exception as e: 479 if self.parent.shouldRetry(tries, e, deadline): 480 tries += 1 481 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 482 continue 483 raise plumbing.convert_error_to_porcelain(e) from e 484 break 485 486 resp = models.AccountAttachmentDeleteResponse() 487 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 488 plumbing_response.meta) 489 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 490 plumbing_response.rate_limit) 491 return resp 492 493 def list(self, filter, *args, timeout=None): 494 ''' 495 List gets a list of AccountAttachments matching a given set of criteria. 496 ''' 497 deadline = None if timeout is None else time.time() + timeout 498 req = AccountAttachmentListRequest() 499 req.meta.CopyFrom(ListRequestMetadata()) 500 if self.parent.page_limit > 0: 501 req.meta.limit = self.parent.page_limit 502 if self.parent.snapshot_datetime is not None: 503 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 504 505 req.filter = plumbing.quote_filter_args(filter, *args) 506 507 def generator(svc, req): 508 tries = 0 509 while True: 510 t = None if deadline is None else deadline - time.time() 511 try: 512 plumbing_response = svc.stub.List( 513 req, 514 metadata=svc.parent.get_metadata( 515 'AccountAttachments.List', req), 516 timeout=t) 517 except Exception as e: 518 if self.parent.shouldRetry(tries, e, deadline): 519 tries += 1 520 time.sleep( 521 self.parent.exponentialBackoff(tries, deadline)) 522 continue 523 raise plumbing.convert_error_to_porcelain(e) from e 524 tries = 0 525 for plumbing_item in plumbing_response.account_attachments: 526 yield plumbing.convert_account_attachment_to_porcelain( 527 plumbing_item) 528 if plumbing_response.meta.next_cursor == '': 529 break 530 req.meta.cursor = plumbing_response.meta.next_cursor 531 532 return generator(self, req)
AccountAttachments assign an account to a role.
See strongdm.models.AccountAttachment.
def
create(self, account_attachment, timeout=None)
384 def create(self, account_attachment, timeout=None): 385 ''' 386 Create registers a new AccountAttachment. 387 ''' 388 deadline = None if timeout is None else time.time() + timeout 389 req = AccountAttachmentCreateRequest() 390 391 if account_attachment is not None: 392 req.account_attachment.CopyFrom( 393 plumbing.convert_account_attachment_to_plumbing( 394 account_attachment)) 395 tries = 0 396 plumbing_response = None 397 while True: 398 t = None if deadline is None else deadline - time.time() 399 try: 400 plumbing_response = self.stub.Create( 401 req, 402 metadata=self.parent.get_metadata( 403 'AccountAttachments.Create', req), 404 timeout=t) 405 except Exception as e: 406 if self.parent.shouldRetry(tries, e, deadline): 407 tries += 1 408 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 409 continue 410 raise plumbing.convert_error_to_porcelain(e) from e 411 break 412 413 resp = models.AccountAttachmentCreateResponse() 414 resp.account_attachment = plumbing.convert_account_attachment_to_porcelain( 415 plumbing_response.account_attachment) 416 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 417 plumbing_response.meta) 418 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 419 plumbing_response.rate_limit) 420 return resp
Create registers a new AccountAttachment.
def
get(self, id, timeout=None)
422 def get(self, id, timeout=None): 423 ''' 424 Get reads one AccountAttachment by ID. 425 ''' 426 deadline = None if timeout is None else time.time() + timeout 427 req = AccountAttachmentGetRequest() 428 if self.parent.snapshot_datetime is not None: 429 req.meta.CopyFrom(GetRequestMetadata()) 430 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 431 432 req.id = (id) 433 tries = 0 434 plumbing_response = None 435 while True: 436 t = None if deadline is None else deadline - time.time() 437 try: 438 plumbing_response = self.stub.Get( 439 req, 440 metadata=self.parent.get_metadata('AccountAttachments.Get', 441 req), 442 timeout=t) 443 except Exception as e: 444 if self.parent.shouldRetry(tries, e, deadline): 445 tries += 1 446 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 447 continue 448 raise plumbing.convert_error_to_porcelain(e) from e 449 break 450 451 resp = models.AccountAttachmentGetResponse() 452 resp.account_attachment = plumbing.convert_account_attachment_to_porcelain( 453 plumbing_response.account_attachment) 454 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 455 plumbing_response.meta) 456 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 457 plumbing_response.rate_limit) 458 return resp
Get reads one AccountAttachment by ID.
def
delete(self, id, timeout=None)
460 def delete(self, id, timeout=None): 461 ''' 462 Delete removes a AccountAttachment by ID. 463 ''' 464 deadline = None if timeout is None else time.time() + timeout 465 req = AccountAttachmentDeleteRequest() 466 467 req.id = (id) 468 tries = 0 469 plumbing_response = None 470 while True: 471 t = None if deadline is None else deadline - time.time() 472 try: 473 plumbing_response = self.stub.Delete( 474 req, 475 metadata=self.parent.get_metadata( 476 'AccountAttachments.Delete', req), 477 timeout=t) 478 except Exception as e: 479 if self.parent.shouldRetry(tries, e, deadline): 480 tries += 1 481 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 482 continue 483 raise plumbing.convert_error_to_porcelain(e) from e 484 break 485 486 resp = models.AccountAttachmentDeleteResponse() 487 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 488 plumbing_response.meta) 489 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 490 plumbing_response.rate_limit) 491 return resp
Delete removes a AccountAttachment by ID.
def
list(self, filter, *args, timeout=None)
493 def list(self, filter, *args, timeout=None): 494 ''' 495 List gets a list of AccountAttachments matching a given set of criteria. 496 ''' 497 deadline = None if timeout is None else time.time() + timeout 498 req = AccountAttachmentListRequest() 499 req.meta.CopyFrom(ListRequestMetadata()) 500 if self.parent.page_limit > 0: 501 req.meta.limit = self.parent.page_limit 502 if self.parent.snapshot_datetime is not None: 503 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 504 505 req.filter = plumbing.quote_filter_args(filter, *args) 506 507 def generator(svc, req): 508 tries = 0 509 while True: 510 t = None if deadline is None else deadline - time.time() 511 try: 512 plumbing_response = svc.stub.List( 513 req, 514 metadata=svc.parent.get_metadata( 515 'AccountAttachments.List', req), 516 timeout=t) 517 except Exception as e: 518 if self.parent.shouldRetry(tries, e, deadline): 519 tries += 1 520 time.sleep( 521 self.parent.exponentialBackoff(tries, deadline)) 522 continue 523 raise plumbing.convert_error_to_porcelain(e) from e 524 tries = 0 525 for plumbing_item in plumbing_response.account_attachments: 526 yield plumbing.convert_account_attachment_to_porcelain( 527 plumbing_item) 528 if plumbing_response.meta.next_cursor == '': 529 break 530 req.meta.cursor = plumbing_response.meta.next_cursor 531 532 return generator(self, req)
List gets a list of AccountAttachments matching a given set of criteria.
class
SnapshotAccountAttachments:
535class SnapshotAccountAttachments: 536 ''' 537 SnapshotAccountAttachments exposes the read only methods of the AccountAttachments 538 service for historical queries. 539 ''' 540 def __init__(self, account_attachments): 541 self.account_attachments = account_attachments 542 543 def get(self, id, timeout=None): 544 ''' 545 Get reads one AccountAttachment by ID. 546 ''' 547 return self.account_attachments.get(id, timeout=timeout) 548 549 def list(self, filter, *args, timeout=None): 550 ''' 551 List gets a list of AccountAttachments matching a given set of criteria. 552 ''' 553 return self.account_attachments.list(filter, *args, timeout=timeout)
SnapshotAccountAttachments exposes the read only methods of the AccountAttachments service for historical queries.
def
get(self, id, timeout=None)
543 def get(self, id, timeout=None): 544 ''' 545 Get reads one AccountAttachment by ID. 546 ''' 547 return self.account_attachments.get(id, timeout=timeout)
Get reads one AccountAttachment by ID.
def
list(self, filter, *args, timeout=None)
549 def list(self, filter, *args, timeout=None): 550 ''' 551 List gets a list of AccountAttachments matching a given set of criteria. 552 ''' 553 return self.account_attachments.list(filter, *args, timeout=timeout)
List gets a list of AccountAttachments matching a given set of criteria.
class
AccountAttachmentsHistory:
556class AccountAttachmentsHistory: 557 ''' 558 AccountAttachmentsHistory records all changes to the state of an AccountAttachment. 559 See `strongdm.models.AccountAttachmentHistory`. 560 ''' 561 def __init__(self, channel, client): 562 self.parent = client 563 self.stub = AccountAttachmentsHistoryStub(channel) 564 565 def list(self, filter, *args, timeout=None): 566 ''' 567 List gets a list of AccountAttachmentHistory records matching a given set of criteria. 568 ''' 569 deadline = None if timeout is None else time.time() + timeout 570 req = AccountAttachmentHistoryListRequest() 571 req.meta.CopyFrom(ListRequestMetadata()) 572 if self.parent.page_limit > 0: 573 req.meta.limit = self.parent.page_limit 574 if self.parent.snapshot_datetime is not None: 575 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 576 577 req.filter = plumbing.quote_filter_args(filter, *args) 578 579 def generator(svc, req): 580 tries = 0 581 while True: 582 t = None if deadline is None else deadline - time.time() 583 try: 584 plumbing_response = svc.stub.List( 585 req, 586 metadata=svc.parent.get_metadata( 587 'AccountAttachmentsHistory.List', req), 588 timeout=t) 589 except Exception as e: 590 if self.parent.shouldRetry(tries, e, deadline): 591 tries += 1 592 time.sleep( 593 self.parent.exponentialBackoff(tries, deadline)) 594 continue 595 raise plumbing.convert_error_to_porcelain(e) from e 596 tries = 0 597 for plumbing_item in plumbing_response.history: 598 yield plumbing.convert_account_attachment_history_to_porcelain( 599 plumbing_item) 600 if plumbing_response.meta.next_cursor == '': 601 break 602 req.meta.cursor = plumbing_response.meta.next_cursor 603 604 return generator(self, req)
AccountAttachmentsHistory records all changes to the state of an AccountAttachment.
See strongdm.models.AccountAttachmentHistory.
def
list(self, filter, *args, timeout=None)
565 def list(self, filter, *args, timeout=None): 566 ''' 567 List gets a list of AccountAttachmentHistory records matching a given set of criteria. 568 ''' 569 deadline = None if timeout is None else time.time() + timeout 570 req = AccountAttachmentHistoryListRequest() 571 req.meta.CopyFrom(ListRequestMetadata()) 572 if self.parent.page_limit > 0: 573 req.meta.limit = self.parent.page_limit 574 if self.parent.snapshot_datetime is not None: 575 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 576 577 req.filter = plumbing.quote_filter_args(filter, *args) 578 579 def generator(svc, req): 580 tries = 0 581 while True: 582 t = None if deadline is None else deadline - time.time() 583 try: 584 plumbing_response = svc.stub.List( 585 req, 586 metadata=svc.parent.get_metadata( 587 'AccountAttachmentsHistory.List', req), 588 timeout=t) 589 except Exception as e: 590 if self.parent.shouldRetry(tries, e, deadline): 591 tries += 1 592 time.sleep( 593 self.parent.exponentialBackoff(tries, deadline)) 594 continue 595 raise plumbing.convert_error_to_porcelain(e) from e 596 tries = 0 597 for plumbing_item in plumbing_response.history: 598 yield plumbing.convert_account_attachment_history_to_porcelain( 599 plumbing_item) 600 if plumbing_response.meta.next_cursor == '': 601 break 602 req.meta.cursor = plumbing_response.meta.next_cursor 603 604 return generator(self, req)
List gets a list of AccountAttachmentHistory records matching a given set of criteria.
class
AccountGrants:
607class AccountGrants: 608 ''' 609 AccountGrants assign a resource directly to an account, giving the account the permission to connect to that resource. 610 See `strongdm.models.AccountGrant`. 611 ''' 612 def __init__(self, channel, client): 613 self.parent = client 614 self.stub = AccountGrantsStub(channel) 615 616 def create(self, account_grant, timeout=None): 617 ''' 618 Create registers a new AccountGrant. 619 ''' 620 deadline = None if timeout is None else time.time() + timeout 621 req = AccountGrantCreateRequest() 622 623 if account_grant is not None: 624 req.account_grant.CopyFrom( 625 plumbing.convert_account_grant_to_plumbing(account_grant)) 626 tries = 0 627 plumbing_response = None 628 while True: 629 t = None if deadline is None else deadline - time.time() 630 try: 631 plumbing_response = self.stub.Create( 632 req, 633 metadata=self.parent.get_metadata('AccountGrants.Create', 634 req), 635 timeout=t) 636 except Exception as e: 637 if self.parent.shouldRetry(tries, e, deadline): 638 tries += 1 639 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 640 continue 641 raise plumbing.convert_error_to_porcelain(e) from e 642 break 643 644 resp = models.AccountGrantCreateResponse() 645 resp.account_grant = plumbing.convert_account_grant_to_porcelain( 646 plumbing_response.account_grant) 647 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 648 plumbing_response.meta) 649 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 650 plumbing_response.rate_limit) 651 return resp 652 653 def get(self, id, timeout=None): 654 ''' 655 Get reads one AccountGrant by ID. 656 ''' 657 deadline = None if timeout is None else time.time() + timeout 658 req = AccountGrantGetRequest() 659 if self.parent.snapshot_datetime is not None: 660 req.meta.CopyFrom(GetRequestMetadata()) 661 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 662 663 req.id = (id) 664 tries = 0 665 plumbing_response = None 666 while True: 667 t = None if deadline is None else deadline - time.time() 668 try: 669 plumbing_response = self.stub.Get( 670 req, 671 metadata=self.parent.get_metadata('AccountGrants.Get', 672 req), 673 timeout=t) 674 except Exception as e: 675 if self.parent.shouldRetry(tries, e, deadline): 676 tries += 1 677 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 678 continue 679 raise plumbing.convert_error_to_porcelain(e) from e 680 break 681 682 resp = models.AccountGrantGetResponse() 683 resp.account_grant = plumbing.convert_account_grant_to_porcelain( 684 plumbing_response.account_grant) 685 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 686 plumbing_response.meta) 687 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 688 plumbing_response.rate_limit) 689 return resp 690 691 def delete(self, id, timeout=None): 692 ''' 693 Delete removes a AccountGrant by ID. 694 ''' 695 deadline = None if timeout is None else time.time() + timeout 696 req = AccountGrantDeleteRequest() 697 698 req.id = (id) 699 tries = 0 700 plumbing_response = None 701 while True: 702 t = None if deadline is None else deadline - time.time() 703 try: 704 plumbing_response = self.stub.Delete( 705 req, 706 metadata=self.parent.get_metadata('AccountGrants.Delete', 707 req), 708 timeout=t) 709 except Exception as e: 710 if self.parent.shouldRetry(tries, e, deadline): 711 tries += 1 712 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 713 continue 714 raise plumbing.convert_error_to_porcelain(e) from e 715 break 716 717 resp = models.AccountGrantDeleteResponse() 718 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 719 plumbing_response.meta) 720 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 721 plumbing_response.rate_limit) 722 return resp 723 724 def list(self, filter, *args, timeout=None): 725 ''' 726 List gets a list of AccountGrants matching a given set of criteria. 727 ''' 728 deadline = None if timeout is None else time.time() + timeout 729 req = AccountGrantListRequest() 730 req.meta.CopyFrom(ListRequestMetadata()) 731 if self.parent.page_limit > 0: 732 req.meta.limit = self.parent.page_limit 733 if self.parent.snapshot_datetime is not None: 734 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 735 736 req.filter = plumbing.quote_filter_args(filter, *args) 737 738 def generator(svc, req): 739 tries = 0 740 while True: 741 t = None if deadline is None else deadline - time.time() 742 try: 743 plumbing_response = svc.stub.List( 744 req, 745 metadata=svc.parent.get_metadata( 746 'AccountGrants.List', req), 747 timeout=t) 748 except Exception as e: 749 if self.parent.shouldRetry(tries, e, deadline): 750 tries += 1 751 time.sleep( 752 self.parent.exponentialBackoff(tries, deadline)) 753 continue 754 raise plumbing.convert_error_to_porcelain(e) from e 755 tries = 0 756 for plumbing_item in plumbing_response.account_grants: 757 yield plumbing.convert_account_grant_to_porcelain( 758 plumbing_item) 759 if plumbing_response.meta.next_cursor == '': 760 break 761 req.meta.cursor = plumbing_response.meta.next_cursor 762 763 return generator(self, req)
AccountGrants assign a resource directly to an account, giving the account the permission to connect to that resource.
See strongdm.models.AccountGrant.
def
create(self, account_grant, timeout=None)
616 def create(self, account_grant, timeout=None): 617 ''' 618 Create registers a new AccountGrant. 619 ''' 620 deadline = None if timeout is None else time.time() + timeout 621 req = AccountGrantCreateRequest() 622 623 if account_grant is not None: 624 req.account_grant.CopyFrom( 625 plumbing.convert_account_grant_to_plumbing(account_grant)) 626 tries = 0 627 plumbing_response = None 628 while True: 629 t = None if deadline is None else deadline - time.time() 630 try: 631 plumbing_response = self.stub.Create( 632 req, 633 metadata=self.parent.get_metadata('AccountGrants.Create', 634 req), 635 timeout=t) 636 except Exception as e: 637 if self.parent.shouldRetry(tries, e, deadline): 638 tries += 1 639 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 640 continue 641 raise plumbing.convert_error_to_porcelain(e) from e 642 break 643 644 resp = models.AccountGrantCreateResponse() 645 resp.account_grant = plumbing.convert_account_grant_to_porcelain( 646 plumbing_response.account_grant) 647 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 648 plumbing_response.meta) 649 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 650 plumbing_response.rate_limit) 651 return resp
Create registers a new AccountGrant.
def
get(self, id, timeout=None)
653 def get(self, id, timeout=None): 654 ''' 655 Get reads one AccountGrant by ID. 656 ''' 657 deadline = None if timeout is None else time.time() + timeout 658 req = AccountGrantGetRequest() 659 if self.parent.snapshot_datetime is not None: 660 req.meta.CopyFrom(GetRequestMetadata()) 661 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 662 663 req.id = (id) 664 tries = 0 665 plumbing_response = None 666 while True: 667 t = None if deadline is None else deadline - time.time() 668 try: 669 plumbing_response = self.stub.Get( 670 req, 671 metadata=self.parent.get_metadata('AccountGrants.Get', 672 req), 673 timeout=t) 674 except Exception as e: 675 if self.parent.shouldRetry(tries, e, deadline): 676 tries += 1 677 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 678 continue 679 raise plumbing.convert_error_to_porcelain(e) from e 680 break 681 682 resp = models.AccountGrantGetResponse() 683 resp.account_grant = plumbing.convert_account_grant_to_porcelain( 684 plumbing_response.account_grant) 685 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 686 plumbing_response.meta) 687 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 688 plumbing_response.rate_limit) 689 return resp
Get reads one AccountGrant by ID.
def
delete(self, id, timeout=None)
691 def delete(self, id, timeout=None): 692 ''' 693 Delete removes a AccountGrant by ID. 694 ''' 695 deadline = None if timeout is None else time.time() + timeout 696 req = AccountGrantDeleteRequest() 697 698 req.id = (id) 699 tries = 0 700 plumbing_response = None 701 while True: 702 t = None if deadline is None else deadline - time.time() 703 try: 704 plumbing_response = self.stub.Delete( 705 req, 706 metadata=self.parent.get_metadata('AccountGrants.Delete', 707 req), 708 timeout=t) 709 except Exception as e: 710 if self.parent.shouldRetry(tries, e, deadline): 711 tries += 1 712 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 713 continue 714 raise plumbing.convert_error_to_porcelain(e) from e 715 break 716 717 resp = models.AccountGrantDeleteResponse() 718 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 719 plumbing_response.meta) 720 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 721 plumbing_response.rate_limit) 722 return resp
Delete removes a AccountGrant by ID.
def
list(self, filter, *args, timeout=None)
724 def list(self, filter, *args, timeout=None): 725 ''' 726 List gets a list of AccountGrants matching a given set of criteria. 727 ''' 728 deadline = None if timeout is None else time.time() + timeout 729 req = AccountGrantListRequest() 730 req.meta.CopyFrom(ListRequestMetadata()) 731 if self.parent.page_limit > 0: 732 req.meta.limit = self.parent.page_limit 733 if self.parent.snapshot_datetime is not None: 734 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 735 736 req.filter = plumbing.quote_filter_args(filter, *args) 737 738 def generator(svc, req): 739 tries = 0 740 while True: 741 t = None if deadline is None else deadline - time.time() 742 try: 743 plumbing_response = svc.stub.List( 744 req, 745 metadata=svc.parent.get_metadata( 746 'AccountGrants.List', req), 747 timeout=t) 748 except Exception as e: 749 if self.parent.shouldRetry(tries, e, deadline): 750 tries += 1 751 time.sleep( 752 self.parent.exponentialBackoff(tries, deadline)) 753 continue 754 raise plumbing.convert_error_to_porcelain(e) from e 755 tries = 0 756 for plumbing_item in plumbing_response.account_grants: 757 yield plumbing.convert_account_grant_to_porcelain( 758 plumbing_item) 759 if plumbing_response.meta.next_cursor == '': 760 break 761 req.meta.cursor = plumbing_response.meta.next_cursor 762 763 return generator(self, req)
List gets a list of AccountGrants matching a given set of criteria.
class
SnapshotAccountGrants:
766class SnapshotAccountGrants: 767 ''' 768 SnapshotAccountGrants exposes the read only methods of the AccountGrants 769 service for historical queries. 770 ''' 771 def __init__(self, account_grants): 772 self.account_grants = account_grants 773 774 def get(self, id, timeout=None): 775 ''' 776 Get reads one AccountGrant by ID. 777 ''' 778 return self.account_grants.get(id, timeout=timeout) 779 780 def list(self, filter, *args, timeout=None): 781 ''' 782 List gets a list of AccountGrants matching a given set of criteria. 783 ''' 784 return self.account_grants.list(filter, *args, timeout=timeout)
SnapshotAccountGrants exposes the read only methods of the AccountGrants service for historical queries.
def
get(self, id, timeout=None)
774 def get(self, id, timeout=None): 775 ''' 776 Get reads one AccountGrant by ID. 777 ''' 778 return self.account_grants.get(id, timeout=timeout)
Get reads one AccountGrant by ID.
def
list(self, filter, *args, timeout=None)
780 def list(self, filter, *args, timeout=None): 781 ''' 782 List gets a list of AccountGrants matching a given set of criteria. 783 ''' 784 return self.account_grants.list(filter, *args, timeout=timeout)
List gets a list of AccountGrants matching a given set of criteria.
class
AccountGrantsHistory:
787class AccountGrantsHistory: 788 ''' 789 AccountGrantsHistory records all changes to the state of an AccountGrant. 790 See `strongdm.models.AccountGrantHistory`. 791 ''' 792 def __init__(self, channel, client): 793 self.parent = client 794 self.stub = AccountGrantsHistoryStub(channel) 795 796 def list(self, filter, *args, timeout=None): 797 ''' 798 List gets a list of AccountGrantHistory records matching a given set of criteria. 799 ''' 800 deadline = None if timeout is None else time.time() + timeout 801 req = AccountGrantHistoryListRequest() 802 req.meta.CopyFrom(ListRequestMetadata()) 803 if self.parent.page_limit > 0: 804 req.meta.limit = self.parent.page_limit 805 if self.parent.snapshot_datetime is not None: 806 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 807 808 req.filter = plumbing.quote_filter_args(filter, *args) 809 810 def generator(svc, req): 811 tries = 0 812 while True: 813 t = None if deadline is None else deadline - time.time() 814 try: 815 plumbing_response = svc.stub.List( 816 req, 817 metadata=svc.parent.get_metadata( 818 'AccountGrantsHistory.List', req), 819 timeout=t) 820 except Exception as e: 821 if self.parent.shouldRetry(tries, e, deadline): 822 tries += 1 823 time.sleep( 824 self.parent.exponentialBackoff(tries, deadline)) 825 continue 826 raise plumbing.convert_error_to_porcelain(e) from e 827 tries = 0 828 for plumbing_item in plumbing_response.history: 829 yield plumbing.convert_account_grant_history_to_porcelain( 830 plumbing_item) 831 if plumbing_response.meta.next_cursor == '': 832 break 833 req.meta.cursor = plumbing_response.meta.next_cursor 834 835 return generator(self, req)
AccountGrantsHistory records all changes to the state of an AccountGrant.
See strongdm.models.AccountGrantHistory.
def
list(self, filter, *args, timeout=None)
796 def list(self, filter, *args, timeout=None): 797 ''' 798 List gets a list of AccountGrantHistory records matching a given set of criteria. 799 ''' 800 deadline = None if timeout is None else time.time() + timeout 801 req = AccountGrantHistoryListRequest() 802 req.meta.CopyFrom(ListRequestMetadata()) 803 if self.parent.page_limit > 0: 804 req.meta.limit = self.parent.page_limit 805 if self.parent.snapshot_datetime is not None: 806 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 807 808 req.filter = plumbing.quote_filter_args(filter, *args) 809 810 def generator(svc, req): 811 tries = 0 812 while True: 813 t = None if deadline is None else deadline - time.time() 814 try: 815 plumbing_response = svc.stub.List( 816 req, 817 metadata=svc.parent.get_metadata( 818 'AccountGrantsHistory.List', req), 819 timeout=t) 820 except Exception as e: 821 if self.parent.shouldRetry(tries, e, deadline): 822 tries += 1 823 time.sleep( 824 self.parent.exponentialBackoff(tries, deadline)) 825 continue 826 raise plumbing.convert_error_to_porcelain(e) from e 827 tries = 0 828 for plumbing_item in plumbing_response.history: 829 yield plumbing.convert_account_grant_history_to_porcelain( 830 plumbing_item) 831 if plumbing_response.meta.next_cursor == '': 832 break 833 req.meta.cursor = plumbing_response.meta.next_cursor 834 835 return generator(self, req)
List gets a list of AccountGrantHistory records matching a given set of criteria.
class
AccountPermissions:
838class AccountPermissions: 839 ''' 840 AccountPermissions records the granular permissions accounts have, allowing them to execute 841 relevant commands via StrongDM's APIs. 842 See `strongdm.models.AccountPermission`. 843 ''' 844 def __init__(self, channel, client): 845 self.parent = client 846 self.stub = AccountPermissionsStub(channel) 847 848 def list(self, filter, *args, timeout=None): 849 ''' 850 List gets a list of Permission records matching a given set of criteria. 851 ''' 852 deadline = None if timeout is None else time.time() + timeout 853 req = AccountPermissionListRequest() 854 req.meta.CopyFrom(ListRequestMetadata()) 855 if self.parent.page_limit > 0: 856 req.meta.limit = self.parent.page_limit 857 if self.parent.snapshot_datetime is not None: 858 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 859 860 req.filter = plumbing.quote_filter_args(filter, *args) 861 862 def generator(svc, req): 863 tries = 0 864 while True: 865 t = None if deadline is None else deadline - time.time() 866 try: 867 plumbing_response = svc.stub.List( 868 req, 869 metadata=svc.parent.get_metadata( 870 'AccountPermissions.List', req), 871 timeout=t) 872 except Exception as e: 873 if self.parent.shouldRetry(tries, e, deadline): 874 tries += 1 875 time.sleep( 876 self.parent.exponentialBackoff(tries, deadline)) 877 continue 878 raise plumbing.convert_error_to_porcelain(e) from e 879 tries = 0 880 for plumbing_item in plumbing_response.permissions: 881 yield plumbing.convert_account_permission_to_porcelain( 882 plumbing_item) 883 if plumbing_response.meta.next_cursor == '': 884 break 885 req.meta.cursor = plumbing_response.meta.next_cursor 886 887 return generator(self, req)
AccountPermissions records the granular permissions accounts have, allowing them to execute
relevant commands via StrongDM's APIs.
See strongdm.models.AccountPermission.
def
list(self, filter, *args, timeout=None)
848 def list(self, filter, *args, timeout=None): 849 ''' 850 List gets a list of Permission records matching a given set of criteria. 851 ''' 852 deadline = None if timeout is None else time.time() + timeout 853 req = AccountPermissionListRequest() 854 req.meta.CopyFrom(ListRequestMetadata()) 855 if self.parent.page_limit > 0: 856 req.meta.limit = self.parent.page_limit 857 if self.parent.snapshot_datetime is not None: 858 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 859 860 req.filter = plumbing.quote_filter_args(filter, *args) 861 862 def generator(svc, req): 863 tries = 0 864 while True: 865 t = None if deadline is None else deadline - time.time() 866 try: 867 plumbing_response = svc.stub.List( 868 req, 869 metadata=svc.parent.get_metadata( 870 'AccountPermissions.List', req), 871 timeout=t) 872 except Exception as e: 873 if self.parent.shouldRetry(tries, e, deadline): 874 tries += 1 875 time.sleep( 876 self.parent.exponentialBackoff(tries, deadline)) 877 continue 878 raise plumbing.convert_error_to_porcelain(e) from e 879 tries = 0 880 for plumbing_item in plumbing_response.permissions: 881 yield plumbing.convert_account_permission_to_porcelain( 882 plumbing_item) 883 if plumbing_response.meta.next_cursor == '': 884 break 885 req.meta.cursor = plumbing_response.meta.next_cursor 886 887 return generator(self, req)
List gets a list of Permission records matching a given set of criteria.
class
SnapshotAccountPermissions:
890class SnapshotAccountPermissions: 891 ''' 892 SnapshotAccountPermissions exposes the read only methods of the AccountPermissions 893 service for historical queries. 894 ''' 895 def __init__(self, account_permissions): 896 self.account_permissions = account_permissions 897 898 def list(self, filter, *args, timeout=None): 899 ''' 900 List gets a list of Permission records matching a given set of criteria. 901 ''' 902 return self.account_permissions.list(filter, *args, timeout=timeout)
SnapshotAccountPermissions exposes the read only methods of the AccountPermissions service for historical queries.
def
list(self, filter, *args, timeout=None)
898 def list(self, filter, *args, timeout=None): 899 ''' 900 List gets a list of Permission records matching a given set of criteria. 901 ''' 902 return self.account_permissions.list(filter, *args, timeout=timeout)
List gets a list of Permission records matching a given set of criteria.
class
AccountResources:
905class AccountResources: 906 ''' 907 AccountResources enumerates the resources to which accounts have access. 908 The AccountResources service is read-only. 909 See `strongdm.models.AccountResource`. 910 ''' 911 def __init__(self, channel, client): 912 self.parent = client 913 self.stub = AccountResourcesStub(channel) 914 915 def list(self, filter, *args, timeout=None): 916 ''' 917 List gets a list of AccountResource records matching a given set of criteria. 918 ''' 919 deadline = None if timeout is None else time.time() + timeout 920 req = AccountResourceListRequest() 921 req.meta.CopyFrom(ListRequestMetadata()) 922 if self.parent.page_limit > 0: 923 req.meta.limit = self.parent.page_limit 924 if self.parent.snapshot_datetime is not None: 925 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 926 927 req.filter = plumbing.quote_filter_args(filter, *args) 928 929 def generator(svc, req): 930 tries = 0 931 while True: 932 t = None if deadline is None else deadline - time.time() 933 try: 934 plumbing_response = svc.stub.List( 935 req, 936 metadata=svc.parent.get_metadata( 937 'AccountResources.List', req), 938 timeout=t) 939 except Exception as e: 940 if self.parent.shouldRetry(tries, e, deadline): 941 tries += 1 942 time.sleep( 943 self.parent.exponentialBackoff(tries, deadline)) 944 continue 945 raise plumbing.convert_error_to_porcelain(e) from e 946 tries = 0 947 for plumbing_item in plumbing_response.account_resources: 948 yield plumbing.convert_account_resource_to_porcelain( 949 plumbing_item) 950 if plumbing_response.meta.next_cursor == '': 951 break 952 req.meta.cursor = plumbing_response.meta.next_cursor 953 954 return generator(self, req)
AccountResources enumerates the resources to which accounts have access.
The AccountResources service is read-only.
See strongdm.models.AccountResource.
def
list(self, filter, *args, timeout=None)
915 def list(self, filter, *args, timeout=None): 916 ''' 917 List gets a list of AccountResource records matching a given set of criteria. 918 ''' 919 deadline = None if timeout is None else time.time() + timeout 920 req = AccountResourceListRequest() 921 req.meta.CopyFrom(ListRequestMetadata()) 922 if self.parent.page_limit > 0: 923 req.meta.limit = self.parent.page_limit 924 if self.parent.snapshot_datetime is not None: 925 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 926 927 req.filter = plumbing.quote_filter_args(filter, *args) 928 929 def generator(svc, req): 930 tries = 0 931 while True: 932 t = None if deadline is None else deadline - time.time() 933 try: 934 plumbing_response = svc.stub.List( 935 req, 936 metadata=svc.parent.get_metadata( 937 'AccountResources.List', req), 938 timeout=t) 939 except Exception as e: 940 if self.parent.shouldRetry(tries, e, deadline): 941 tries += 1 942 time.sleep( 943 self.parent.exponentialBackoff(tries, deadline)) 944 continue 945 raise plumbing.convert_error_to_porcelain(e) from e 946 tries = 0 947 for plumbing_item in plumbing_response.account_resources: 948 yield plumbing.convert_account_resource_to_porcelain( 949 plumbing_item) 950 if plumbing_response.meta.next_cursor == '': 951 break 952 req.meta.cursor = plumbing_response.meta.next_cursor 953 954 return generator(self, req)
List gets a list of AccountResource records matching a given set of criteria.
class
SnapshotAccountResources:
957class SnapshotAccountResources: 958 ''' 959 SnapshotAccountResources exposes the read only methods of the AccountResources 960 service for historical queries. 961 ''' 962 def __init__(self, account_resources): 963 self.account_resources = account_resources 964 965 def list(self, filter, *args, timeout=None): 966 ''' 967 List gets a list of AccountResource records matching a given set of criteria. 968 ''' 969 return self.account_resources.list(filter, *args, timeout=timeout)
SnapshotAccountResources exposes the read only methods of the AccountResources service for historical queries.
def
list(self, filter, *args, timeout=None)
965 def list(self, filter, *args, timeout=None): 966 ''' 967 List gets a list of AccountResource records matching a given set of criteria. 968 ''' 969 return self.account_resources.list(filter, *args, timeout=timeout)
List gets a list of AccountResource records matching a given set of criteria.
class
AccountResourcesHistory:
972class AccountResourcesHistory: 973 ''' 974 AccountResourcesHistory records all changes to the state of a AccountResource. 975 See `strongdm.models.AccountResourceHistory`. 976 ''' 977 def __init__(self, channel, client): 978 self.parent = client 979 self.stub = AccountResourcesHistoryStub(channel) 980 981 def list(self, filter, *args, timeout=None): 982 ''' 983 List gets a list of AccountResourceHistory records matching a given set of criteria. 984 ''' 985 deadline = None if timeout is None else time.time() + timeout 986 req = AccountResourceHistoryListRequest() 987 req.meta.CopyFrom(ListRequestMetadata()) 988 if self.parent.page_limit > 0: 989 req.meta.limit = self.parent.page_limit 990 if self.parent.snapshot_datetime is not None: 991 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 992 993 req.filter = plumbing.quote_filter_args(filter, *args) 994 995 def generator(svc, req): 996 tries = 0 997 while True: 998 t = None if deadline is None else deadline - time.time() 999 try: 1000 plumbing_response = svc.stub.List( 1001 req, 1002 metadata=svc.parent.get_metadata( 1003 'AccountResourcesHistory.List', req), 1004 timeout=t) 1005 except Exception as e: 1006 if self.parent.shouldRetry(tries, e, deadline): 1007 tries += 1 1008 time.sleep( 1009 self.parent.exponentialBackoff(tries, deadline)) 1010 continue 1011 raise plumbing.convert_error_to_porcelain(e) from e 1012 tries = 0 1013 for plumbing_item in plumbing_response.history: 1014 yield plumbing.convert_account_resource_history_to_porcelain( 1015 plumbing_item) 1016 if plumbing_response.meta.next_cursor == '': 1017 break 1018 req.meta.cursor = plumbing_response.meta.next_cursor 1019 1020 return generator(self, req)
AccountResourcesHistory records all changes to the state of a AccountResource.
See strongdm.models.AccountResourceHistory.
def
list(self, filter, *args, timeout=None)
981 def list(self, filter, *args, timeout=None): 982 ''' 983 List gets a list of AccountResourceHistory records matching a given set of criteria. 984 ''' 985 deadline = None if timeout is None else time.time() + timeout 986 req = AccountResourceHistoryListRequest() 987 req.meta.CopyFrom(ListRequestMetadata()) 988 if self.parent.page_limit > 0: 989 req.meta.limit = self.parent.page_limit 990 if self.parent.snapshot_datetime is not None: 991 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 992 993 req.filter = plumbing.quote_filter_args(filter, *args) 994 995 def generator(svc, req): 996 tries = 0 997 while True: 998 t = None if deadline is None else deadline - time.time() 999 try: 1000 plumbing_response = svc.stub.List( 1001 req, 1002 metadata=svc.parent.get_metadata( 1003 'AccountResourcesHistory.List', req), 1004 timeout=t) 1005 except Exception as e: 1006 if self.parent.shouldRetry(tries, e, deadline): 1007 tries += 1 1008 time.sleep( 1009 self.parent.exponentialBackoff(tries, deadline)) 1010 continue 1011 raise plumbing.convert_error_to_porcelain(e) from e 1012 tries = 0 1013 for plumbing_item in plumbing_response.history: 1014 yield plumbing.convert_account_resource_history_to_porcelain( 1015 plumbing_item) 1016 if plumbing_response.meta.next_cursor == '': 1017 break 1018 req.meta.cursor = plumbing_response.meta.next_cursor 1019 1020 return generator(self, req)
List gets a list of AccountResourceHistory records matching a given set of criteria.
class
Accounts:
1023class Accounts: 1024 ''' 1025 Accounts are users that have access to strongDM. There are two types of accounts: 1026 1. **Users:** humans who are authenticated through username and password or SSO. 1027 2. **Service Accounts:** machines that are authenticated using a service token. 1028 3. **Tokens** are access keys with permissions that can be used for authentication. 1029 See: 1030 `strongdm.models.Service` 1031 `strongdm.models.Token` 1032 `strongdm.models.User` 1033 ''' 1034 def __init__(self, channel, client): 1035 self.parent = client 1036 self.stub = AccountsStub(channel) 1037 1038 def create(self, account, timeout=None): 1039 ''' 1040 Create registers a new Account. 1041 ''' 1042 deadline = None if timeout is None else time.time() + timeout 1043 req = AccountCreateRequest() 1044 1045 if account is not None: 1046 req.account.CopyFrom(plumbing.convert_account_to_plumbing(account)) 1047 tries = 0 1048 plumbing_response = None 1049 while True: 1050 t = None if deadline is None else deadline - time.time() 1051 try: 1052 plumbing_response = self.stub.Create( 1053 req, 1054 metadata=self.parent.get_metadata('Accounts.Create', req), 1055 timeout=t) 1056 except Exception as e: 1057 if self.parent.shouldRetry(tries, e, deadline): 1058 tries += 1 1059 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1060 continue 1061 raise plumbing.convert_error_to_porcelain(e) from e 1062 break 1063 1064 resp = models.AccountCreateResponse() 1065 resp.access_key = (plumbing_response.access_key) 1066 resp.account = plumbing.convert_account_to_porcelain( 1067 plumbing_response.account) 1068 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 1069 plumbing_response.meta) 1070 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1071 plumbing_response.rate_limit) 1072 resp.secret_key = (plumbing_response.secret_key) 1073 resp.token = (plumbing_response.token) 1074 return resp 1075 1076 def get(self, id, timeout=None): 1077 ''' 1078 Get reads one Account by ID. 1079 ''' 1080 deadline = None if timeout is None else time.time() + timeout 1081 req = AccountGetRequest() 1082 if self.parent.snapshot_datetime is not None: 1083 req.meta.CopyFrom(GetRequestMetadata()) 1084 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1085 1086 req.id = (id) 1087 tries = 0 1088 plumbing_response = None 1089 while True: 1090 t = None if deadline is None else deadline - time.time() 1091 try: 1092 plumbing_response = self.stub.Get( 1093 req, 1094 metadata=self.parent.get_metadata('Accounts.Get', req), 1095 timeout=t) 1096 except Exception as e: 1097 if self.parent.shouldRetry(tries, e, deadline): 1098 tries += 1 1099 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1100 continue 1101 raise plumbing.convert_error_to_porcelain(e) from e 1102 break 1103 1104 resp = models.AccountGetResponse() 1105 resp.account = plumbing.convert_account_to_porcelain( 1106 plumbing_response.account) 1107 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1108 plumbing_response.meta) 1109 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1110 plumbing_response.rate_limit) 1111 return resp 1112 1113 def update(self, account, timeout=None): 1114 ''' 1115 Update replaces all the fields of an Account by ID. 1116 ''' 1117 deadline = None if timeout is None else time.time() + timeout 1118 req = AccountUpdateRequest() 1119 1120 if account is not None: 1121 req.account.CopyFrom(plumbing.convert_account_to_plumbing(account)) 1122 tries = 0 1123 plumbing_response = None 1124 while True: 1125 t = None if deadline is None else deadline - time.time() 1126 try: 1127 plumbing_response = self.stub.Update( 1128 req, 1129 metadata=self.parent.get_metadata('Accounts.Update', req), 1130 timeout=t) 1131 except Exception as e: 1132 if self.parent.shouldRetry(tries, e, deadline): 1133 tries += 1 1134 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1135 continue 1136 raise plumbing.convert_error_to_porcelain(e) from e 1137 break 1138 1139 resp = models.AccountUpdateResponse() 1140 resp.account = plumbing.convert_account_to_porcelain( 1141 plumbing_response.account) 1142 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 1143 plumbing_response.meta) 1144 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1145 plumbing_response.rate_limit) 1146 return resp 1147 1148 def delete(self, id, timeout=None): 1149 ''' 1150 Delete removes an Account by ID. 1151 ''' 1152 deadline = None if timeout is None else time.time() + timeout 1153 req = AccountDeleteRequest() 1154 1155 req.id = (id) 1156 tries = 0 1157 plumbing_response = None 1158 while True: 1159 t = None if deadline is None else deadline - time.time() 1160 try: 1161 plumbing_response = self.stub.Delete( 1162 req, 1163 metadata=self.parent.get_metadata('Accounts.Delete', req), 1164 timeout=t) 1165 except Exception as e: 1166 if self.parent.shouldRetry(tries, e, deadline): 1167 tries += 1 1168 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1169 continue 1170 raise plumbing.convert_error_to_porcelain(e) from e 1171 break 1172 1173 resp = models.AccountDeleteResponse() 1174 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 1175 plumbing_response.meta) 1176 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1177 plumbing_response.rate_limit) 1178 return resp 1179 1180 def list(self, filter, *args, timeout=None): 1181 ''' 1182 List gets a list of Accounts matching a given set of criteria. 1183 ''' 1184 deadline = None if timeout is None else time.time() + timeout 1185 req = AccountListRequest() 1186 req.meta.CopyFrom(ListRequestMetadata()) 1187 if self.parent.page_limit > 0: 1188 req.meta.limit = self.parent.page_limit 1189 if self.parent.snapshot_datetime is not None: 1190 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1191 1192 req.filter = plumbing.quote_filter_args(filter, *args) 1193 1194 def generator(svc, req): 1195 tries = 0 1196 while True: 1197 t = None if deadline is None else deadline - time.time() 1198 try: 1199 plumbing_response = svc.stub.List( 1200 req, 1201 metadata=svc.parent.get_metadata('Accounts.List', req), 1202 timeout=t) 1203 except Exception as e: 1204 if self.parent.shouldRetry(tries, e, deadline): 1205 tries += 1 1206 time.sleep( 1207 self.parent.exponentialBackoff(tries, deadline)) 1208 continue 1209 raise plumbing.convert_error_to_porcelain(e) from e 1210 tries = 0 1211 for plumbing_item in plumbing_response.accounts: 1212 yield plumbing.convert_account_to_porcelain(plumbing_item) 1213 if plumbing_response.meta.next_cursor == '': 1214 break 1215 req.meta.cursor = plumbing_response.meta.next_cursor 1216 1217 return generator(self, req)
Accounts are users that have access to strongDM. There are two types of accounts:
- Users: humans who are authenticated through username and password or SSO.
- Service Accounts: machines that are authenticated using a service token.
- Tokens are access keys with permissions that can be used for authentication.
See:
strongdm.models.Servicestrongdm.models.Tokenstrongdm.models.User
def
create(self, account, timeout=None)
1038 def create(self, account, timeout=None): 1039 ''' 1040 Create registers a new Account. 1041 ''' 1042 deadline = None if timeout is None else time.time() + timeout 1043 req = AccountCreateRequest() 1044 1045 if account is not None: 1046 req.account.CopyFrom(plumbing.convert_account_to_plumbing(account)) 1047 tries = 0 1048 plumbing_response = None 1049 while True: 1050 t = None if deadline is None else deadline - time.time() 1051 try: 1052 plumbing_response = self.stub.Create( 1053 req, 1054 metadata=self.parent.get_metadata('Accounts.Create', req), 1055 timeout=t) 1056 except Exception as e: 1057 if self.parent.shouldRetry(tries, e, deadline): 1058 tries += 1 1059 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1060 continue 1061 raise plumbing.convert_error_to_porcelain(e) from e 1062 break 1063 1064 resp = models.AccountCreateResponse() 1065 resp.access_key = (plumbing_response.access_key) 1066 resp.account = plumbing.convert_account_to_porcelain( 1067 plumbing_response.account) 1068 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 1069 plumbing_response.meta) 1070 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1071 plumbing_response.rate_limit) 1072 resp.secret_key = (plumbing_response.secret_key) 1073 resp.token = (plumbing_response.token) 1074 return resp
Create registers a new Account.
def
get(self, id, timeout=None)
1076 def get(self, id, timeout=None): 1077 ''' 1078 Get reads one Account by ID. 1079 ''' 1080 deadline = None if timeout is None else time.time() + timeout 1081 req = AccountGetRequest() 1082 if self.parent.snapshot_datetime is not None: 1083 req.meta.CopyFrom(GetRequestMetadata()) 1084 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1085 1086 req.id = (id) 1087 tries = 0 1088 plumbing_response = None 1089 while True: 1090 t = None if deadline is None else deadline - time.time() 1091 try: 1092 plumbing_response = self.stub.Get( 1093 req, 1094 metadata=self.parent.get_metadata('Accounts.Get', req), 1095 timeout=t) 1096 except Exception as e: 1097 if self.parent.shouldRetry(tries, e, deadline): 1098 tries += 1 1099 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1100 continue 1101 raise plumbing.convert_error_to_porcelain(e) from e 1102 break 1103 1104 resp = models.AccountGetResponse() 1105 resp.account = plumbing.convert_account_to_porcelain( 1106 plumbing_response.account) 1107 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1108 plumbing_response.meta) 1109 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1110 plumbing_response.rate_limit) 1111 return resp
Get reads one Account by ID.
def
update(self, account, timeout=None)
1113 def update(self, account, timeout=None): 1114 ''' 1115 Update replaces all the fields of an Account by ID. 1116 ''' 1117 deadline = None if timeout is None else time.time() + timeout 1118 req = AccountUpdateRequest() 1119 1120 if account is not None: 1121 req.account.CopyFrom(plumbing.convert_account_to_plumbing(account)) 1122 tries = 0 1123 plumbing_response = None 1124 while True: 1125 t = None if deadline is None else deadline - time.time() 1126 try: 1127 plumbing_response = self.stub.Update( 1128 req, 1129 metadata=self.parent.get_metadata('Accounts.Update', req), 1130 timeout=t) 1131 except Exception as e: 1132 if self.parent.shouldRetry(tries, e, deadline): 1133 tries += 1 1134 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1135 continue 1136 raise plumbing.convert_error_to_porcelain(e) from e 1137 break 1138 1139 resp = models.AccountUpdateResponse() 1140 resp.account = plumbing.convert_account_to_porcelain( 1141 plumbing_response.account) 1142 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 1143 plumbing_response.meta) 1144 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1145 plumbing_response.rate_limit) 1146 return resp
Update replaces all the fields of an Account by ID.
def
delete(self, id, timeout=None)
1148 def delete(self, id, timeout=None): 1149 ''' 1150 Delete removes an Account by ID. 1151 ''' 1152 deadline = None if timeout is None else time.time() + timeout 1153 req = AccountDeleteRequest() 1154 1155 req.id = (id) 1156 tries = 0 1157 plumbing_response = None 1158 while True: 1159 t = None if deadline is None else deadline - time.time() 1160 try: 1161 plumbing_response = self.stub.Delete( 1162 req, 1163 metadata=self.parent.get_metadata('Accounts.Delete', req), 1164 timeout=t) 1165 except Exception as e: 1166 if self.parent.shouldRetry(tries, e, deadline): 1167 tries += 1 1168 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1169 continue 1170 raise plumbing.convert_error_to_porcelain(e) from e 1171 break 1172 1173 resp = models.AccountDeleteResponse() 1174 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 1175 plumbing_response.meta) 1176 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1177 plumbing_response.rate_limit) 1178 return resp
Delete removes an Account by ID.
def
list(self, filter, *args, timeout=None)
1180 def list(self, filter, *args, timeout=None): 1181 ''' 1182 List gets a list of Accounts matching a given set of criteria. 1183 ''' 1184 deadline = None if timeout is None else time.time() + timeout 1185 req = AccountListRequest() 1186 req.meta.CopyFrom(ListRequestMetadata()) 1187 if self.parent.page_limit > 0: 1188 req.meta.limit = self.parent.page_limit 1189 if self.parent.snapshot_datetime is not None: 1190 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1191 1192 req.filter = plumbing.quote_filter_args(filter, *args) 1193 1194 def generator(svc, req): 1195 tries = 0 1196 while True: 1197 t = None if deadline is None else deadline - time.time() 1198 try: 1199 plumbing_response = svc.stub.List( 1200 req, 1201 metadata=svc.parent.get_metadata('Accounts.List', req), 1202 timeout=t) 1203 except Exception as e: 1204 if self.parent.shouldRetry(tries, e, deadline): 1205 tries += 1 1206 time.sleep( 1207 self.parent.exponentialBackoff(tries, deadline)) 1208 continue 1209 raise plumbing.convert_error_to_porcelain(e) from e 1210 tries = 0 1211 for plumbing_item in plumbing_response.accounts: 1212 yield plumbing.convert_account_to_porcelain(plumbing_item) 1213 if plumbing_response.meta.next_cursor == '': 1214 break 1215 req.meta.cursor = plumbing_response.meta.next_cursor 1216 1217 return generator(self, req)
List gets a list of Accounts matching a given set of criteria.
class
SnapshotAccounts:
1220class SnapshotAccounts: 1221 ''' 1222 SnapshotAccounts exposes the read only methods of the Accounts 1223 service for historical queries. 1224 ''' 1225 def __init__(self, accounts): 1226 self.accounts = accounts 1227 1228 def get(self, id, timeout=None): 1229 ''' 1230 Get reads one Account by ID. 1231 ''' 1232 return self.accounts.get(id, timeout=timeout) 1233 1234 def list(self, filter, *args, timeout=None): 1235 ''' 1236 List gets a list of Accounts matching a given set of criteria. 1237 ''' 1238 return self.accounts.list(filter, *args, timeout=timeout)
SnapshotAccounts exposes the read only methods of the Accounts service for historical queries.
def
get(self, id, timeout=None)
1228 def get(self, id, timeout=None): 1229 ''' 1230 Get reads one Account by ID. 1231 ''' 1232 return self.accounts.get(id, timeout=timeout)
Get reads one Account by ID.
def
list(self, filter, *args, timeout=None)
1234 def list(self, filter, *args, timeout=None): 1235 ''' 1236 List gets a list of Accounts matching a given set of criteria. 1237 ''' 1238 return self.accounts.list(filter, *args, timeout=timeout)
List gets a list of Accounts matching a given set of criteria.
class
AccountsGroups:
1241class AccountsGroups: 1242 ''' 1243 An AccountGroup links an account and a group. 1244 See `strongdm.models.AccountGroup`. 1245 ''' 1246 def __init__(self, channel, client): 1247 self.parent = client 1248 self.stub = AccountsGroupsStub(channel) 1249 1250 def create(self, account_group, timeout=None): 1251 ''' 1252 Create create a new AccountGroup. 1253 ''' 1254 deadline = None if timeout is None else time.time() + timeout 1255 req = AccountGroupCreateRequest() 1256 1257 if account_group is not None: 1258 req.account_group.CopyFrom( 1259 plumbing.convert_account_group_to_plumbing(account_group)) 1260 tries = 0 1261 plumbing_response = None 1262 while True: 1263 t = None if deadline is None else deadline - time.time() 1264 try: 1265 plumbing_response = self.stub.Create( 1266 req, 1267 metadata=self.parent.get_metadata('AccountsGroups.Create', 1268 req), 1269 timeout=t) 1270 except Exception as e: 1271 if self.parent.shouldRetry(tries, e, deadline): 1272 tries += 1 1273 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1274 continue 1275 raise plumbing.convert_error_to_porcelain(e) from e 1276 break 1277 1278 resp = models.AccountGroupCreateResponse() 1279 resp.account_group = plumbing.convert_account_group_to_porcelain( 1280 plumbing_response.account_group) 1281 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1282 plumbing_response.rate_limit) 1283 return resp 1284 1285 def get(self, id, timeout=None): 1286 ''' 1287 Get reads one AccountGroup by ID. 1288 ''' 1289 deadline = None if timeout is None else time.time() + timeout 1290 req = AccountGroupGetRequest() 1291 if self.parent.snapshot_datetime is not None: 1292 req.meta.CopyFrom(GetRequestMetadata()) 1293 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1294 1295 req.id = (id) 1296 tries = 0 1297 plumbing_response = None 1298 while True: 1299 t = None if deadline is None else deadline - time.time() 1300 try: 1301 plumbing_response = self.stub.Get( 1302 req, 1303 metadata=self.parent.get_metadata('AccountsGroups.Get', 1304 req), 1305 timeout=t) 1306 except Exception as e: 1307 if self.parent.shouldRetry(tries, e, deadline): 1308 tries += 1 1309 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1310 continue 1311 raise plumbing.convert_error_to_porcelain(e) from e 1312 break 1313 1314 resp = models.AccountGroupGetResponse() 1315 resp.account_group = plumbing.convert_account_group_to_porcelain( 1316 plumbing_response.account_group) 1317 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1318 plumbing_response.meta) 1319 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1320 plumbing_response.rate_limit) 1321 return resp 1322 1323 def delete(self, id, timeout=None): 1324 ''' 1325 Delete removes an AccountGroup by ID. 1326 ''' 1327 deadline = None if timeout is None else time.time() + timeout 1328 req = AccountGroupDeleteRequest() 1329 1330 req.id = (id) 1331 tries = 0 1332 plumbing_response = None 1333 while True: 1334 t = None if deadline is None else deadline - time.time() 1335 try: 1336 plumbing_response = self.stub.Delete( 1337 req, 1338 metadata=self.parent.get_metadata('AccountsGroups.Delete', 1339 req), 1340 timeout=t) 1341 except Exception as e: 1342 if self.parent.shouldRetry(tries, e, deadline): 1343 tries += 1 1344 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1345 continue 1346 raise plumbing.convert_error_to_porcelain(e) from e 1347 break 1348 1349 resp = models.AccountGroupDeleteResponse() 1350 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 1351 plumbing_response.meta) 1352 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1353 plumbing_response.rate_limit) 1354 return resp 1355 1356 def list(self, filter, *args, timeout=None): 1357 ''' 1358 List gets a list of AccountGroups matching a given set of criteria. 1359 ''' 1360 deadline = None if timeout is None else time.time() + timeout 1361 req = AccountGroupListRequest() 1362 req.meta.CopyFrom(ListRequestMetadata()) 1363 if self.parent.page_limit > 0: 1364 req.meta.limit = self.parent.page_limit 1365 if self.parent.snapshot_datetime is not None: 1366 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1367 1368 req.filter = plumbing.quote_filter_args(filter, *args) 1369 1370 def generator(svc, req): 1371 tries = 0 1372 while True: 1373 t = None if deadline is None else deadline - time.time() 1374 try: 1375 plumbing_response = svc.stub.List( 1376 req, 1377 metadata=svc.parent.get_metadata( 1378 'AccountsGroups.List', req), 1379 timeout=t) 1380 except Exception as e: 1381 if self.parent.shouldRetry(tries, e, deadline): 1382 tries += 1 1383 time.sleep( 1384 self.parent.exponentialBackoff(tries, deadline)) 1385 continue 1386 raise plumbing.convert_error_to_porcelain(e) from e 1387 tries = 0 1388 for plumbing_item in plumbing_response.account_groups: 1389 yield plumbing.convert_account_group_to_porcelain( 1390 plumbing_item) 1391 if plumbing_response.meta.next_cursor == '': 1392 break 1393 req.meta.cursor = plumbing_response.meta.next_cursor 1394 1395 return generator(self, req)
An AccountGroup links an account and a group.
See strongdm.models.AccountGroup.
def
create(self, account_group, timeout=None)
1250 def create(self, account_group, timeout=None): 1251 ''' 1252 Create create a new AccountGroup. 1253 ''' 1254 deadline = None if timeout is None else time.time() + timeout 1255 req = AccountGroupCreateRequest() 1256 1257 if account_group is not None: 1258 req.account_group.CopyFrom( 1259 plumbing.convert_account_group_to_plumbing(account_group)) 1260 tries = 0 1261 plumbing_response = None 1262 while True: 1263 t = None if deadline is None else deadline - time.time() 1264 try: 1265 plumbing_response = self.stub.Create( 1266 req, 1267 metadata=self.parent.get_metadata('AccountsGroups.Create', 1268 req), 1269 timeout=t) 1270 except Exception as e: 1271 if self.parent.shouldRetry(tries, e, deadline): 1272 tries += 1 1273 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1274 continue 1275 raise plumbing.convert_error_to_porcelain(e) from e 1276 break 1277 1278 resp = models.AccountGroupCreateResponse() 1279 resp.account_group = plumbing.convert_account_group_to_porcelain( 1280 plumbing_response.account_group) 1281 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1282 plumbing_response.rate_limit) 1283 return resp
Create create a new AccountGroup.
def
get(self, id, timeout=None)
1285 def get(self, id, timeout=None): 1286 ''' 1287 Get reads one AccountGroup by ID. 1288 ''' 1289 deadline = None if timeout is None else time.time() + timeout 1290 req = AccountGroupGetRequest() 1291 if self.parent.snapshot_datetime is not None: 1292 req.meta.CopyFrom(GetRequestMetadata()) 1293 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1294 1295 req.id = (id) 1296 tries = 0 1297 plumbing_response = None 1298 while True: 1299 t = None if deadline is None else deadline - time.time() 1300 try: 1301 plumbing_response = self.stub.Get( 1302 req, 1303 metadata=self.parent.get_metadata('AccountsGroups.Get', 1304 req), 1305 timeout=t) 1306 except Exception as e: 1307 if self.parent.shouldRetry(tries, e, deadline): 1308 tries += 1 1309 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1310 continue 1311 raise plumbing.convert_error_to_porcelain(e) from e 1312 break 1313 1314 resp = models.AccountGroupGetResponse() 1315 resp.account_group = plumbing.convert_account_group_to_porcelain( 1316 plumbing_response.account_group) 1317 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1318 plumbing_response.meta) 1319 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1320 plumbing_response.rate_limit) 1321 return resp
Get reads one AccountGroup by ID.
def
delete(self, id, timeout=None)
1323 def delete(self, id, timeout=None): 1324 ''' 1325 Delete removes an AccountGroup by ID. 1326 ''' 1327 deadline = None if timeout is None else time.time() + timeout 1328 req = AccountGroupDeleteRequest() 1329 1330 req.id = (id) 1331 tries = 0 1332 plumbing_response = None 1333 while True: 1334 t = None if deadline is None else deadline - time.time() 1335 try: 1336 plumbing_response = self.stub.Delete( 1337 req, 1338 metadata=self.parent.get_metadata('AccountsGroups.Delete', 1339 req), 1340 timeout=t) 1341 except Exception as e: 1342 if self.parent.shouldRetry(tries, e, deadline): 1343 tries += 1 1344 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1345 continue 1346 raise plumbing.convert_error_to_porcelain(e) from e 1347 break 1348 1349 resp = models.AccountGroupDeleteResponse() 1350 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 1351 plumbing_response.meta) 1352 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1353 plumbing_response.rate_limit) 1354 return resp
Delete removes an AccountGroup by ID.
def
list(self, filter, *args, timeout=None)
1356 def list(self, filter, *args, timeout=None): 1357 ''' 1358 List gets a list of AccountGroups matching a given set of criteria. 1359 ''' 1360 deadline = None if timeout is None else time.time() + timeout 1361 req = AccountGroupListRequest() 1362 req.meta.CopyFrom(ListRequestMetadata()) 1363 if self.parent.page_limit > 0: 1364 req.meta.limit = self.parent.page_limit 1365 if self.parent.snapshot_datetime is not None: 1366 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1367 1368 req.filter = plumbing.quote_filter_args(filter, *args) 1369 1370 def generator(svc, req): 1371 tries = 0 1372 while True: 1373 t = None if deadline is None else deadline - time.time() 1374 try: 1375 plumbing_response = svc.stub.List( 1376 req, 1377 metadata=svc.parent.get_metadata( 1378 'AccountsGroups.List', req), 1379 timeout=t) 1380 except Exception as e: 1381 if self.parent.shouldRetry(tries, e, deadline): 1382 tries += 1 1383 time.sleep( 1384 self.parent.exponentialBackoff(tries, deadline)) 1385 continue 1386 raise plumbing.convert_error_to_porcelain(e) from e 1387 tries = 0 1388 for plumbing_item in plumbing_response.account_groups: 1389 yield plumbing.convert_account_group_to_porcelain( 1390 plumbing_item) 1391 if plumbing_response.meta.next_cursor == '': 1392 break 1393 req.meta.cursor = plumbing_response.meta.next_cursor 1394 1395 return generator(self, req)
List gets a list of AccountGroups matching a given set of criteria.
class
SnapshotAccountsGroups:
1398class SnapshotAccountsGroups: 1399 ''' 1400 SnapshotAccountsGroups exposes the read only methods of the AccountsGroups 1401 service for historical queries. 1402 ''' 1403 def __init__(self, accounts_groups): 1404 self.accounts_groups = accounts_groups 1405 1406 def get(self, id, timeout=None): 1407 ''' 1408 Get reads one AccountGroup by ID. 1409 ''' 1410 return self.accounts_groups.get(id, timeout=timeout) 1411 1412 def list(self, filter, *args, timeout=None): 1413 ''' 1414 List gets a list of AccountGroups matching a given set of criteria. 1415 ''' 1416 return self.accounts_groups.list(filter, *args, timeout=timeout)
SnapshotAccountsGroups exposes the read only methods of the AccountsGroups service for historical queries.
def
get(self, id, timeout=None)
1406 def get(self, id, timeout=None): 1407 ''' 1408 Get reads one AccountGroup by ID. 1409 ''' 1410 return self.accounts_groups.get(id, timeout=timeout)
Get reads one AccountGroup by ID.
def
list(self, filter, *args, timeout=None)
1412 def list(self, filter, *args, timeout=None): 1413 ''' 1414 List gets a list of AccountGroups matching a given set of criteria. 1415 ''' 1416 return self.accounts_groups.list(filter, *args, timeout=timeout)
List gets a list of AccountGroups matching a given set of criteria.
class
AccountsGroupsHistory:
1419class AccountsGroupsHistory: 1420 ''' 1421 AccountsGroupsHistory records all changes to the state of an AccountGroup. 1422 See `strongdm.models.AccountGroupHistory`. 1423 ''' 1424 def __init__(self, channel, client): 1425 self.parent = client 1426 self.stub = AccountsGroupsHistoryStub(channel) 1427 1428 def list(self, filter, *args, timeout=None): 1429 ''' 1430 List gets a list of AccountGroupHistory records matching a given set of criteria. 1431 ''' 1432 deadline = None if timeout is None else time.time() + timeout 1433 req = AccountGroupHistoryListRequest() 1434 req.meta.CopyFrom(ListRequestMetadata()) 1435 if self.parent.page_limit > 0: 1436 req.meta.limit = self.parent.page_limit 1437 if self.parent.snapshot_datetime is not None: 1438 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1439 1440 req.filter = plumbing.quote_filter_args(filter, *args) 1441 1442 def generator(svc, req): 1443 tries = 0 1444 while True: 1445 t = None if deadline is None else deadline - time.time() 1446 try: 1447 plumbing_response = svc.stub.List( 1448 req, 1449 metadata=svc.parent.get_metadata( 1450 'AccountsGroupsHistory.List', req), 1451 timeout=t) 1452 except Exception as e: 1453 if self.parent.shouldRetry(tries, e, deadline): 1454 tries += 1 1455 time.sleep( 1456 self.parent.exponentialBackoff(tries, deadline)) 1457 continue 1458 raise plumbing.convert_error_to_porcelain(e) from e 1459 tries = 0 1460 for plumbing_item in plumbing_response.history: 1461 yield plumbing.convert_account_group_history_to_porcelain( 1462 plumbing_item) 1463 if plumbing_response.meta.next_cursor == '': 1464 break 1465 req.meta.cursor = plumbing_response.meta.next_cursor 1466 1467 return generator(self, req)
AccountsGroupsHistory records all changes to the state of an AccountGroup.
See strongdm.models.AccountGroupHistory.
def
list(self, filter, *args, timeout=None)
1428 def list(self, filter, *args, timeout=None): 1429 ''' 1430 List gets a list of AccountGroupHistory records matching a given set of criteria. 1431 ''' 1432 deadline = None if timeout is None else time.time() + timeout 1433 req = AccountGroupHistoryListRequest() 1434 req.meta.CopyFrom(ListRequestMetadata()) 1435 if self.parent.page_limit > 0: 1436 req.meta.limit = self.parent.page_limit 1437 if self.parent.snapshot_datetime is not None: 1438 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1439 1440 req.filter = plumbing.quote_filter_args(filter, *args) 1441 1442 def generator(svc, req): 1443 tries = 0 1444 while True: 1445 t = None if deadline is None else deadline - time.time() 1446 try: 1447 plumbing_response = svc.stub.List( 1448 req, 1449 metadata=svc.parent.get_metadata( 1450 'AccountsGroupsHistory.List', req), 1451 timeout=t) 1452 except Exception as e: 1453 if self.parent.shouldRetry(tries, e, deadline): 1454 tries += 1 1455 time.sleep( 1456 self.parent.exponentialBackoff(tries, deadline)) 1457 continue 1458 raise plumbing.convert_error_to_porcelain(e) from e 1459 tries = 0 1460 for plumbing_item in plumbing_response.history: 1461 yield plumbing.convert_account_group_history_to_porcelain( 1462 plumbing_item) 1463 if plumbing_response.meta.next_cursor == '': 1464 break 1465 req.meta.cursor = plumbing_response.meta.next_cursor 1466 1467 return generator(self, req)
List gets a list of AccountGroupHistory records matching a given set of criteria.
class
AccountsHistory:
1470class AccountsHistory: 1471 ''' 1472 AccountsHistory records all changes to the state of an Account. 1473 See `strongdm.models.AccountHistory`. 1474 ''' 1475 def __init__(self, channel, client): 1476 self.parent = client 1477 self.stub = AccountsHistoryStub(channel) 1478 1479 def list(self, filter, *args, timeout=None): 1480 ''' 1481 List gets a list of AccountHistory records matching a given set of criteria. 1482 ''' 1483 deadline = None if timeout is None else time.time() + timeout 1484 req = AccountHistoryListRequest() 1485 req.meta.CopyFrom(ListRequestMetadata()) 1486 if self.parent.page_limit > 0: 1487 req.meta.limit = self.parent.page_limit 1488 if self.parent.snapshot_datetime is not None: 1489 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1490 1491 req.filter = plumbing.quote_filter_args(filter, *args) 1492 1493 def generator(svc, req): 1494 tries = 0 1495 while True: 1496 t = None if deadline is None else deadline - time.time() 1497 try: 1498 plumbing_response = svc.stub.List( 1499 req, 1500 metadata=svc.parent.get_metadata( 1501 'AccountsHistory.List', req), 1502 timeout=t) 1503 except Exception as e: 1504 if self.parent.shouldRetry(tries, e, deadline): 1505 tries += 1 1506 time.sleep( 1507 self.parent.exponentialBackoff(tries, deadline)) 1508 continue 1509 raise plumbing.convert_error_to_porcelain(e) from e 1510 tries = 0 1511 for plumbing_item in plumbing_response.history: 1512 yield plumbing.convert_account_history_to_porcelain( 1513 plumbing_item) 1514 if plumbing_response.meta.next_cursor == '': 1515 break 1516 req.meta.cursor = plumbing_response.meta.next_cursor 1517 1518 return generator(self, req)
AccountsHistory records all changes to the state of an Account.
See strongdm.models.AccountHistory.
def
list(self, filter, *args, timeout=None)
1479 def list(self, filter, *args, timeout=None): 1480 ''' 1481 List gets a list of AccountHistory records matching a given set of criteria. 1482 ''' 1483 deadline = None if timeout is None else time.time() + timeout 1484 req = AccountHistoryListRequest() 1485 req.meta.CopyFrom(ListRequestMetadata()) 1486 if self.parent.page_limit > 0: 1487 req.meta.limit = self.parent.page_limit 1488 if self.parent.snapshot_datetime is not None: 1489 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1490 1491 req.filter = plumbing.quote_filter_args(filter, *args) 1492 1493 def generator(svc, req): 1494 tries = 0 1495 while True: 1496 t = None if deadline is None else deadline - time.time() 1497 try: 1498 plumbing_response = svc.stub.List( 1499 req, 1500 metadata=svc.parent.get_metadata( 1501 'AccountsHistory.List', req), 1502 timeout=t) 1503 except Exception as e: 1504 if self.parent.shouldRetry(tries, e, deadline): 1505 tries += 1 1506 time.sleep( 1507 self.parent.exponentialBackoff(tries, deadline)) 1508 continue 1509 raise plumbing.convert_error_to_porcelain(e) from e 1510 tries = 0 1511 for plumbing_item in plumbing_response.history: 1512 yield plumbing.convert_account_history_to_porcelain( 1513 plumbing_item) 1514 if plumbing_response.meta.next_cursor == '': 1515 break 1516 req.meta.cursor = plumbing_response.meta.next_cursor 1517 1518 return generator(self, req)
List gets a list of AccountHistory records matching a given set of criteria.
class
Activities:
1521class Activities: 1522 ''' 1523 An Activity is a record of an action taken against a strongDM deployment, e.g. 1524 a user creation, resource deletion, sso configuration change, etc. The Activities 1525 service is read-only. 1526 See `strongdm.models.Activity`. 1527 ''' 1528 def __init__(self, channel, client): 1529 self.parent = client 1530 self.stub = ActivitiesStub(channel) 1531 1532 def get(self, id, timeout=None): 1533 ''' 1534 Get reads one Activity by ID. 1535 ''' 1536 deadline = None if timeout is None else time.time() + timeout 1537 req = ActivityGetRequest() 1538 if self.parent.snapshot_datetime is not None: 1539 req.meta.CopyFrom(GetRequestMetadata()) 1540 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1541 1542 req.id = (id) 1543 tries = 0 1544 plumbing_response = None 1545 while True: 1546 t = None if deadline is None else deadline - time.time() 1547 try: 1548 plumbing_response = self.stub.Get( 1549 req, 1550 metadata=self.parent.get_metadata('Activities.Get', req), 1551 timeout=t) 1552 except Exception as e: 1553 if self.parent.shouldRetry(tries, e, deadline): 1554 tries += 1 1555 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1556 continue 1557 raise plumbing.convert_error_to_porcelain(e) from e 1558 break 1559 1560 resp = models.ActivityGetResponse() 1561 resp.activity = plumbing.convert_activity_to_porcelain( 1562 plumbing_response.activity) 1563 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1564 plumbing_response.meta) 1565 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1566 plumbing_response.rate_limit) 1567 return resp 1568 1569 def list(self, filter, *args, timeout=None): 1570 ''' 1571 List gets a list of Activities matching a given set of criteria. 1572 The 'before' and 'after' filters can be used to control the time 1573 range of the output activities. If not provided, one week of back 1574 of activities will be returned. 1575 ''' 1576 deadline = None if timeout is None else time.time() + timeout 1577 req = ActivityListRequest() 1578 req.meta.CopyFrom(ListRequestMetadata()) 1579 if self.parent.page_limit > 0: 1580 req.meta.limit = self.parent.page_limit 1581 if self.parent.snapshot_datetime is not None: 1582 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1583 1584 req.filter = plumbing.quote_filter_args(filter, *args) 1585 1586 def generator(svc, req): 1587 tries = 0 1588 while True: 1589 t = None if deadline is None else deadline - time.time() 1590 try: 1591 plumbing_response = svc.stub.List( 1592 req, 1593 metadata=svc.parent.get_metadata( 1594 'Activities.List', req), 1595 timeout=t) 1596 except Exception as e: 1597 if self.parent.shouldRetry(tries, e, deadline): 1598 tries += 1 1599 time.sleep( 1600 self.parent.exponentialBackoff(tries, deadline)) 1601 continue 1602 raise plumbing.convert_error_to_porcelain(e) from e 1603 tries = 0 1604 for plumbing_item in plumbing_response.activities: 1605 yield plumbing.convert_activity_to_porcelain(plumbing_item) 1606 if plumbing_response.meta.next_cursor == '': 1607 break 1608 req.meta.cursor = plumbing_response.meta.next_cursor 1609 1610 return generator(self, req)
An Activity is a record of an action taken against a strongDM deployment, e.g.
a user creation, resource deletion, sso configuration change, etc. The Activities
service is read-only.
See strongdm.models.Activity.
def
get(self, id, timeout=None)
1532 def get(self, id, timeout=None): 1533 ''' 1534 Get reads one Activity by ID. 1535 ''' 1536 deadline = None if timeout is None else time.time() + timeout 1537 req = ActivityGetRequest() 1538 if self.parent.snapshot_datetime is not None: 1539 req.meta.CopyFrom(GetRequestMetadata()) 1540 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1541 1542 req.id = (id) 1543 tries = 0 1544 plumbing_response = None 1545 while True: 1546 t = None if deadline is None else deadline - time.time() 1547 try: 1548 plumbing_response = self.stub.Get( 1549 req, 1550 metadata=self.parent.get_metadata('Activities.Get', req), 1551 timeout=t) 1552 except Exception as e: 1553 if self.parent.shouldRetry(tries, e, deadline): 1554 tries += 1 1555 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1556 continue 1557 raise plumbing.convert_error_to_porcelain(e) from e 1558 break 1559 1560 resp = models.ActivityGetResponse() 1561 resp.activity = plumbing.convert_activity_to_porcelain( 1562 plumbing_response.activity) 1563 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1564 plumbing_response.meta) 1565 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1566 plumbing_response.rate_limit) 1567 return resp
Get reads one Activity by ID.
def
list(self, filter, *args, timeout=None)
1569 def list(self, filter, *args, timeout=None): 1570 ''' 1571 List gets a list of Activities matching a given set of criteria. 1572 The 'before' and 'after' filters can be used to control the time 1573 range of the output activities. If not provided, one week of back 1574 of activities will be returned. 1575 ''' 1576 deadline = None if timeout is None else time.time() + timeout 1577 req = ActivityListRequest() 1578 req.meta.CopyFrom(ListRequestMetadata()) 1579 if self.parent.page_limit > 0: 1580 req.meta.limit = self.parent.page_limit 1581 if self.parent.snapshot_datetime is not None: 1582 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1583 1584 req.filter = plumbing.quote_filter_args(filter, *args) 1585 1586 def generator(svc, req): 1587 tries = 0 1588 while True: 1589 t = None if deadline is None else deadline - time.time() 1590 try: 1591 plumbing_response = svc.stub.List( 1592 req, 1593 metadata=svc.parent.get_metadata( 1594 'Activities.List', req), 1595 timeout=t) 1596 except Exception as e: 1597 if self.parent.shouldRetry(tries, e, deadline): 1598 tries += 1 1599 time.sleep( 1600 self.parent.exponentialBackoff(tries, deadline)) 1601 continue 1602 raise plumbing.convert_error_to_porcelain(e) from e 1603 tries = 0 1604 for plumbing_item in plumbing_response.activities: 1605 yield plumbing.convert_activity_to_porcelain(plumbing_item) 1606 if plumbing_response.meta.next_cursor == '': 1607 break 1608 req.meta.cursor = plumbing_response.meta.next_cursor 1609 1610 return generator(self, req)
List gets a list of Activities matching a given set of criteria. The 'before' and 'after' filters can be used to control the time range of the output activities. If not provided, one week of back of activities will be returned.
class
ApprovalWorkflowApprovers:
1613class ApprovalWorkflowApprovers: 1614 ''' 1615 ApprovalWorkflowApprovers link approval workflow approvers to an ApprovalWorkflowStep 1616 See `strongdm.models.ApprovalWorkflowApprover`. 1617 ''' 1618 def __init__(self, channel, client): 1619 self.parent = client 1620 self.stub = ApprovalWorkflowApproversStub(channel) 1621 1622 def create(self, approval_workflow_approver, timeout=None): 1623 ''' 1624 Deprecated: Create creates a new approval workflow approver. 1625 ''' 1626 deadline = None if timeout is None else time.time() + timeout 1627 req = ApprovalWorkflowApproverCreateRequest() 1628 1629 if approval_workflow_approver is not None: 1630 req.approval_workflow_approver.CopyFrom( 1631 plumbing.convert_approval_workflow_approver_to_plumbing( 1632 approval_workflow_approver)) 1633 tries = 0 1634 plumbing_response = None 1635 while True: 1636 t = None if deadline is None else deadline - time.time() 1637 try: 1638 plumbing_response = self.stub.Create( 1639 req, 1640 metadata=self.parent.get_metadata( 1641 'ApprovalWorkflowApprovers.Create', req), 1642 timeout=t) 1643 except Exception as e: 1644 if self.parent.shouldRetry(tries, e, deadline): 1645 tries += 1 1646 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1647 continue 1648 raise plumbing.convert_error_to_porcelain(e) from e 1649 break 1650 1651 resp = models.ApprovalWorkflowApproverCreateResponse() 1652 resp.approval_workflow_approver = plumbing.convert_approval_workflow_approver_to_porcelain( 1653 plumbing_response.approval_workflow_approver) 1654 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1655 plumbing_response.rate_limit) 1656 return resp 1657 1658 def get(self, id, timeout=None): 1659 ''' 1660 Deprecated: Get reads one approval workflow approver by ID. 1661 ''' 1662 deadline = None if timeout is None else time.time() + timeout 1663 req = ApprovalWorkflowApproverGetRequest() 1664 if self.parent.snapshot_datetime is not None: 1665 req.meta.CopyFrom(GetRequestMetadata()) 1666 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1667 1668 req.id = (id) 1669 tries = 0 1670 plumbing_response = None 1671 while True: 1672 t = None if deadline is None else deadline - time.time() 1673 try: 1674 plumbing_response = self.stub.Get( 1675 req, 1676 metadata=self.parent.get_metadata( 1677 'ApprovalWorkflowApprovers.Get', req), 1678 timeout=t) 1679 except Exception as e: 1680 if self.parent.shouldRetry(tries, e, deadline): 1681 tries += 1 1682 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1683 continue 1684 raise plumbing.convert_error_to_porcelain(e) from e 1685 break 1686 1687 resp = models.ApprovalWorkflowApproverGetResponse() 1688 resp.approval_workflow_approver = plumbing.convert_approval_workflow_approver_to_porcelain( 1689 plumbing_response.approval_workflow_approver) 1690 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1691 plumbing_response.meta) 1692 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1693 plumbing_response.rate_limit) 1694 return resp 1695 1696 def delete(self, id, timeout=None): 1697 ''' 1698 Deprecated: Delete deletes an existing approval workflow approver. 1699 ''' 1700 deadline = None if timeout is None else time.time() + timeout 1701 req = ApprovalWorkflowApproverDeleteRequest() 1702 1703 req.id = (id) 1704 tries = 0 1705 plumbing_response = None 1706 while True: 1707 t = None if deadline is None else deadline - time.time() 1708 try: 1709 plumbing_response = self.stub.Delete( 1710 req, 1711 metadata=self.parent.get_metadata( 1712 'ApprovalWorkflowApprovers.Delete', req), 1713 timeout=t) 1714 except Exception as e: 1715 if self.parent.shouldRetry(tries, e, deadline): 1716 tries += 1 1717 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1718 continue 1719 raise plumbing.convert_error_to_porcelain(e) from e 1720 break 1721 1722 resp = models.ApprovalWorkflowApproverDeleteResponse() 1723 resp.id = (plumbing_response.id) 1724 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1725 plumbing_response.rate_limit) 1726 return resp 1727 1728 def list(self, filter, *args, timeout=None): 1729 ''' 1730 Deprecated: Lists existing approval workflow approvers. 1731 ''' 1732 deadline = None if timeout is None else time.time() + timeout 1733 req = ApprovalWorkflowApproverListRequest() 1734 req.meta.CopyFrom(ListRequestMetadata()) 1735 if self.parent.page_limit > 0: 1736 req.meta.limit = self.parent.page_limit 1737 if self.parent.snapshot_datetime is not None: 1738 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1739 1740 req.filter = plumbing.quote_filter_args(filter, *args) 1741 1742 def generator(svc, req): 1743 tries = 0 1744 while True: 1745 t = None if deadline is None else deadline - time.time() 1746 try: 1747 plumbing_response = svc.stub.List( 1748 req, 1749 metadata=svc.parent.get_metadata( 1750 'ApprovalWorkflowApprovers.List', req), 1751 timeout=t) 1752 except Exception as e: 1753 if self.parent.shouldRetry(tries, e, deadline): 1754 tries += 1 1755 time.sleep( 1756 self.parent.exponentialBackoff(tries, deadline)) 1757 continue 1758 raise plumbing.convert_error_to_porcelain(e) from e 1759 tries = 0 1760 for plumbing_item in plumbing_response.approval_workflow_approvers: 1761 yield plumbing.convert_approval_workflow_approver_to_porcelain( 1762 plumbing_item) 1763 if plumbing_response.meta.next_cursor == '': 1764 break 1765 req.meta.cursor = plumbing_response.meta.next_cursor 1766 1767 return generator(self, req)
ApprovalWorkflowApprovers link approval workflow approvers to an ApprovalWorkflowStep
See strongdm.models.ApprovalWorkflowApprover.
def
create(self, approval_workflow_approver, timeout=None)
1622 def create(self, approval_workflow_approver, timeout=None): 1623 ''' 1624 Deprecated: Create creates a new approval workflow approver. 1625 ''' 1626 deadline = None if timeout is None else time.time() + timeout 1627 req = ApprovalWorkflowApproverCreateRequest() 1628 1629 if approval_workflow_approver is not None: 1630 req.approval_workflow_approver.CopyFrom( 1631 plumbing.convert_approval_workflow_approver_to_plumbing( 1632 approval_workflow_approver)) 1633 tries = 0 1634 plumbing_response = None 1635 while True: 1636 t = None if deadline is None else deadline - time.time() 1637 try: 1638 plumbing_response = self.stub.Create( 1639 req, 1640 metadata=self.parent.get_metadata( 1641 'ApprovalWorkflowApprovers.Create', req), 1642 timeout=t) 1643 except Exception as e: 1644 if self.parent.shouldRetry(tries, e, deadline): 1645 tries += 1 1646 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1647 continue 1648 raise plumbing.convert_error_to_porcelain(e) from e 1649 break 1650 1651 resp = models.ApprovalWorkflowApproverCreateResponse() 1652 resp.approval_workflow_approver = plumbing.convert_approval_workflow_approver_to_porcelain( 1653 plumbing_response.approval_workflow_approver) 1654 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1655 plumbing_response.rate_limit) 1656 return resp
Deprecated: Create creates a new approval workflow approver.
def
get(self, id, timeout=None)
1658 def get(self, id, timeout=None): 1659 ''' 1660 Deprecated: Get reads one approval workflow approver by ID. 1661 ''' 1662 deadline = None if timeout is None else time.time() + timeout 1663 req = ApprovalWorkflowApproverGetRequest() 1664 if self.parent.snapshot_datetime is not None: 1665 req.meta.CopyFrom(GetRequestMetadata()) 1666 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1667 1668 req.id = (id) 1669 tries = 0 1670 plumbing_response = None 1671 while True: 1672 t = None if deadline is None else deadline - time.time() 1673 try: 1674 plumbing_response = self.stub.Get( 1675 req, 1676 metadata=self.parent.get_metadata( 1677 'ApprovalWorkflowApprovers.Get', req), 1678 timeout=t) 1679 except Exception as e: 1680 if self.parent.shouldRetry(tries, e, deadline): 1681 tries += 1 1682 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1683 continue 1684 raise plumbing.convert_error_to_porcelain(e) from e 1685 break 1686 1687 resp = models.ApprovalWorkflowApproverGetResponse() 1688 resp.approval_workflow_approver = plumbing.convert_approval_workflow_approver_to_porcelain( 1689 plumbing_response.approval_workflow_approver) 1690 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1691 plumbing_response.meta) 1692 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1693 plumbing_response.rate_limit) 1694 return resp
Deprecated: Get reads one approval workflow approver by ID.
def
delete(self, id, timeout=None)
1696 def delete(self, id, timeout=None): 1697 ''' 1698 Deprecated: Delete deletes an existing approval workflow approver. 1699 ''' 1700 deadline = None if timeout is None else time.time() + timeout 1701 req = ApprovalWorkflowApproverDeleteRequest() 1702 1703 req.id = (id) 1704 tries = 0 1705 plumbing_response = None 1706 while True: 1707 t = None if deadline is None else deadline - time.time() 1708 try: 1709 plumbing_response = self.stub.Delete( 1710 req, 1711 metadata=self.parent.get_metadata( 1712 'ApprovalWorkflowApprovers.Delete', req), 1713 timeout=t) 1714 except Exception as e: 1715 if self.parent.shouldRetry(tries, e, deadline): 1716 tries += 1 1717 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1718 continue 1719 raise plumbing.convert_error_to_porcelain(e) from e 1720 break 1721 1722 resp = models.ApprovalWorkflowApproverDeleteResponse() 1723 resp.id = (plumbing_response.id) 1724 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1725 plumbing_response.rate_limit) 1726 return resp
Deprecated: Delete deletes an existing approval workflow approver.
def
list(self, filter, *args, timeout=None)
1728 def list(self, filter, *args, timeout=None): 1729 ''' 1730 Deprecated: Lists existing approval workflow approvers. 1731 ''' 1732 deadline = None if timeout is None else time.time() + timeout 1733 req = ApprovalWorkflowApproverListRequest() 1734 req.meta.CopyFrom(ListRequestMetadata()) 1735 if self.parent.page_limit > 0: 1736 req.meta.limit = self.parent.page_limit 1737 if self.parent.snapshot_datetime is not None: 1738 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1739 1740 req.filter = plumbing.quote_filter_args(filter, *args) 1741 1742 def generator(svc, req): 1743 tries = 0 1744 while True: 1745 t = None if deadline is None else deadline - time.time() 1746 try: 1747 plumbing_response = svc.stub.List( 1748 req, 1749 metadata=svc.parent.get_metadata( 1750 'ApprovalWorkflowApprovers.List', req), 1751 timeout=t) 1752 except Exception as e: 1753 if self.parent.shouldRetry(tries, e, deadline): 1754 tries += 1 1755 time.sleep( 1756 self.parent.exponentialBackoff(tries, deadline)) 1757 continue 1758 raise plumbing.convert_error_to_porcelain(e) from e 1759 tries = 0 1760 for plumbing_item in plumbing_response.approval_workflow_approvers: 1761 yield plumbing.convert_approval_workflow_approver_to_porcelain( 1762 plumbing_item) 1763 if plumbing_response.meta.next_cursor == '': 1764 break 1765 req.meta.cursor = plumbing_response.meta.next_cursor 1766 1767 return generator(self, req)
Deprecated: Lists existing approval workflow approvers.
class
SnapshotApprovalWorkflowApprovers:
1770class SnapshotApprovalWorkflowApprovers: 1771 ''' 1772 SnapshotApprovalWorkflowApprovers exposes the read only methods of the ApprovalWorkflowApprovers 1773 service for historical queries. 1774 ''' 1775 def __init__(self, approval_workflow_approvers): 1776 self.approval_workflow_approvers = approval_workflow_approvers 1777 1778 def get(self, id, timeout=None): 1779 ''' 1780 Deprecated: Get reads one approval workflow approver by ID. 1781 ''' 1782 return self.approval_workflow_approvers.get(id, timeout=timeout) 1783 1784 def list(self, filter, *args, timeout=None): 1785 ''' 1786 Deprecated: Lists existing approval workflow approvers. 1787 ''' 1788 return self.approval_workflow_approvers.list(filter, 1789 *args, 1790 timeout=timeout)
SnapshotApprovalWorkflowApprovers exposes the read only methods of the ApprovalWorkflowApprovers service for historical queries.
def
get(self, id, timeout=None)
1778 def get(self, id, timeout=None): 1779 ''' 1780 Deprecated: Get reads one approval workflow approver by ID. 1781 ''' 1782 return self.approval_workflow_approvers.get(id, timeout=timeout)
Deprecated: Get reads one approval workflow approver by ID.
def
list(self, filter, *args, timeout=None)
1784 def list(self, filter, *args, timeout=None): 1785 ''' 1786 Deprecated: Lists existing approval workflow approvers. 1787 ''' 1788 return self.approval_workflow_approvers.list(filter, 1789 *args, 1790 timeout=timeout)
Deprecated: Lists existing approval workflow approvers.
class
ApprovalWorkflowApproversHistory:
1793class ApprovalWorkflowApproversHistory: 1794 ''' 1795 ApprovalWorkflowApproversHistory records all changes to the state of an ApprovalWorkflowApprover. 1796 See `strongdm.models.ApprovalWorkflowApproverHistory`. 1797 ''' 1798 def __init__(self, channel, client): 1799 self.parent = client 1800 self.stub = ApprovalWorkflowApproversHistoryStub(channel) 1801 1802 def list(self, filter, *args, timeout=None): 1803 ''' 1804 List gets a list of ApprovalWorkflowApproverHistory records matching a given set of criteria. 1805 ''' 1806 deadline = None if timeout is None else time.time() + timeout 1807 req = ApprovalWorkflowApproverHistoryListRequest() 1808 req.meta.CopyFrom(ListRequestMetadata()) 1809 if self.parent.page_limit > 0: 1810 req.meta.limit = self.parent.page_limit 1811 if self.parent.snapshot_datetime is not None: 1812 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1813 1814 req.filter = plumbing.quote_filter_args(filter, *args) 1815 1816 def generator(svc, req): 1817 tries = 0 1818 while True: 1819 t = None if deadline is None else deadline - time.time() 1820 try: 1821 plumbing_response = svc.stub.List( 1822 req, 1823 metadata=svc.parent.get_metadata( 1824 'ApprovalWorkflowApproversHistory.List', req), 1825 timeout=t) 1826 except Exception as e: 1827 if self.parent.shouldRetry(tries, e, deadline): 1828 tries += 1 1829 time.sleep( 1830 self.parent.exponentialBackoff(tries, deadline)) 1831 continue 1832 raise plumbing.convert_error_to_porcelain(e) from e 1833 tries = 0 1834 for plumbing_item in plumbing_response.history: 1835 yield plumbing.convert_approval_workflow_approver_history_to_porcelain( 1836 plumbing_item) 1837 if plumbing_response.meta.next_cursor == '': 1838 break 1839 req.meta.cursor = plumbing_response.meta.next_cursor 1840 1841 return generator(self, req)
ApprovalWorkflowApproversHistory records all changes to the state of an ApprovalWorkflowApprover.
See strongdm.models.ApprovalWorkflowApproverHistory.
def
list(self, filter, *args, timeout=None)
1802 def list(self, filter, *args, timeout=None): 1803 ''' 1804 List gets a list of ApprovalWorkflowApproverHistory records matching a given set of criteria. 1805 ''' 1806 deadline = None if timeout is None else time.time() + timeout 1807 req = ApprovalWorkflowApproverHistoryListRequest() 1808 req.meta.CopyFrom(ListRequestMetadata()) 1809 if self.parent.page_limit > 0: 1810 req.meta.limit = self.parent.page_limit 1811 if self.parent.snapshot_datetime is not None: 1812 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1813 1814 req.filter = plumbing.quote_filter_args(filter, *args) 1815 1816 def generator(svc, req): 1817 tries = 0 1818 while True: 1819 t = None if deadline is None else deadline - time.time() 1820 try: 1821 plumbing_response = svc.stub.List( 1822 req, 1823 metadata=svc.parent.get_metadata( 1824 'ApprovalWorkflowApproversHistory.List', req), 1825 timeout=t) 1826 except Exception as e: 1827 if self.parent.shouldRetry(tries, e, deadline): 1828 tries += 1 1829 time.sleep( 1830 self.parent.exponentialBackoff(tries, deadline)) 1831 continue 1832 raise plumbing.convert_error_to_porcelain(e) from e 1833 tries = 0 1834 for plumbing_item in plumbing_response.history: 1835 yield plumbing.convert_approval_workflow_approver_history_to_porcelain( 1836 plumbing_item) 1837 if plumbing_response.meta.next_cursor == '': 1838 break 1839 req.meta.cursor = plumbing_response.meta.next_cursor 1840 1841 return generator(self, req)
List gets a list of ApprovalWorkflowApproverHistory records matching a given set of criteria.
class
ApprovalWorkflowSteps:
1844class ApprovalWorkflowSteps: 1845 ''' 1846 ApprovalWorkflowSteps link approval workflow steps to an ApprovalWorkflow 1847 See `strongdm.models.ApprovalWorkflowStep`. 1848 ''' 1849 def __init__(self, channel, client): 1850 self.parent = client 1851 self.stub = ApprovalWorkflowStepsStub(channel) 1852 1853 def create(self, approval_workflow_step, timeout=None): 1854 ''' 1855 Deprecated: Create creates a new approval workflow step. 1856 ''' 1857 deadline = None if timeout is None else time.time() + timeout 1858 req = ApprovalWorkflowStepCreateRequest() 1859 1860 if approval_workflow_step is not None: 1861 req.approval_workflow_step.CopyFrom( 1862 plumbing.convert_approval_workflow_step_to_plumbing( 1863 approval_workflow_step)) 1864 tries = 0 1865 plumbing_response = None 1866 while True: 1867 t = None if deadline is None else deadline - time.time() 1868 try: 1869 plumbing_response = self.stub.Create( 1870 req, 1871 metadata=self.parent.get_metadata( 1872 'ApprovalWorkflowSteps.Create', req), 1873 timeout=t) 1874 except Exception as e: 1875 if self.parent.shouldRetry(tries, e, deadline): 1876 tries += 1 1877 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1878 continue 1879 raise plumbing.convert_error_to_porcelain(e) from e 1880 break 1881 1882 resp = models.ApprovalWorkflowStepCreateResponse() 1883 resp.approval_workflow_step = plumbing.convert_approval_workflow_step_to_porcelain( 1884 plumbing_response.approval_workflow_step) 1885 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1886 plumbing_response.rate_limit) 1887 return resp 1888 1889 def get(self, id, timeout=None): 1890 ''' 1891 Deprecated: Get reads one approval workflow step by ID. 1892 ''' 1893 deadline = None if timeout is None else time.time() + timeout 1894 req = ApprovalWorkflowStepGetRequest() 1895 if self.parent.snapshot_datetime is not None: 1896 req.meta.CopyFrom(GetRequestMetadata()) 1897 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1898 1899 req.id = (id) 1900 tries = 0 1901 plumbing_response = None 1902 while True: 1903 t = None if deadline is None else deadline - time.time() 1904 try: 1905 plumbing_response = self.stub.Get( 1906 req, 1907 metadata=self.parent.get_metadata( 1908 'ApprovalWorkflowSteps.Get', req), 1909 timeout=t) 1910 except Exception as e: 1911 if self.parent.shouldRetry(tries, e, deadline): 1912 tries += 1 1913 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1914 continue 1915 raise plumbing.convert_error_to_porcelain(e) from e 1916 break 1917 1918 resp = models.ApprovalWorkflowStepGetResponse() 1919 resp.approval_workflow_step = plumbing.convert_approval_workflow_step_to_porcelain( 1920 plumbing_response.approval_workflow_step) 1921 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1922 plumbing_response.meta) 1923 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1924 plumbing_response.rate_limit) 1925 return resp 1926 1927 def delete(self, id, timeout=None): 1928 ''' 1929 Deprecated: Delete deletes an existing approval workflow step. 1930 ''' 1931 deadline = None if timeout is None else time.time() + timeout 1932 req = ApprovalWorkflowStepDeleteRequest() 1933 1934 req.id = (id) 1935 tries = 0 1936 plumbing_response = None 1937 while True: 1938 t = None if deadline is None else deadline - time.time() 1939 try: 1940 plumbing_response = self.stub.Delete( 1941 req, 1942 metadata=self.parent.get_metadata( 1943 'ApprovalWorkflowSteps.Delete', req), 1944 timeout=t) 1945 except Exception as e: 1946 if self.parent.shouldRetry(tries, e, deadline): 1947 tries += 1 1948 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1949 continue 1950 raise plumbing.convert_error_to_porcelain(e) from e 1951 break 1952 1953 resp = models.ApprovalWorkflowStepDeleteResponse() 1954 resp.id = (plumbing_response.id) 1955 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1956 plumbing_response.rate_limit) 1957 return resp 1958 1959 def list(self, filter, *args, timeout=None): 1960 ''' 1961 Deprecated: Lists existing approval workflow steps. 1962 ''' 1963 deadline = None if timeout is None else time.time() + timeout 1964 req = ApprovalWorkflowStepListRequest() 1965 req.meta.CopyFrom(ListRequestMetadata()) 1966 if self.parent.page_limit > 0: 1967 req.meta.limit = self.parent.page_limit 1968 if self.parent.snapshot_datetime is not None: 1969 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1970 1971 req.filter = plumbing.quote_filter_args(filter, *args) 1972 1973 def generator(svc, req): 1974 tries = 0 1975 while True: 1976 t = None if deadline is None else deadline - time.time() 1977 try: 1978 plumbing_response = svc.stub.List( 1979 req, 1980 metadata=svc.parent.get_metadata( 1981 'ApprovalWorkflowSteps.List', req), 1982 timeout=t) 1983 except Exception as e: 1984 if self.parent.shouldRetry(tries, e, deadline): 1985 tries += 1 1986 time.sleep( 1987 self.parent.exponentialBackoff(tries, deadline)) 1988 continue 1989 raise plumbing.convert_error_to_porcelain(e) from e 1990 tries = 0 1991 for plumbing_item in plumbing_response.approval_workflow_steps: 1992 yield plumbing.convert_approval_workflow_step_to_porcelain( 1993 plumbing_item) 1994 if plumbing_response.meta.next_cursor == '': 1995 break 1996 req.meta.cursor = plumbing_response.meta.next_cursor 1997 1998 return generator(self, req)
ApprovalWorkflowSteps link approval workflow steps to an ApprovalWorkflow
See strongdm.models.ApprovalWorkflowStep.
def
create(self, approval_workflow_step, timeout=None)
1853 def create(self, approval_workflow_step, timeout=None): 1854 ''' 1855 Deprecated: Create creates a new approval workflow step. 1856 ''' 1857 deadline = None if timeout is None else time.time() + timeout 1858 req = ApprovalWorkflowStepCreateRequest() 1859 1860 if approval_workflow_step is not None: 1861 req.approval_workflow_step.CopyFrom( 1862 plumbing.convert_approval_workflow_step_to_plumbing( 1863 approval_workflow_step)) 1864 tries = 0 1865 plumbing_response = None 1866 while True: 1867 t = None if deadline is None else deadline - time.time() 1868 try: 1869 plumbing_response = self.stub.Create( 1870 req, 1871 metadata=self.parent.get_metadata( 1872 'ApprovalWorkflowSteps.Create', req), 1873 timeout=t) 1874 except Exception as e: 1875 if self.parent.shouldRetry(tries, e, deadline): 1876 tries += 1 1877 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1878 continue 1879 raise plumbing.convert_error_to_porcelain(e) from e 1880 break 1881 1882 resp = models.ApprovalWorkflowStepCreateResponse() 1883 resp.approval_workflow_step = plumbing.convert_approval_workflow_step_to_porcelain( 1884 plumbing_response.approval_workflow_step) 1885 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1886 plumbing_response.rate_limit) 1887 return resp
Deprecated: Create creates a new approval workflow step.
def
get(self, id, timeout=None)
1889 def get(self, id, timeout=None): 1890 ''' 1891 Deprecated: Get reads one approval workflow step by ID. 1892 ''' 1893 deadline = None if timeout is None else time.time() + timeout 1894 req = ApprovalWorkflowStepGetRequest() 1895 if self.parent.snapshot_datetime is not None: 1896 req.meta.CopyFrom(GetRequestMetadata()) 1897 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1898 1899 req.id = (id) 1900 tries = 0 1901 plumbing_response = None 1902 while True: 1903 t = None if deadline is None else deadline - time.time() 1904 try: 1905 plumbing_response = self.stub.Get( 1906 req, 1907 metadata=self.parent.get_metadata( 1908 'ApprovalWorkflowSteps.Get', req), 1909 timeout=t) 1910 except Exception as e: 1911 if self.parent.shouldRetry(tries, e, deadline): 1912 tries += 1 1913 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1914 continue 1915 raise plumbing.convert_error_to_porcelain(e) from e 1916 break 1917 1918 resp = models.ApprovalWorkflowStepGetResponse() 1919 resp.approval_workflow_step = plumbing.convert_approval_workflow_step_to_porcelain( 1920 plumbing_response.approval_workflow_step) 1921 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1922 plumbing_response.meta) 1923 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1924 plumbing_response.rate_limit) 1925 return resp
Deprecated: Get reads one approval workflow step by ID.
def
delete(self, id, timeout=None)
1927 def delete(self, id, timeout=None): 1928 ''' 1929 Deprecated: Delete deletes an existing approval workflow step. 1930 ''' 1931 deadline = None if timeout is None else time.time() + timeout 1932 req = ApprovalWorkflowStepDeleteRequest() 1933 1934 req.id = (id) 1935 tries = 0 1936 plumbing_response = None 1937 while True: 1938 t = None if deadline is None else deadline - time.time() 1939 try: 1940 plumbing_response = self.stub.Delete( 1941 req, 1942 metadata=self.parent.get_metadata( 1943 'ApprovalWorkflowSteps.Delete', req), 1944 timeout=t) 1945 except Exception as e: 1946 if self.parent.shouldRetry(tries, e, deadline): 1947 tries += 1 1948 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1949 continue 1950 raise plumbing.convert_error_to_porcelain(e) from e 1951 break 1952 1953 resp = models.ApprovalWorkflowStepDeleteResponse() 1954 resp.id = (plumbing_response.id) 1955 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1956 plumbing_response.rate_limit) 1957 return resp
Deprecated: Delete deletes an existing approval workflow step.
def
list(self, filter, *args, timeout=None)
1959 def list(self, filter, *args, timeout=None): 1960 ''' 1961 Deprecated: Lists existing approval workflow steps. 1962 ''' 1963 deadline = None if timeout is None else time.time() + timeout 1964 req = ApprovalWorkflowStepListRequest() 1965 req.meta.CopyFrom(ListRequestMetadata()) 1966 if self.parent.page_limit > 0: 1967 req.meta.limit = self.parent.page_limit 1968 if self.parent.snapshot_datetime is not None: 1969 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1970 1971 req.filter = plumbing.quote_filter_args(filter, *args) 1972 1973 def generator(svc, req): 1974 tries = 0 1975 while True: 1976 t = None if deadline is None else deadline - time.time() 1977 try: 1978 plumbing_response = svc.stub.List( 1979 req, 1980 metadata=svc.parent.get_metadata( 1981 'ApprovalWorkflowSteps.List', req), 1982 timeout=t) 1983 except Exception as e: 1984 if self.parent.shouldRetry(tries, e, deadline): 1985 tries += 1 1986 time.sleep( 1987 self.parent.exponentialBackoff(tries, deadline)) 1988 continue 1989 raise plumbing.convert_error_to_porcelain(e) from e 1990 tries = 0 1991 for plumbing_item in plumbing_response.approval_workflow_steps: 1992 yield plumbing.convert_approval_workflow_step_to_porcelain( 1993 plumbing_item) 1994 if plumbing_response.meta.next_cursor == '': 1995 break 1996 req.meta.cursor = plumbing_response.meta.next_cursor 1997 1998 return generator(self, req)
Deprecated: Lists existing approval workflow steps.
class
SnapshotApprovalWorkflowSteps:
2001class SnapshotApprovalWorkflowSteps: 2002 ''' 2003 SnapshotApprovalWorkflowSteps exposes the read only methods of the ApprovalWorkflowSteps 2004 service for historical queries. 2005 ''' 2006 def __init__(self, approval_workflow_steps): 2007 self.approval_workflow_steps = approval_workflow_steps 2008 2009 def get(self, id, timeout=None): 2010 ''' 2011 Deprecated: Get reads one approval workflow step by ID. 2012 ''' 2013 return self.approval_workflow_steps.get(id, timeout=timeout) 2014 2015 def list(self, filter, *args, timeout=None): 2016 ''' 2017 Deprecated: Lists existing approval workflow steps. 2018 ''' 2019 return self.approval_workflow_steps.list(filter, 2020 *args, 2021 timeout=timeout)
SnapshotApprovalWorkflowSteps exposes the read only methods of the ApprovalWorkflowSteps service for historical queries.
def
get(self, id, timeout=None)
2009 def get(self, id, timeout=None): 2010 ''' 2011 Deprecated: Get reads one approval workflow step by ID. 2012 ''' 2013 return self.approval_workflow_steps.get(id, timeout=timeout)
Deprecated: Get reads one approval workflow step by ID.
def
list(self, filter, *args, timeout=None)
2015 def list(self, filter, *args, timeout=None): 2016 ''' 2017 Deprecated: Lists existing approval workflow steps. 2018 ''' 2019 return self.approval_workflow_steps.list(filter, 2020 *args, 2021 timeout=timeout)
Deprecated: Lists existing approval workflow steps.
class
ApprovalWorkflowStepsHistory:
2024class ApprovalWorkflowStepsHistory: 2025 ''' 2026 ApprovalWorkflowStepsHistory records all changes to the state of an ApprovalWorkflowStep. 2027 See `strongdm.models.ApprovalWorkflowStepHistory`. 2028 ''' 2029 def __init__(self, channel, client): 2030 self.parent = client 2031 self.stub = ApprovalWorkflowStepsHistoryStub(channel) 2032 2033 def list(self, filter, *args, timeout=None): 2034 ''' 2035 List gets a list of ApprovalWorkflowStepHistory records matching a given set of criteria. 2036 ''' 2037 deadline = None if timeout is None else time.time() + timeout 2038 req = ApprovalWorkflowStepHistoryListRequest() 2039 req.meta.CopyFrom(ListRequestMetadata()) 2040 if self.parent.page_limit > 0: 2041 req.meta.limit = self.parent.page_limit 2042 if self.parent.snapshot_datetime is not None: 2043 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2044 2045 req.filter = plumbing.quote_filter_args(filter, *args) 2046 2047 def generator(svc, req): 2048 tries = 0 2049 while True: 2050 t = None if deadline is None else deadline - time.time() 2051 try: 2052 plumbing_response = svc.stub.List( 2053 req, 2054 metadata=svc.parent.get_metadata( 2055 'ApprovalWorkflowStepsHistory.List', req), 2056 timeout=t) 2057 except Exception as e: 2058 if self.parent.shouldRetry(tries, e, deadline): 2059 tries += 1 2060 time.sleep( 2061 self.parent.exponentialBackoff(tries, deadline)) 2062 continue 2063 raise plumbing.convert_error_to_porcelain(e) from e 2064 tries = 0 2065 for plumbing_item in plumbing_response.history: 2066 yield plumbing.convert_approval_workflow_step_history_to_porcelain( 2067 plumbing_item) 2068 if plumbing_response.meta.next_cursor == '': 2069 break 2070 req.meta.cursor = plumbing_response.meta.next_cursor 2071 2072 return generator(self, req)
ApprovalWorkflowStepsHistory records all changes to the state of an ApprovalWorkflowStep.
See strongdm.models.ApprovalWorkflowStepHistory.
def
list(self, filter, *args, timeout=None)
2033 def list(self, filter, *args, timeout=None): 2034 ''' 2035 List gets a list of ApprovalWorkflowStepHistory records matching a given set of criteria. 2036 ''' 2037 deadline = None if timeout is None else time.time() + timeout 2038 req = ApprovalWorkflowStepHistoryListRequest() 2039 req.meta.CopyFrom(ListRequestMetadata()) 2040 if self.parent.page_limit > 0: 2041 req.meta.limit = self.parent.page_limit 2042 if self.parent.snapshot_datetime is not None: 2043 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2044 2045 req.filter = plumbing.quote_filter_args(filter, *args) 2046 2047 def generator(svc, req): 2048 tries = 0 2049 while True: 2050 t = None if deadline is None else deadline - time.time() 2051 try: 2052 plumbing_response = svc.stub.List( 2053 req, 2054 metadata=svc.parent.get_metadata( 2055 'ApprovalWorkflowStepsHistory.List', req), 2056 timeout=t) 2057 except Exception as e: 2058 if self.parent.shouldRetry(tries, e, deadline): 2059 tries += 1 2060 time.sleep( 2061 self.parent.exponentialBackoff(tries, deadline)) 2062 continue 2063 raise plumbing.convert_error_to_porcelain(e) from e 2064 tries = 0 2065 for plumbing_item in plumbing_response.history: 2066 yield plumbing.convert_approval_workflow_step_history_to_porcelain( 2067 plumbing_item) 2068 if plumbing_response.meta.next_cursor == '': 2069 break 2070 req.meta.cursor = plumbing_response.meta.next_cursor 2071 2072 return generator(self, req)
List gets a list of ApprovalWorkflowStepHistory records matching a given set of criteria.
class
ApprovalWorkflows:
2075class ApprovalWorkflows: 2076 ''' 2077 ApprovalWorkflows are the mechanism by which requests for access can be viewed by authorized 2078 approvers and be approved or denied. 2079 See `strongdm.models.ApprovalWorkflow`. 2080 ''' 2081 def __init__(self, channel, client): 2082 self.parent = client 2083 self.stub = ApprovalWorkflowsStub(channel) 2084 2085 def create(self, approval_workflow, timeout=None): 2086 ''' 2087 Create creates a new approval workflow and requires a name and approval mode for the approval workflow. 2088 ''' 2089 deadline = None if timeout is None else time.time() + timeout 2090 req = ApprovalWorkflowCreateRequest() 2091 2092 if approval_workflow is not None: 2093 req.approval_workflow.CopyFrom( 2094 plumbing.convert_approval_workflow_to_plumbing( 2095 approval_workflow)) 2096 tries = 0 2097 plumbing_response = None 2098 while True: 2099 t = None if deadline is None else deadline - time.time() 2100 try: 2101 plumbing_response = self.stub.Create( 2102 req, 2103 metadata=self.parent.get_metadata( 2104 'ApprovalWorkflows.Create', req), 2105 timeout=t) 2106 except Exception as e: 2107 if self.parent.shouldRetry(tries, e, deadline): 2108 tries += 1 2109 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2110 continue 2111 raise plumbing.convert_error_to_porcelain(e) from e 2112 break 2113 2114 resp = models.ApprovalWorkflowCreateResponse() 2115 resp.approval_workflow = plumbing.convert_approval_workflow_to_porcelain( 2116 plumbing_response.approval_workflow) 2117 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2118 plumbing_response.rate_limit) 2119 return resp 2120 2121 def get(self, id, timeout=None): 2122 ''' 2123 Get reads one approval workflow by ID. 2124 ''' 2125 deadline = None if timeout is None else time.time() + timeout 2126 req = ApprovalWorkflowGetRequest() 2127 if self.parent.snapshot_datetime is not None: 2128 req.meta.CopyFrom(GetRequestMetadata()) 2129 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2130 2131 req.id = (id) 2132 tries = 0 2133 plumbing_response = None 2134 while True: 2135 t = None if deadline is None else deadline - time.time() 2136 try: 2137 plumbing_response = self.stub.Get( 2138 req, 2139 metadata=self.parent.get_metadata('ApprovalWorkflows.Get', 2140 req), 2141 timeout=t) 2142 except Exception as e: 2143 if self.parent.shouldRetry(tries, e, deadline): 2144 tries += 1 2145 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2146 continue 2147 raise plumbing.convert_error_to_porcelain(e) from e 2148 break 2149 2150 resp = models.ApprovalWorkflowGetResponse() 2151 resp.approval_workflow = plumbing.convert_approval_workflow_to_porcelain( 2152 plumbing_response.approval_workflow) 2153 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2154 plumbing_response.meta) 2155 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2156 plumbing_response.rate_limit) 2157 return resp 2158 2159 def delete(self, id, timeout=None): 2160 ''' 2161 Delete deletes an existing approval workflow. 2162 ''' 2163 deadline = None if timeout is None else time.time() + timeout 2164 req = ApprovalWorkflowDeleteRequest() 2165 2166 req.id = (id) 2167 tries = 0 2168 plumbing_response = None 2169 while True: 2170 t = None if deadline is None else deadline - time.time() 2171 try: 2172 plumbing_response = self.stub.Delete( 2173 req, 2174 metadata=self.parent.get_metadata( 2175 'ApprovalWorkflows.Delete', req), 2176 timeout=t) 2177 except Exception as e: 2178 if self.parent.shouldRetry(tries, e, deadline): 2179 tries += 1 2180 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2181 continue 2182 raise plumbing.convert_error_to_porcelain(e) from e 2183 break 2184 2185 resp = models.ApprovalWorkflowDeleteResponse() 2186 resp.id = (plumbing_response.id) 2187 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2188 plumbing_response.rate_limit) 2189 return resp 2190 2191 def update(self, approval_workflow, timeout=None): 2192 ''' 2193 Update updates an existing approval workflow. 2194 ''' 2195 deadline = None if timeout is None else time.time() + timeout 2196 req = ApprovalWorkflowUpdateRequest() 2197 2198 if approval_workflow is not None: 2199 req.approval_workflow.CopyFrom( 2200 plumbing.convert_approval_workflow_to_plumbing( 2201 approval_workflow)) 2202 tries = 0 2203 plumbing_response = None 2204 while True: 2205 t = None if deadline is None else deadline - time.time() 2206 try: 2207 plumbing_response = self.stub.Update( 2208 req, 2209 metadata=self.parent.get_metadata( 2210 'ApprovalWorkflows.Update', req), 2211 timeout=t) 2212 except Exception as e: 2213 if self.parent.shouldRetry(tries, e, deadline): 2214 tries += 1 2215 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2216 continue 2217 raise plumbing.convert_error_to_porcelain(e) from e 2218 break 2219 2220 resp = models.ApprovalWorkflowUpdateResponse() 2221 resp.approval_workflow = plumbing.convert_approval_workflow_to_porcelain( 2222 plumbing_response.approval_workflow) 2223 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2224 plumbing_response.rate_limit) 2225 return resp 2226 2227 def list(self, filter, *args, timeout=None): 2228 ''' 2229 Lists existing approval workflows. 2230 ''' 2231 deadline = None if timeout is None else time.time() + timeout 2232 req = ApprovalWorkflowListRequest() 2233 req.meta.CopyFrom(ListRequestMetadata()) 2234 if self.parent.page_limit > 0: 2235 req.meta.limit = self.parent.page_limit 2236 if self.parent.snapshot_datetime is not None: 2237 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2238 2239 req.filter = plumbing.quote_filter_args(filter, *args) 2240 2241 def generator(svc, req): 2242 tries = 0 2243 while True: 2244 t = None if deadline is None else deadline - time.time() 2245 try: 2246 plumbing_response = svc.stub.List( 2247 req, 2248 metadata=svc.parent.get_metadata( 2249 'ApprovalWorkflows.List', req), 2250 timeout=t) 2251 except Exception as e: 2252 if self.parent.shouldRetry(tries, e, deadline): 2253 tries += 1 2254 time.sleep( 2255 self.parent.exponentialBackoff(tries, deadline)) 2256 continue 2257 raise plumbing.convert_error_to_porcelain(e) from e 2258 tries = 0 2259 for plumbing_item in plumbing_response.approval_workflows: 2260 yield plumbing.convert_approval_workflow_to_porcelain( 2261 plumbing_item) 2262 if plumbing_response.meta.next_cursor == '': 2263 break 2264 req.meta.cursor = plumbing_response.meta.next_cursor 2265 2266 return generator(self, req)
ApprovalWorkflows are the mechanism by which requests for access can be viewed by authorized
approvers and be approved or denied.
See strongdm.models.ApprovalWorkflow.
def
create(self, approval_workflow, timeout=None)
2085 def create(self, approval_workflow, timeout=None): 2086 ''' 2087 Create creates a new approval workflow and requires a name and approval mode for the approval workflow. 2088 ''' 2089 deadline = None if timeout is None else time.time() + timeout 2090 req = ApprovalWorkflowCreateRequest() 2091 2092 if approval_workflow is not None: 2093 req.approval_workflow.CopyFrom( 2094 plumbing.convert_approval_workflow_to_plumbing( 2095 approval_workflow)) 2096 tries = 0 2097 plumbing_response = None 2098 while True: 2099 t = None if deadline is None else deadline - time.time() 2100 try: 2101 plumbing_response = self.stub.Create( 2102 req, 2103 metadata=self.parent.get_metadata( 2104 'ApprovalWorkflows.Create', req), 2105 timeout=t) 2106 except Exception as e: 2107 if self.parent.shouldRetry(tries, e, deadline): 2108 tries += 1 2109 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2110 continue 2111 raise plumbing.convert_error_to_porcelain(e) from e 2112 break 2113 2114 resp = models.ApprovalWorkflowCreateResponse() 2115 resp.approval_workflow = plumbing.convert_approval_workflow_to_porcelain( 2116 plumbing_response.approval_workflow) 2117 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2118 plumbing_response.rate_limit) 2119 return resp
Create creates a new approval workflow and requires a name and approval mode for the approval workflow.
def
get(self, id, timeout=None)
2121 def get(self, id, timeout=None): 2122 ''' 2123 Get reads one approval workflow by ID. 2124 ''' 2125 deadline = None if timeout is None else time.time() + timeout 2126 req = ApprovalWorkflowGetRequest() 2127 if self.parent.snapshot_datetime is not None: 2128 req.meta.CopyFrom(GetRequestMetadata()) 2129 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2130 2131 req.id = (id) 2132 tries = 0 2133 plumbing_response = None 2134 while True: 2135 t = None if deadline is None else deadline - time.time() 2136 try: 2137 plumbing_response = self.stub.Get( 2138 req, 2139 metadata=self.parent.get_metadata('ApprovalWorkflows.Get', 2140 req), 2141 timeout=t) 2142 except Exception as e: 2143 if self.parent.shouldRetry(tries, e, deadline): 2144 tries += 1 2145 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2146 continue 2147 raise plumbing.convert_error_to_porcelain(e) from e 2148 break 2149 2150 resp = models.ApprovalWorkflowGetResponse() 2151 resp.approval_workflow = plumbing.convert_approval_workflow_to_porcelain( 2152 plumbing_response.approval_workflow) 2153 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2154 plumbing_response.meta) 2155 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2156 plumbing_response.rate_limit) 2157 return resp
Get reads one approval workflow by ID.
def
delete(self, id, timeout=None)
2159 def delete(self, id, timeout=None): 2160 ''' 2161 Delete deletes an existing approval workflow. 2162 ''' 2163 deadline = None if timeout is None else time.time() + timeout 2164 req = ApprovalWorkflowDeleteRequest() 2165 2166 req.id = (id) 2167 tries = 0 2168 plumbing_response = None 2169 while True: 2170 t = None if deadline is None else deadline - time.time() 2171 try: 2172 plumbing_response = self.stub.Delete( 2173 req, 2174 metadata=self.parent.get_metadata( 2175 'ApprovalWorkflows.Delete', req), 2176 timeout=t) 2177 except Exception as e: 2178 if self.parent.shouldRetry(tries, e, deadline): 2179 tries += 1 2180 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2181 continue 2182 raise plumbing.convert_error_to_porcelain(e) from e 2183 break 2184 2185 resp = models.ApprovalWorkflowDeleteResponse() 2186 resp.id = (plumbing_response.id) 2187 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2188 plumbing_response.rate_limit) 2189 return resp
Delete deletes an existing approval workflow.
def
update(self, approval_workflow, timeout=None)
2191 def update(self, approval_workflow, timeout=None): 2192 ''' 2193 Update updates an existing approval workflow. 2194 ''' 2195 deadline = None if timeout is None else time.time() + timeout 2196 req = ApprovalWorkflowUpdateRequest() 2197 2198 if approval_workflow is not None: 2199 req.approval_workflow.CopyFrom( 2200 plumbing.convert_approval_workflow_to_plumbing( 2201 approval_workflow)) 2202 tries = 0 2203 plumbing_response = None 2204 while True: 2205 t = None if deadline is None else deadline - time.time() 2206 try: 2207 plumbing_response = self.stub.Update( 2208 req, 2209 metadata=self.parent.get_metadata( 2210 'ApprovalWorkflows.Update', req), 2211 timeout=t) 2212 except Exception as e: 2213 if self.parent.shouldRetry(tries, e, deadline): 2214 tries += 1 2215 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2216 continue 2217 raise plumbing.convert_error_to_porcelain(e) from e 2218 break 2219 2220 resp = models.ApprovalWorkflowUpdateResponse() 2221 resp.approval_workflow = plumbing.convert_approval_workflow_to_porcelain( 2222 plumbing_response.approval_workflow) 2223 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2224 plumbing_response.rate_limit) 2225 return resp
Update updates an existing approval workflow.
def
list(self, filter, *args, timeout=None)
2227 def list(self, filter, *args, timeout=None): 2228 ''' 2229 Lists existing approval workflows. 2230 ''' 2231 deadline = None if timeout is None else time.time() + timeout 2232 req = ApprovalWorkflowListRequest() 2233 req.meta.CopyFrom(ListRequestMetadata()) 2234 if self.parent.page_limit > 0: 2235 req.meta.limit = self.parent.page_limit 2236 if self.parent.snapshot_datetime is not None: 2237 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2238 2239 req.filter = plumbing.quote_filter_args(filter, *args) 2240 2241 def generator(svc, req): 2242 tries = 0 2243 while True: 2244 t = None if deadline is None else deadline - time.time() 2245 try: 2246 plumbing_response = svc.stub.List( 2247 req, 2248 metadata=svc.parent.get_metadata( 2249 'ApprovalWorkflows.List', req), 2250 timeout=t) 2251 except Exception as e: 2252 if self.parent.shouldRetry(tries, e, deadline): 2253 tries += 1 2254 time.sleep( 2255 self.parent.exponentialBackoff(tries, deadline)) 2256 continue 2257 raise plumbing.convert_error_to_porcelain(e) from e 2258 tries = 0 2259 for plumbing_item in plumbing_response.approval_workflows: 2260 yield plumbing.convert_approval_workflow_to_porcelain( 2261 plumbing_item) 2262 if plumbing_response.meta.next_cursor == '': 2263 break 2264 req.meta.cursor = plumbing_response.meta.next_cursor 2265 2266 return generator(self, req)
Lists existing approval workflows.
class
SnapshotApprovalWorkflows:
2269class SnapshotApprovalWorkflows: 2270 ''' 2271 SnapshotApprovalWorkflows exposes the read only methods of the ApprovalWorkflows 2272 service for historical queries. 2273 ''' 2274 def __init__(self, approval_workflows): 2275 self.approval_workflows = approval_workflows 2276 2277 def get(self, id, timeout=None): 2278 ''' 2279 Get reads one approval workflow by ID. 2280 ''' 2281 return self.approval_workflows.get(id, timeout=timeout) 2282 2283 def list(self, filter, *args, timeout=None): 2284 ''' 2285 Lists existing approval workflows. 2286 ''' 2287 return self.approval_workflows.list(filter, *args, timeout=timeout)
SnapshotApprovalWorkflows exposes the read only methods of the ApprovalWorkflows service for historical queries.
class
ApprovalWorkflowsHistory:
2290class ApprovalWorkflowsHistory: 2291 ''' 2292 ApprovalWorkflowsHistory records all changes to the state of an ApprovalWorkflow. 2293 See `strongdm.models.ApprovalWorkflowHistory`. 2294 ''' 2295 def __init__(self, channel, client): 2296 self.parent = client 2297 self.stub = ApprovalWorkflowsHistoryStub(channel) 2298 2299 def list(self, filter, *args, timeout=None): 2300 ''' 2301 List gets a list of ApprovalWorkflowHistory records matching a given set of criteria. 2302 ''' 2303 deadline = None if timeout is None else time.time() + timeout 2304 req = ApprovalWorkflowHistoryListRequest() 2305 req.meta.CopyFrom(ListRequestMetadata()) 2306 if self.parent.page_limit > 0: 2307 req.meta.limit = self.parent.page_limit 2308 if self.parent.snapshot_datetime is not None: 2309 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2310 2311 req.filter = plumbing.quote_filter_args(filter, *args) 2312 2313 def generator(svc, req): 2314 tries = 0 2315 while True: 2316 t = None if deadline is None else deadline - time.time() 2317 try: 2318 plumbing_response = svc.stub.List( 2319 req, 2320 metadata=svc.parent.get_metadata( 2321 'ApprovalWorkflowsHistory.List', req), 2322 timeout=t) 2323 except Exception as e: 2324 if self.parent.shouldRetry(tries, e, deadline): 2325 tries += 1 2326 time.sleep( 2327 self.parent.exponentialBackoff(tries, deadline)) 2328 continue 2329 raise plumbing.convert_error_to_porcelain(e) from e 2330 tries = 0 2331 for plumbing_item in plumbing_response.history: 2332 yield plumbing.convert_approval_workflow_history_to_porcelain( 2333 plumbing_item) 2334 if plumbing_response.meta.next_cursor == '': 2335 break 2336 req.meta.cursor = plumbing_response.meta.next_cursor 2337 2338 return generator(self, req)
ApprovalWorkflowsHistory records all changes to the state of an ApprovalWorkflow.
See strongdm.models.ApprovalWorkflowHistory.
def
list(self, filter, *args, timeout=None)
2299 def list(self, filter, *args, timeout=None): 2300 ''' 2301 List gets a list of ApprovalWorkflowHistory records matching a given set of criteria. 2302 ''' 2303 deadline = None if timeout is None else time.time() + timeout 2304 req = ApprovalWorkflowHistoryListRequest() 2305 req.meta.CopyFrom(ListRequestMetadata()) 2306 if self.parent.page_limit > 0: 2307 req.meta.limit = self.parent.page_limit 2308 if self.parent.snapshot_datetime is not None: 2309 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2310 2311 req.filter = plumbing.quote_filter_args(filter, *args) 2312 2313 def generator(svc, req): 2314 tries = 0 2315 while True: 2316 t = None if deadline is None else deadline - time.time() 2317 try: 2318 plumbing_response = svc.stub.List( 2319 req, 2320 metadata=svc.parent.get_metadata( 2321 'ApprovalWorkflowsHistory.List', req), 2322 timeout=t) 2323 except Exception as e: 2324 if self.parent.shouldRetry(tries, e, deadline): 2325 tries += 1 2326 time.sleep( 2327 self.parent.exponentialBackoff(tries, deadline)) 2328 continue 2329 raise plumbing.convert_error_to_porcelain(e) from e 2330 tries = 0 2331 for plumbing_item in plumbing_response.history: 2332 yield plumbing.convert_approval_workflow_history_to_porcelain( 2333 plumbing_item) 2334 if plumbing_response.meta.next_cursor == '': 2335 break 2336 req.meta.cursor = plumbing_response.meta.next_cursor 2337 2338 return generator(self, req)
List gets a list of ApprovalWorkflowHistory records matching a given set of criteria.
class
ControlPanel:
2341class ControlPanel: 2342 ''' 2343 ControlPanel contains all administrative controls. 2344 ''' 2345 def __init__(self, channel, client): 2346 self.parent = client 2347 self.stub = ControlPanelStub(channel) 2348 2349 def get_sshca_public_key(self, timeout=None): 2350 ''' 2351 GetSSHCAPublicKey retrieves the SSH CA public key. 2352 ''' 2353 deadline = None if timeout is None else time.time() + timeout 2354 req = ControlPanelGetSSHCAPublicKeyRequest() 2355 2356 tries = 0 2357 plumbing_response = None 2358 while True: 2359 t = None if deadline is None else deadline - time.time() 2360 try: 2361 plumbing_response = self.stub.GetSSHCAPublicKey( 2362 req, 2363 metadata=self.parent.get_metadata( 2364 'ControlPanel.GetSSHCAPublicKey', req), 2365 timeout=t) 2366 except Exception as e: 2367 if self.parent.shouldRetry(tries, e, deadline): 2368 tries += 1 2369 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2370 continue 2371 raise plumbing.convert_error_to_porcelain(e) from e 2372 break 2373 2374 resp = models.ControlPanelGetSSHCAPublicKeyResponse() 2375 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2376 plumbing_response.meta) 2377 resp.public_key = (plumbing_response.public_key) 2378 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2379 plumbing_response.rate_limit) 2380 return resp 2381 2382 def get_rdpca_public_key(self, timeout=None): 2383 ''' 2384 GetRDPCAPublicKey retrieves the RDP CA public key. 2385 ''' 2386 deadline = None if timeout is None else time.time() + timeout 2387 req = ControlPanelGetRDPCAPublicKeyRequest() 2388 2389 tries = 0 2390 plumbing_response = None 2391 while True: 2392 t = None if deadline is None else deadline - time.time() 2393 try: 2394 plumbing_response = self.stub.GetRDPCAPublicKey( 2395 req, 2396 metadata=self.parent.get_metadata( 2397 'ControlPanel.GetRDPCAPublicKey', req), 2398 timeout=t) 2399 except Exception as e: 2400 if self.parent.shouldRetry(tries, e, deadline): 2401 tries += 1 2402 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2403 continue 2404 raise plumbing.convert_error_to_porcelain(e) from e 2405 break 2406 2407 resp = models.ControlPanelGetRDPCAPublicKeyResponse() 2408 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2409 plumbing_response.meta) 2410 resp.public_key = (plumbing_response.public_key) 2411 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2412 plumbing_response.rate_limit) 2413 return resp 2414 2415 def get_org_url_info(self, timeout=None): 2416 ''' 2417 GetOrgURLInfo retrieves URL configuration for the organization. 2418 This includes the base URL, website subdomain, OIDC issuer URL, and SAML metadata URL. 2419 ''' 2420 deadline = None if timeout is None else time.time() + timeout 2421 req = ControlPanelGetOrgURLInfoRequest() 2422 2423 tries = 0 2424 plumbing_response = None 2425 while True: 2426 t = None if deadline is None else deadline - time.time() 2427 try: 2428 plumbing_response = self.stub.GetOrgURLInfo( 2429 req, 2430 metadata=self.parent.get_metadata( 2431 'ControlPanel.GetOrgURLInfo', req), 2432 timeout=t) 2433 except Exception as e: 2434 if self.parent.shouldRetry(tries, e, deadline): 2435 tries += 1 2436 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2437 continue 2438 raise plumbing.convert_error_to_porcelain(e) from e 2439 break 2440 2441 resp = models.ControlPanelGetOrgURLInfoResponse() 2442 resp.base_url = (plumbing_response.base_url) 2443 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2444 plumbing_response.meta) 2445 resp.oidc_issuer_url = (plumbing_response.oidc_issuer_url) 2446 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2447 plumbing_response.rate_limit) 2448 resp.saml_metadata_url = (plumbing_response.saml_metadata_url) 2449 resp.websites_subdomain = (plumbing_response.websites_subdomain) 2450 return resp 2451 2452 def verify_jwt(self, token, timeout=None): 2453 ''' 2454 VerifyJWT reports whether the given JWT token (x-sdm-token) is valid. 2455 ''' 2456 deadline = None if timeout is None else time.time() + timeout 2457 req = ControlPanelVerifyJWTRequest() 2458 2459 req.token = (token) 2460 tries = 0 2461 plumbing_response = None 2462 while True: 2463 t = None if deadline is None else deadline - time.time() 2464 try: 2465 plumbing_response = self.stub.VerifyJWT( 2466 req, 2467 metadata=self.parent.get_metadata('ControlPanel.VerifyJWT', 2468 req), 2469 timeout=t) 2470 except Exception as e: 2471 if self.parent.shouldRetry(tries, e, deadline): 2472 tries += 1 2473 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2474 continue 2475 raise plumbing.convert_error_to_porcelain(e) from e 2476 break 2477 2478 resp = models.ControlPanelVerifyJWTResponse() 2479 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2480 plumbing_response.meta) 2481 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2482 plumbing_response.rate_limit) 2483 resp.valid = (plumbing_response.valid) 2484 return resp
ControlPanel contains all administrative controls.
def
get_sshca_public_key(self, timeout=None)
2349 def get_sshca_public_key(self, timeout=None): 2350 ''' 2351 GetSSHCAPublicKey retrieves the SSH CA public key. 2352 ''' 2353 deadline = None if timeout is None else time.time() + timeout 2354 req = ControlPanelGetSSHCAPublicKeyRequest() 2355 2356 tries = 0 2357 plumbing_response = None 2358 while True: 2359 t = None if deadline is None else deadline - time.time() 2360 try: 2361 plumbing_response = self.stub.GetSSHCAPublicKey( 2362 req, 2363 metadata=self.parent.get_metadata( 2364 'ControlPanel.GetSSHCAPublicKey', req), 2365 timeout=t) 2366 except Exception as e: 2367 if self.parent.shouldRetry(tries, e, deadline): 2368 tries += 1 2369 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2370 continue 2371 raise plumbing.convert_error_to_porcelain(e) from e 2372 break 2373 2374 resp = models.ControlPanelGetSSHCAPublicKeyResponse() 2375 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2376 plumbing_response.meta) 2377 resp.public_key = (plumbing_response.public_key) 2378 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2379 plumbing_response.rate_limit) 2380 return resp
GetSSHCAPublicKey retrieves the SSH CA public key.
def
get_rdpca_public_key(self, timeout=None)
2382 def get_rdpca_public_key(self, timeout=None): 2383 ''' 2384 GetRDPCAPublicKey retrieves the RDP CA public key. 2385 ''' 2386 deadline = None if timeout is None else time.time() + timeout 2387 req = ControlPanelGetRDPCAPublicKeyRequest() 2388 2389 tries = 0 2390 plumbing_response = None 2391 while True: 2392 t = None if deadline is None else deadline - time.time() 2393 try: 2394 plumbing_response = self.stub.GetRDPCAPublicKey( 2395 req, 2396 metadata=self.parent.get_metadata( 2397 'ControlPanel.GetRDPCAPublicKey', req), 2398 timeout=t) 2399 except Exception as e: 2400 if self.parent.shouldRetry(tries, e, deadline): 2401 tries += 1 2402 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2403 continue 2404 raise plumbing.convert_error_to_porcelain(e) from e 2405 break 2406 2407 resp = models.ControlPanelGetRDPCAPublicKeyResponse() 2408 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2409 plumbing_response.meta) 2410 resp.public_key = (plumbing_response.public_key) 2411 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2412 plumbing_response.rate_limit) 2413 return resp
GetRDPCAPublicKey retrieves the RDP CA public key.
def
get_org_url_info(self, timeout=None)
2415 def get_org_url_info(self, timeout=None): 2416 ''' 2417 GetOrgURLInfo retrieves URL configuration for the organization. 2418 This includes the base URL, website subdomain, OIDC issuer URL, and SAML metadata URL. 2419 ''' 2420 deadline = None if timeout is None else time.time() + timeout 2421 req = ControlPanelGetOrgURLInfoRequest() 2422 2423 tries = 0 2424 plumbing_response = None 2425 while True: 2426 t = None if deadline is None else deadline - time.time() 2427 try: 2428 plumbing_response = self.stub.GetOrgURLInfo( 2429 req, 2430 metadata=self.parent.get_metadata( 2431 'ControlPanel.GetOrgURLInfo', req), 2432 timeout=t) 2433 except Exception as e: 2434 if self.parent.shouldRetry(tries, e, deadline): 2435 tries += 1 2436 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2437 continue 2438 raise plumbing.convert_error_to_porcelain(e) from e 2439 break 2440 2441 resp = models.ControlPanelGetOrgURLInfoResponse() 2442 resp.base_url = (plumbing_response.base_url) 2443 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2444 plumbing_response.meta) 2445 resp.oidc_issuer_url = (plumbing_response.oidc_issuer_url) 2446 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2447 plumbing_response.rate_limit) 2448 resp.saml_metadata_url = (plumbing_response.saml_metadata_url) 2449 resp.websites_subdomain = (plumbing_response.websites_subdomain) 2450 return resp
GetOrgURLInfo retrieves URL configuration for the organization. This includes the base URL, website subdomain, OIDC issuer URL, and SAML metadata URL.
def
verify_jwt(self, token, timeout=None)
2452 def verify_jwt(self, token, timeout=None): 2453 ''' 2454 VerifyJWT reports whether the given JWT token (x-sdm-token) is valid. 2455 ''' 2456 deadline = None if timeout is None else time.time() + timeout 2457 req = ControlPanelVerifyJWTRequest() 2458 2459 req.token = (token) 2460 tries = 0 2461 plumbing_response = None 2462 while True: 2463 t = None if deadline is None else deadline - time.time() 2464 try: 2465 plumbing_response = self.stub.VerifyJWT( 2466 req, 2467 metadata=self.parent.get_metadata('ControlPanel.VerifyJWT', 2468 req), 2469 timeout=t) 2470 except Exception as e: 2471 if self.parent.shouldRetry(tries, e, deadline): 2472 tries += 1 2473 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2474 continue 2475 raise plumbing.convert_error_to_porcelain(e) from e 2476 break 2477 2478 resp = models.ControlPanelVerifyJWTResponse() 2479 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2480 plumbing_response.meta) 2481 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2482 plumbing_response.rate_limit) 2483 resp.valid = (plumbing_response.valid) 2484 return resp
VerifyJWT reports whether the given JWT token (x-sdm-token) is valid.
class
DiscoveryConnectors:
2487class DiscoveryConnectors: 2488 ''' 2489 A Discovery Connector is a configuration object for performing Resource 2490 Scans in remote systems such as AWS, GCP, Azure, and other systems. 2491 See: 2492 `strongdm.models.AWSConnector` 2493 `strongdm.models.AzureConnector` 2494 `strongdm.models.GCPConnector` 2495 ''' 2496 def __init__(self, channel, client): 2497 self.parent = client 2498 self.stub = DiscoveryConnectorsStub(channel) 2499 2500 def create(self, connector, timeout=None): 2501 ''' 2502 Create adds a new Connector. 2503 ''' 2504 deadline = None if timeout is None else time.time() + timeout 2505 req = ConnectorCreateRequest() 2506 2507 if connector is not None: 2508 req.connector.CopyFrom( 2509 plumbing.convert_connector_to_plumbing(connector)) 2510 tries = 0 2511 plumbing_response = None 2512 while True: 2513 t = None if deadline is None else deadline - time.time() 2514 try: 2515 plumbing_response = self.stub.Create( 2516 req, 2517 metadata=self.parent.get_metadata( 2518 'DiscoveryConnectors.Create', req), 2519 timeout=t) 2520 except Exception as e: 2521 if self.parent.shouldRetry(tries, e, deadline): 2522 tries += 1 2523 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2524 continue 2525 raise plumbing.convert_error_to_porcelain(e) from e 2526 break 2527 2528 resp = models.ConnectorCreateResponse() 2529 resp.connector = plumbing.convert_connector_to_porcelain( 2530 plumbing_response.connector) 2531 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2532 plumbing_response.rate_limit) 2533 return resp 2534 2535 def get(self, id, timeout=None): 2536 ''' 2537 Get reads one Connector by ID 2538 ''' 2539 deadline = None if timeout is None else time.time() + timeout 2540 req = ConnectorGetRequest() 2541 if self.parent.snapshot_datetime is not None: 2542 req.meta.CopyFrom(GetRequestMetadata()) 2543 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2544 2545 req.id = (id) 2546 tries = 0 2547 plumbing_response = None 2548 while True: 2549 t = None if deadline is None else deadline - time.time() 2550 try: 2551 plumbing_response = self.stub.Get( 2552 req, 2553 metadata=self.parent.get_metadata( 2554 'DiscoveryConnectors.Get', req), 2555 timeout=t) 2556 except Exception as e: 2557 if self.parent.shouldRetry(tries, e, deadline): 2558 tries += 1 2559 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2560 continue 2561 raise plumbing.convert_error_to_porcelain(e) from e 2562 break 2563 2564 resp = models.ConnectorGetResponse() 2565 resp.connector = plumbing.convert_connector_to_porcelain( 2566 plumbing_response.connector) 2567 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2568 plumbing_response.meta) 2569 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2570 plumbing_response.rate_limit) 2571 return resp 2572 2573 def update(self, connector, timeout=None): 2574 ''' 2575 Update replaces all the fields of a Connector by ID. 2576 ''' 2577 deadline = None if timeout is None else time.time() + timeout 2578 req = ConnectorUpdateRequest() 2579 2580 if connector is not None: 2581 req.connector.CopyFrom( 2582 plumbing.convert_connector_to_plumbing(connector)) 2583 tries = 0 2584 plumbing_response = None 2585 while True: 2586 t = None if deadline is None else deadline - time.time() 2587 try: 2588 plumbing_response = self.stub.Update( 2589 req, 2590 metadata=self.parent.get_metadata( 2591 'DiscoveryConnectors.Update', req), 2592 timeout=t) 2593 except Exception as e: 2594 if self.parent.shouldRetry(tries, e, deadline): 2595 tries += 1 2596 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2597 continue 2598 raise plumbing.convert_error_to_porcelain(e) from e 2599 break 2600 2601 resp = models.ConnectorUpdateResponse() 2602 resp.connector = plumbing.convert_connector_to_porcelain( 2603 plumbing_response.connector) 2604 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2605 plumbing_response.rate_limit) 2606 return resp 2607 2608 def delete(self, id, timeout=None): 2609 ''' 2610 Delete removes a Connector by ID. 2611 ''' 2612 deadline = None if timeout is None else time.time() + timeout 2613 req = ConnectorDeleteRequest() 2614 2615 req.id = (id) 2616 tries = 0 2617 plumbing_response = None 2618 while True: 2619 t = None if deadline is None else deadline - time.time() 2620 try: 2621 plumbing_response = self.stub.Delete( 2622 req, 2623 metadata=self.parent.get_metadata( 2624 'DiscoveryConnectors.Delete', req), 2625 timeout=t) 2626 except Exception as e: 2627 if self.parent.shouldRetry(tries, e, deadline): 2628 tries += 1 2629 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2630 continue 2631 raise plumbing.convert_error_to_porcelain(e) from e 2632 break 2633 2634 resp = models.ConnectorDeleteResponse() 2635 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 2636 plumbing_response.meta) 2637 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2638 plumbing_response.rate_limit) 2639 return resp 2640 2641 def list(self, filter, *args, timeout=None): 2642 ''' 2643 List gets a list of Connectors matching a given set of criteria. 2644 ''' 2645 deadline = None if timeout is None else time.time() + timeout 2646 req = ConnectorListRequest() 2647 req.meta.CopyFrom(ListRequestMetadata()) 2648 if self.parent.page_limit > 0: 2649 req.meta.limit = self.parent.page_limit 2650 if self.parent.snapshot_datetime is not None: 2651 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2652 2653 req.filter = plumbing.quote_filter_args(filter, *args) 2654 2655 def generator(svc, req): 2656 tries = 0 2657 while True: 2658 t = None if deadline is None else deadline - time.time() 2659 try: 2660 plumbing_response = svc.stub.List( 2661 req, 2662 metadata=svc.parent.get_metadata( 2663 'DiscoveryConnectors.List', req), 2664 timeout=t) 2665 except Exception as e: 2666 if self.parent.shouldRetry(tries, e, deadline): 2667 tries += 1 2668 time.sleep( 2669 self.parent.exponentialBackoff(tries, deadline)) 2670 continue 2671 raise plumbing.convert_error_to_porcelain(e) from e 2672 tries = 0 2673 for plumbing_item in plumbing_response.connectors: 2674 yield plumbing.convert_connector_to_porcelain( 2675 plumbing_item) 2676 if plumbing_response.meta.next_cursor == '': 2677 break 2678 req.meta.cursor = plumbing_response.meta.next_cursor 2679 2680 return generator(self, req)
A Discovery Connector is a configuration object for performing Resource
Scans in remote systems such as AWS, GCP, Azure, and other systems.
See:
strongdm.models.AWSConnector
strongdm.models.AzureConnector
strongdm.models.GCPConnector
def
create(self, connector, timeout=None)
2500 def create(self, connector, timeout=None): 2501 ''' 2502 Create adds a new Connector. 2503 ''' 2504 deadline = None if timeout is None else time.time() + timeout 2505 req = ConnectorCreateRequest() 2506 2507 if connector is not None: 2508 req.connector.CopyFrom( 2509 plumbing.convert_connector_to_plumbing(connector)) 2510 tries = 0 2511 plumbing_response = None 2512 while True: 2513 t = None if deadline is None else deadline - time.time() 2514 try: 2515 plumbing_response = self.stub.Create( 2516 req, 2517 metadata=self.parent.get_metadata( 2518 'DiscoveryConnectors.Create', req), 2519 timeout=t) 2520 except Exception as e: 2521 if self.parent.shouldRetry(tries, e, deadline): 2522 tries += 1 2523 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2524 continue 2525 raise plumbing.convert_error_to_porcelain(e) from e 2526 break 2527 2528 resp = models.ConnectorCreateResponse() 2529 resp.connector = plumbing.convert_connector_to_porcelain( 2530 plumbing_response.connector) 2531 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2532 plumbing_response.rate_limit) 2533 return resp
Create adds a new Connector.
def
get(self, id, timeout=None)
2535 def get(self, id, timeout=None): 2536 ''' 2537 Get reads one Connector by ID 2538 ''' 2539 deadline = None if timeout is None else time.time() + timeout 2540 req = ConnectorGetRequest() 2541 if self.parent.snapshot_datetime is not None: 2542 req.meta.CopyFrom(GetRequestMetadata()) 2543 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2544 2545 req.id = (id) 2546 tries = 0 2547 plumbing_response = None 2548 while True: 2549 t = None if deadline is None else deadline - time.time() 2550 try: 2551 plumbing_response = self.stub.Get( 2552 req, 2553 metadata=self.parent.get_metadata( 2554 'DiscoveryConnectors.Get', req), 2555 timeout=t) 2556 except Exception as e: 2557 if self.parent.shouldRetry(tries, e, deadline): 2558 tries += 1 2559 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2560 continue 2561 raise plumbing.convert_error_to_porcelain(e) from e 2562 break 2563 2564 resp = models.ConnectorGetResponse() 2565 resp.connector = plumbing.convert_connector_to_porcelain( 2566 plumbing_response.connector) 2567 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2568 plumbing_response.meta) 2569 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2570 plumbing_response.rate_limit) 2571 return resp
Get reads one Connector by ID
def
update(self, connector, timeout=None)
2573 def update(self, connector, timeout=None): 2574 ''' 2575 Update replaces all the fields of a Connector by ID. 2576 ''' 2577 deadline = None if timeout is None else time.time() + timeout 2578 req = ConnectorUpdateRequest() 2579 2580 if connector is not None: 2581 req.connector.CopyFrom( 2582 plumbing.convert_connector_to_plumbing(connector)) 2583 tries = 0 2584 plumbing_response = None 2585 while True: 2586 t = None if deadline is None else deadline - time.time() 2587 try: 2588 plumbing_response = self.stub.Update( 2589 req, 2590 metadata=self.parent.get_metadata( 2591 'DiscoveryConnectors.Update', req), 2592 timeout=t) 2593 except Exception as e: 2594 if self.parent.shouldRetry(tries, e, deadline): 2595 tries += 1 2596 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2597 continue 2598 raise plumbing.convert_error_to_porcelain(e) from e 2599 break 2600 2601 resp = models.ConnectorUpdateResponse() 2602 resp.connector = plumbing.convert_connector_to_porcelain( 2603 plumbing_response.connector) 2604 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2605 plumbing_response.rate_limit) 2606 return resp
Update replaces all the fields of a Connector by ID.
def
delete(self, id, timeout=None)
2608 def delete(self, id, timeout=None): 2609 ''' 2610 Delete removes a Connector by ID. 2611 ''' 2612 deadline = None if timeout is None else time.time() + timeout 2613 req = ConnectorDeleteRequest() 2614 2615 req.id = (id) 2616 tries = 0 2617 plumbing_response = None 2618 while True: 2619 t = None if deadline is None else deadline - time.time() 2620 try: 2621 plumbing_response = self.stub.Delete( 2622 req, 2623 metadata=self.parent.get_metadata( 2624 'DiscoveryConnectors.Delete', req), 2625 timeout=t) 2626 except Exception as e: 2627 if self.parent.shouldRetry(tries, e, deadline): 2628 tries += 1 2629 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2630 continue 2631 raise plumbing.convert_error_to_porcelain(e) from e 2632 break 2633 2634 resp = models.ConnectorDeleteResponse() 2635 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 2636 plumbing_response.meta) 2637 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2638 plumbing_response.rate_limit) 2639 return resp
Delete removes a Connector by ID.
def
list(self, filter, *args, timeout=None)
2641 def list(self, filter, *args, timeout=None): 2642 ''' 2643 List gets a list of Connectors matching a given set of criteria. 2644 ''' 2645 deadline = None if timeout is None else time.time() + timeout 2646 req = ConnectorListRequest() 2647 req.meta.CopyFrom(ListRequestMetadata()) 2648 if self.parent.page_limit > 0: 2649 req.meta.limit = self.parent.page_limit 2650 if self.parent.snapshot_datetime is not None: 2651 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2652 2653 req.filter = plumbing.quote_filter_args(filter, *args) 2654 2655 def generator(svc, req): 2656 tries = 0 2657 while True: 2658 t = None if deadline is None else deadline - time.time() 2659 try: 2660 plumbing_response = svc.stub.List( 2661 req, 2662 metadata=svc.parent.get_metadata( 2663 'DiscoveryConnectors.List', req), 2664 timeout=t) 2665 except Exception as e: 2666 if self.parent.shouldRetry(tries, e, deadline): 2667 tries += 1 2668 time.sleep( 2669 self.parent.exponentialBackoff(tries, deadline)) 2670 continue 2671 raise plumbing.convert_error_to_porcelain(e) from e 2672 tries = 0 2673 for plumbing_item in plumbing_response.connectors: 2674 yield plumbing.convert_connector_to_porcelain( 2675 plumbing_item) 2676 if plumbing_response.meta.next_cursor == '': 2677 break 2678 req.meta.cursor = plumbing_response.meta.next_cursor 2679 2680 return generator(self, req)
List gets a list of Connectors matching a given set of criteria.
class
SnapshotDiscoveryConnectors:
2683class SnapshotDiscoveryConnectors: 2684 ''' 2685 SnapshotDiscoveryConnectors exposes the read only methods of the DiscoveryConnectors 2686 service for historical queries. 2687 ''' 2688 def __init__(self, discovery_connectors): 2689 self.discovery_connectors = discovery_connectors 2690 2691 def get(self, id, timeout=None): 2692 ''' 2693 Get reads one Connector by ID 2694 ''' 2695 return self.discovery_connectors.get(id, timeout=timeout) 2696 2697 def list(self, filter, *args, timeout=None): 2698 ''' 2699 List gets a list of Connectors matching a given set of criteria. 2700 ''' 2701 return self.discovery_connectors.list(filter, *args, timeout=timeout)
SnapshotDiscoveryConnectors exposes the read only methods of the DiscoveryConnectors service for historical queries.
def
get(self, id, timeout=None)
2691 def get(self, id, timeout=None): 2692 ''' 2693 Get reads one Connector by ID 2694 ''' 2695 return self.discovery_connectors.get(id, timeout=timeout)
Get reads one Connector by ID
def
list(self, filter, *args, timeout=None)
2697 def list(self, filter, *args, timeout=None): 2698 ''' 2699 List gets a list of Connectors matching a given set of criteria. 2700 ''' 2701 return self.discovery_connectors.list(filter, *args, timeout=timeout)
List gets a list of Connectors matching a given set of criteria.
class
GrantedAccountEntitlements:
2704class GrantedAccountEntitlements: 2705 ''' 2706 GrantedAccountEntitlements enumerates the resources to which an account has been granted access. 2707 The GrantedAccountEntitlements service is read-only. 2708 See `strongdm.models.GrantedAccountEntitlement`. 2709 ''' 2710 def __init__(self, channel, client): 2711 self.parent = client 2712 self.stub = GrantedAccountEntitlementsStub(channel) 2713 2714 def list(self, account_id, filter, *args, timeout=None): 2715 ''' 2716 List gets a list of GrantedAccountEntitlement records matching a given set of criteria. 2717 ''' 2718 deadline = None if timeout is None else time.time() + timeout 2719 req = GrantedAccountEntitlementListRequest() 2720 req.meta.CopyFrom(ListRequestMetadata()) 2721 if self.parent.page_limit > 0: 2722 req.meta.limit = self.parent.page_limit 2723 if self.parent.snapshot_datetime is not None: 2724 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2725 2726 req.account_id = (account_id) 2727 req.filter = plumbing.quote_filter_args(filter, *args) 2728 2729 def generator(svc, req): 2730 tries = 0 2731 while True: 2732 t = None if deadline is None else deadline - time.time() 2733 try: 2734 plumbing_response = svc.stub.List( 2735 req, 2736 metadata=svc.parent.get_metadata( 2737 'GrantedAccountEntitlements.List', req), 2738 timeout=t) 2739 except Exception as e: 2740 if self.parent.shouldRetry(tries, e, deadline): 2741 tries += 1 2742 time.sleep( 2743 self.parent.exponentialBackoff(tries, deadline)) 2744 continue 2745 raise plumbing.convert_error_to_porcelain(e) from e 2746 tries = 0 2747 for plumbing_item in plumbing_response.granted_account_entitlements: 2748 yield plumbing.convert_granted_account_entitlement_to_porcelain( 2749 plumbing_item) 2750 if plumbing_response.meta.next_cursor == '': 2751 break 2752 req.meta.cursor = plumbing_response.meta.next_cursor 2753 2754 return generator(self, req)
GrantedAccountEntitlements enumerates the resources to which an account has been granted access.
The GrantedAccountEntitlements service is read-only.
See strongdm.models.GrantedAccountEntitlement.
def
list(self, account_id, filter, *args, timeout=None)
2714 def list(self, account_id, filter, *args, timeout=None): 2715 ''' 2716 List gets a list of GrantedAccountEntitlement records matching a given set of criteria. 2717 ''' 2718 deadline = None if timeout is None else time.time() + timeout 2719 req = GrantedAccountEntitlementListRequest() 2720 req.meta.CopyFrom(ListRequestMetadata()) 2721 if self.parent.page_limit > 0: 2722 req.meta.limit = self.parent.page_limit 2723 if self.parent.snapshot_datetime is not None: 2724 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2725 2726 req.account_id = (account_id) 2727 req.filter = plumbing.quote_filter_args(filter, *args) 2728 2729 def generator(svc, req): 2730 tries = 0 2731 while True: 2732 t = None if deadline is None else deadline - time.time() 2733 try: 2734 plumbing_response = svc.stub.List( 2735 req, 2736 metadata=svc.parent.get_metadata( 2737 'GrantedAccountEntitlements.List', req), 2738 timeout=t) 2739 except Exception as e: 2740 if self.parent.shouldRetry(tries, e, deadline): 2741 tries += 1 2742 time.sleep( 2743 self.parent.exponentialBackoff(tries, deadline)) 2744 continue 2745 raise plumbing.convert_error_to_porcelain(e) from e 2746 tries = 0 2747 for plumbing_item in plumbing_response.granted_account_entitlements: 2748 yield plumbing.convert_granted_account_entitlement_to_porcelain( 2749 plumbing_item) 2750 if plumbing_response.meta.next_cursor == '': 2751 break 2752 req.meta.cursor = plumbing_response.meta.next_cursor 2753 2754 return generator(self, req)
List gets a list of GrantedAccountEntitlement records matching a given set of criteria.
class
SnapshotGrantedAccountEntitlements:
2757class SnapshotGrantedAccountEntitlements: 2758 ''' 2759 SnapshotGrantedAccountEntitlements exposes the read only methods of the GrantedAccountEntitlements 2760 service for historical queries. 2761 ''' 2762 def __init__(self, granted_account_entitlements): 2763 self.granted_account_entitlements = granted_account_entitlements 2764 2765 def list(self, account_id, filter, *args, timeout=None): 2766 ''' 2767 List gets a list of GrantedAccountEntitlement records matching a given set of criteria. 2768 ''' 2769 return self.granted_account_entitlements.list(account_id, 2770 filter, 2771 *args, 2772 timeout=timeout)
SnapshotGrantedAccountEntitlements exposes the read only methods of the GrantedAccountEntitlements service for historical queries.
def
list(self, account_id, filter, *args, timeout=None)
2765 def list(self, account_id, filter, *args, timeout=None): 2766 ''' 2767 List gets a list of GrantedAccountEntitlement records matching a given set of criteria. 2768 ''' 2769 return self.granted_account_entitlements.list(account_id, 2770 filter, 2771 *args, 2772 timeout=timeout)
List gets a list of GrantedAccountEntitlement records matching a given set of criteria.
class
GrantedResourceEntitlements:
2775class GrantedResourceEntitlements: 2776 ''' 2777 GrantedResourceEntitlements enumerates the accounts that have been granted access to a given resource. 2778 The GrantedResourceEntitlements service is read-only. 2779 See `strongdm.models.GrantedResourceEntitlement`. 2780 ''' 2781 def __init__(self, channel, client): 2782 self.parent = client 2783 self.stub = GrantedResourceEntitlementsStub(channel) 2784 2785 def list(self, resource_id, filter, *args, timeout=None): 2786 ''' 2787 List gets a list of GrantedResourceEntitlement records matching a given set of criteria. 2788 ''' 2789 deadline = None if timeout is None else time.time() + timeout 2790 req = GrantedResourceEntitlementListRequest() 2791 req.meta.CopyFrom(ListRequestMetadata()) 2792 if self.parent.page_limit > 0: 2793 req.meta.limit = self.parent.page_limit 2794 if self.parent.snapshot_datetime is not None: 2795 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2796 2797 req.resource_id = (resource_id) 2798 req.filter = plumbing.quote_filter_args(filter, *args) 2799 2800 def generator(svc, req): 2801 tries = 0 2802 while True: 2803 t = None if deadline is None else deadline - time.time() 2804 try: 2805 plumbing_response = svc.stub.List( 2806 req, 2807 metadata=svc.parent.get_metadata( 2808 'GrantedResourceEntitlements.List', req), 2809 timeout=t) 2810 except Exception as e: 2811 if self.parent.shouldRetry(tries, e, deadline): 2812 tries += 1 2813 time.sleep( 2814 self.parent.exponentialBackoff(tries, deadline)) 2815 continue 2816 raise plumbing.convert_error_to_porcelain(e) from e 2817 tries = 0 2818 for plumbing_item in plumbing_response.granted_resource_entitlements: 2819 yield plumbing.convert_granted_resource_entitlement_to_porcelain( 2820 plumbing_item) 2821 if plumbing_response.meta.next_cursor == '': 2822 break 2823 req.meta.cursor = plumbing_response.meta.next_cursor 2824 2825 return generator(self, req)
GrantedResourceEntitlements enumerates the accounts that have been granted access to a given resource.
The GrantedResourceEntitlements service is read-only.
See strongdm.models.GrantedResourceEntitlement.
def
list(self, resource_id, filter, *args, timeout=None)
2785 def list(self, resource_id, filter, *args, timeout=None): 2786 ''' 2787 List gets a list of GrantedResourceEntitlement records matching a given set of criteria. 2788 ''' 2789 deadline = None if timeout is None else time.time() + timeout 2790 req = GrantedResourceEntitlementListRequest() 2791 req.meta.CopyFrom(ListRequestMetadata()) 2792 if self.parent.page_limit > 0: 2793 req.meta.limit = self.parent.page_limit 2794 if self.parent.snapshot_datetime is not None: 2795 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2796 2797 req.resource_id = (resource_id) 2798 req.filter = plumbing.quote_filter_args(filter, *args) 2799 2800 def generator(svc, req): 2801 tries = 0 2802 while True: 2803 t = None if deadline is None else deadline - time.time() 2804 try: 2805 plumbing_response = svc.stub.List( 2806 req, 2807 metadata=svc.parent.get_metadata( 2808 'GrantedResourceEntitlements.List', req), 2809 timeout=t) 2810 except Exception as e: 2811 if self.parent.shouldRetry(tries, e, deadline): 2812 tries += 1 2813 time.sleep( 2814 self.parent.exponentialBackoff(tries, deadline)) 2815 continue 2816 raise plumbing.convert_error_to_porcelain(e) from e 2817 tries = 0 2818 for plumbing_item in plumbing_response.granted_resource_entitlements: 2819 yield plumbing.convert_granted_resource_entitlement_to_porcelain( 2820 plumbing_item) 2821 if plumbing_response.meta.next_cursor == '': 2822 break 2823 req.meta.cursor = plumbing_response.meta.next_cursor 2824 2825 return generator(self, req)
List gets a list of GrantedResourceEntitlement records matching a given set of criteria.
class
SnapshotGrantedResourceEntitlements:
2828class SnapshotGrantedResourceEntitlements: 2829 ''' 2830 SnapshotGrantedResourceEntitlements exposes the read only methods of the GrantedResourceEntitlements 2831 service for historical queries. 2832 ''' 2833 def __init__(self, granted_resource_entitlements): 2834 self.granted_resource_entitlements = granted_resource_entitlements 2835 2836 def list(self, resource_id, filter, *args, timeout=None): 2837 ''' 2838 List gets a list of GrantedResourceEntitlement records matching a given set of criteria. 2839 ''' 2840 return self.granted_resource_entitlements.list(resource_id, 2841 filter, 2842 *args, 2843 timeout=timeout)
SnapshotGrantedResourceEntitlements exposes the read only methods of the GrantedResourceEntitlements service for historical queries.
def
list(self, resource_id, filter, *args, timeout=None)
2836 def list(self, resource_id, filter, *args, timeout=None): 2837 ''' 2838 List gets a list of GrantedResourceEntitlement records matching a given set of criteria. 2839 ''' 2840 return self.granted_resource_entitlements.list(resource_id, 2841 filter, 2842 *args, 2843 timeout=timeout)
List gets a list of GrantedResourceEntitlement records matching a given set of criteria.
class
GrantedRoleEntitlements:
2846class GrantedRoleEntitlements: 2847 ''' 2848 GrantedRoleEntitlements enumerates the resources to which a role grants access. 2849 The GrantedRoleEntitlements service is read-only. 2850 See `strongdm.models.GrantedRoleEntitlement`. 2851 ''' 2852 def __init__(self, channel, client): 2853 self.parent = client 2854 self.stub = GrantedRoleEntitlementsStub(channel) 2855 2856 def list(self, role_id, filter, *args, timeout=None): 2857 ''' 2858 List gets a list of GrantedRoleEntitlement records matching a given set of criteria. 2859 ''' 2860 deadline = None if timeout is None else time.time() + timeout 2861 req = GrantedRoleEntitlementListRequest() 2862 req.meta.CopyFrom(ListRequestMetadata()) 2863 if self.parent.page_limit > 0: 2864 req.meta.limit = self.parent.page_limit 2865 if self.parent.snapshot_datetime is not None: 2866 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2867 2868 req.role_id = (role_id) 2869 req.filter = plumbing.quote_filter_args(filter, *args) 2870 2871 def generator(svc, req): 2872 tries = 0 2873 while True: 2874 t = None if deadline is None else deadline - time.time() 2875 try: 2876 plumbing_response = svc.stub.List( 2877 req, 2878 metadata=svc.parent.get_metadata( 2879 'GrantedRoleEntitlements.List', req), 2880 timeout=t) 2881 except Exception as e: 2882 if self.parent.shouldRetry(tries, e, deadline): 2883 tries += 1 2884 time.sleep( 2885 self.parent.exponentialBackoff(tries, deadline)) 2886 continue 2887 raise plumbing.convert_error_to_porcelain(e) from e 2888 tries = 0 2889 for plumbing_item in plumbing_response.granted_role_entitlements: 2890 yield plumbing.convert_granted_role_entitlement_to_porcelain( 2891 plumbing_item) 2892 if plumbing_response.meta.next_cursor == '': 2893 break 2894 req.meta.cursor = plumbing_response.meta.next_cursor 2895 2896 return generator(self, req)
GrantedRoleEntitlements enumerates the resources to which a role grants access.
The GrantedRoleEntitlements service is read-only.
See strongdm.models.GrantedRoleEntitlement.
def
list(self, role_id, filter, *args, timeout=None)
2856 def list(self, role_id, filter, *args, timeout=None): 2857 ''' 2858 List gets a list of GrantedRoleEntitlement records matching a given set of criteria. 2859 ''' 2860 deadline = None if timeout is None else time.time() + timeout 2861 req = GrantedRoleEntitlementListRequest() 2862 req.meta.CopyFrom(ListRequestMetadata()) 2863 if self.parent.page_limit > 0: 2864 req.meta.limit = self.parent.page_limit 2865 if self.parent.snapshot_datetime is not None: 2866 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2867 2868 req.role_id = (role_id) 2869 req.filter = plumbing.quote_filter_args(filter, *args) 2870 2871 def generator(svc, req): 2872 tries = 0 2873 while True: 2874 t = None if deadline is None else deadline - time.time() 2875 try: 2876 plumbing_response = svc.stub.List( 2877 req, 2878 metadata=svc.parent.get_metadata( 2879 'GrantedRoleEntitlements.List', req), 2880 timeout=t) 2881 except Exception as e: 2882 if self.parent.shouldRetry(tries, e, deadline): 2883 tries += 1 2884 time.sleep( 2885 self.parent.exponentialBackoff(tries, deadline)) 2886 continue 2887 raise plumbing.convert_error_to_porcelain(e) from e 2888 tries = 0 2889 for plumbing_item in plumbing_response.granted_role_entitlements: 2890 yield plumbing.convert_granted_role_entitlement_to_porcelain( 2891 plumbing_item) 2892 if plumbing_response.meta.next_cursor == '': 2893 break 2894 req.meta.cursor = plumbing_response.meta.next_cursor 2895 2896 return generator(self, req)
List gets a list of GrantedRoleEntitlement records matching a given set of criteria.
class
SnapshotGrantedRoleEntitlements:
2899class SnapshotGrantedRoleEntitlements: 2900 ''' 2901 SnapshotGrantedRoleEntitlements exposes the read only methods of the GrantedRoleEntitlements 2902 service for historical queries. 2903 ''' 2904 def __init__(self, granted_role_entitlements): 2905 self.granted_role_entitlements = granted_role_entitlements 2906 2907 def list(self, role_id, filter, *args, timeout=None): 2908 ''' 2909 List gets a list of GrantedRoleEntitlement records matching a given set of criteria. 2910 ''' 2911 return self.granted_role_entitlements.list(role_id, 2912 filter, 2913 *args, 2914 timeout=timeout)
SnapshotGrantedRoleEntitlements exposes the read only methods of the GrantedRoleEntitlements service for historical queries.
def
list(self, role_id, filter, *args, timeout=None)
2907 def list(self, role_id, filter, *args, timeout=None): 2908 ''' 2909 List gets a list of GrantedRoleEntitlement records matching a given set of criteria. 2910 ''' 2911 return self.granted_role_entitlements.list(role_id, 2912 filter, 2913 *args, 2914 timeout=timeout)
List gets a list of GrantedRoleEntitlement records matching a given set of criteria.
class
Roles:
2917class Roles: 2918 ''' 2919 A Role has a list of access rules which determine which Resources the members 2920 of the Role have access to. An Account can be a member of multiple Roles via 2921 AccountAttachments. 2922 See `strongdm.models.Role`. 2923 ''' 2924 def __init__(self, channel, client): 2925 self.parent = client 2926 self.stub = RolesStub(channel) 2927 2928 def create(self, role, timeout=None): 2929 ''' 2930 Create registers a new Role. 2931 ''' 2932 deadline = None if timeout is None else time.time() + timeout 2933 req = RoleCreateRequest() 2934 2935 if role is not None: 2936 req.role.CopyFrom(plumbing.convert_role_to_plumbing(role)) 2937 tries = 0 2938 plumbing_response = None 2939 while True: 2940 t = None if deadline is None else deadline - time.time() 2941 try: 2942 plumbing_response = self.stub.Create( 2943 req, 2944 metadata=self.parent.get_metadata('Roles.Create', req), 2945 timeout=t) 2946 except Exception as e: 2947 if self.parent.shouldRetry(tries, e, deadline): 2948 tries += 1 2949 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2950 continue 2951 raise plumbing.convert_error_to_porcelain(e) from e 2952 break 2953 2954 resp = models.RoleCreateResponse() 2955 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 2956 plumbing_response.meta) 2957 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2958 plumbing_response.rate_limit) 2959 resp.role = plumbing.convert_role_to_porcelain(plumbing_response.role) 2960 return resp 2961 2962 def get(self, id, timeout=None): 2963 ''' 2964 Get reads one Role by ID. 2965 ''' 2966 deadline = None if timeout is None else time.time() + timeout 2967 req = RoleGetRequest() 2968 if self.parent.snapshot_datetime is not None: 2969 req.meta.CopyFrom(GetRequestMetadata()) 2970 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2971 2972 req.id = (id) 2973 tries = 0 2974 plumbing_response = None 2975 while True: 2976 t = None if deadline is None else deadline - time.time() 2977 try: 2978 plumbing_response = self.stub.Get( 2979 req, 2980 metadata=self.parent.get_metadata('Roles.Get', req), 2981 timeout=t) 2982 except Exception as e: 2983 if self.parent.shouldRetry(tries, e, deadline): 2984 tries += 1 2985 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2986 continue 2987 raise plumbing.convert_error_to_porcelain(e) from e 2988 break 2989 2990 resp = models.RoleGetResponse() 2991 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2992 plumbing_response.meta) 2993 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2994 plumbing_response.rate_limit) 2995 resp.role = plumbing.convert_role_to_porcelain(plumbing_response.role) 2996 return resp 2997 2998 def update(self, role, timeout=None): 2999 ''' 3000 Update replaces all the fields of a Role by ID. 3001 ''' 3002 deadline = None if timeout is None else time.time() + timeout 3003 req = RoleUpdateRequest() 3004 3005 if role is not None: 3006 req.role.CopyFrom(plumbing.convert_role_to_plumbing(role)) 3007 tries = 0 3008 plumbing_response = None 3009 while True: 3010 t = None if deadline is None else deadline - time.time() 3011 try: 3012 plumbing_response = self.stub.Update( 3013 req, 3014 metadata=self.parent.get_metadata('Roles.Update', req), 3015 timeout=t) 3016 except Exception as e: 3017 if self.parent.shouldRetry(tries, e, deadline): 3018 tries += 1 3019 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3020 continue 3021 raise plumbing.convert_error_to_porcelain(e) from e 3022 break 3023 3024 resp = models.RoleUpdateResponse() 3025 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 3026 plumbing_response.meta) 3027 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3028 plumbing_response.rate_limit) 3029 resp.role = plumbing.convert_role_to_porcelain(plumbing_response.role) 3030 return resp 3031 3032 def delete(self, id, timeout=None): 3033 ''' 3034 Delete removes a Role by ID. 3035 ''' 3036 deadline = None if timeout is None else time.time() + timeout 3037 req = RoleDeleteRequest() 3038 3039 req.id = (id) 3040 tries = 0 3041 plumbing_response = None 3042 while True: 3043 t = None if deadline is None else deadline - time.time() 3044 try: 3045 plumbing_response = self.stub.Delete( 3046 req, 3047 metadata=self.parent.get_metadata('Roles.Delete', req), 3048 timeout=t) 3049 except Exception as e: 3050 if self.parent.shouldRetry(tries, e, deadline): 3051 tries += 1 3052 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3053 continue 3054 raise plumbing.convert_error_to_porcelain(e) from e 3055 break 3056 3057 resp = models.RoleDeleteResponse() 3058 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3059 plumbing_response.meta) 3060 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3061 plumbing_response.rate_limit) 3062 return resp 3063 3064 def list(self, filter, *args, timeout=None): 3065 ''' 3066 List gets a list of Roles matching a given set of criteria. 3067 ''' 3068 deadline = None if timeout is None else time.time() + timeout 3069 req = RoleListRequest() 3070 req.meta.CopyFrom(ListRequestMetadata()) 3071 if self.parent.page_limit > 0: 3072 req.meta.limit = self.parent.page_limit 3073 if self.parent.snapshot_datetime is not None: 3074 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3075 3076 req.filter = plumbing.quote_filter_args(filter, *args) 3077 3078 def generator(svc, req): 3079 tries = 0 3080 while True: 3081 t = None if deadline is None else deadline - time.time() 3082 try: 3083 plumbing_response = svc.stub.List( 3084 req, 3085 metadata=svc.parent.get_metadata('Roles.List', req), 3086 timeout=t) 3087 except Exception as e: 3088 if self.parent.shouldRetry(tries, e, deadline): 3089 tries += 1 3090 time.sleep( 3091 self.parent.exponentialBackoff(tries, deadline)) 3092 continue 3093 raise plumbing.convert_error_to_porcelain(e) from e 3094 tries = 0 3095 for plumbing_item in plumbing_response.roles: 3096 yield plumbing.convert_role_to_porcelain(plumbing_item) 3097 if plumbing_response.meta.next_cursor == '': 3098 break 3099 req.meta.cursor = plumbing_response.meta.next_cursor 3100 3101 return generator(self, req)
A Role has a list of access rules which determine which Resources the members
of the Role have access to. An Account can be a member of multiple Roles via
AccountAttachments.
See strongdm.models.Role.
def
create(self, role, timeout=None)
2928 def create(self, role, timeout=None): 2929 ''' 2930 Create registers a new Role. 2931 ''' 2932 deadline = None if timeout is None else time.time() + timeout 2933 req = RoleCreateRequest() 2934 2935 if role is not None: 2936 req.role.CopyFrom(plumbing.convert_role_to_plumbing(role)) 2937 tries = 0 2938 plumbing_response = None 2939 while True: 2940 t = None if deadline is None else deadline - time.time() 2941 try: 2942 plumbing_response = self.stub.Create( 2943 req, 2944 metadata=self.parent.get_metadata('Roles.Create', req), 2945 timeout=t) 2946 except Exception as e: 2947 if self.parent.shouldRetry(tries, e, deadline): 2948 tries += 1 2949 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2950 continue 2951 raise plumbing.convert_error_to_porcelain(e) from e 2952 break 2953 2954 resp = models.RoleCreateResponse() 2955 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 2956 plumbing_response.meta) 2957 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2958 plumbing_response.rate_limit) 2959 resp.role = plumbing.convert_role_to_porcelain(plumbing_response.role) 2960 return resp
Create registers a new Role.
def
get(self, id, timeout=None)
2962 def get(self, id, timeout=None): 2963 ''' 2964 Get reads one Role by ID. 2965 ''' 2966 deadline = None if timeout is None else time.time() + timeout 2967 req = RoleGetRequest() 2968 if self.parent.snapshot_datetime is not None: 2969 req.meta.CopyFrom(GetRequestMetadata()) 2970 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2971 2972 req.id = (id) 2973 tries = 0 2974 plumbing_response = None 2975 while True: 2976 t = None if deadline is None else deadline - time.time() 2977 try: 2978 plumbing_response = self.stub.Get( 2979 req, 2980 metadata=self.parent.get_metadata('Roles.Get', req), 2981 timeout=t) 2982 except Exception as e: 2983 if self.parent.shouldRetry(tries, e, deadline): 2984 tries += 1 2985 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2986 continue 2987 raise plumbing.convert_error_to_porcelain(e) from e 2988 break 2989 2990 resp = models.RoleGetResponse() 2991 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2992 plumbing_response.meta) 2993 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2994 plumbing_response.rate_limit) 2995 resp.role = plumbing.convert_role_to_porcelain(plumbing_response.role) 2996 return resp
Get reads one Role by ID.
def
update(self, role, timeout=None)
2998 def update(self, role, timeout=None): 2999 ''' 3000 Update replaces all the fields of a Role by ID. 3001 ''' 3002 deadline = None if timeout is None else time.time() + timeout 3003 req = RoleUpdateRequest() 3004 3005 if role is not None: 3006 req.role.CopyFrom(plumbing.convert_role_to_plumbing(role)) 3007 tries = 0 3008 plumbing_response = None 3009 while True: 3010 t = None if deadline is None else deadline - time.time() 3011 try: 3012 plumbing_response = self.stub.Update( 3013 req, 3014 metadata=self.parent.get_metadata('Roles.Update', req), 3015 timeout=t) 3016 except Exception as e: 3017 if self.parent.shouldRetry(tries, e, deadline): 3018 tries += 1 3019 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3020 continue 3021 raise plumbing.convert_error_to_porcelain(e) from e 3022 break 3023 3024 resp = models.RoleUpdateResponse() 3025 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 3026 plumbing_response.meta) 3027 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3028 plumbing_response.rate_limit) 3029 resp.role = plumbing.convert_role_to_porcelain(plumbing_response.role) 3030 return resp
Update replaces all the fields of a Role by ID.
def
delete(self, id, timeout=None)
3032 def delete(self, id, timeout=None): 3033 ''' 3034 Delete removes a Role by ID. 3035 ''' 3036 deadline = None if timeout is None else time.time() + timeout 3037 req = RoleDeleteRequest() 3038 3039 req.id = (id) 3040 tries = 0 3041 plumbing_response = None 3042 while True: 3043 t = None if deadline is None else deadline - time.time() 3044 try: 3045 plumbing_response = self.stub.Delete( 3046 req, 3047 metadata=self.parent.get_metadata('Roles.Delete', req), 3048 timeout=t) 3049 except Exception as e: 3050 if self.parent.shouldRetry(tries, e, deadline): 3051 tries += 1 3052 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3053 continue 3054 raise plumbing.convert_error_to_porcelain(e) from e 3055 break 3056 3057 resp = models.RoleDeleteResponse() 3058 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3059 plumbing_response.meta) 3060 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3061 plumbing_response.rate_limit) 3062 return resp
Delete removes a Role by ID.
def
list(self, filter, *args, timeout=None)
3064 def list(self, filter, *args, timeout=None): 3065 ''' 3066 List gets a list of Roles matching a given set of criteria. 3067 ''' 3068 deadline = None if timeout is None else time.time() + timeout 3069 req = RoleListRequest() 3070 req.meta.CopyFrom(ListRequestMetadata()) 3071 if self.parent.page_limit > 0: 3072 req.meta.limit = self.parent.page_limit 3073 if self.parent.snapshot_datetime is not None: 3074 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3075 3076 req.filter = plumbing.quote_filter_args(filter, *args) 3077 3078 def generator(svc, req): 3079 tries = 0 3080 while True: 3081 t = None if deadline is None else deadline - time.time() 3082 try: 3083 plumbing_response = svc.stub.List( 3084 req, 3085 metadata=svc.parent.get_metadata('Roles.List', req), 3086 timeout=t) 3087 except Exception as e: 3088 if self.parent.shouldRetry(tries, e, deadline): 3089 tries += 1 3090 time.sleep( 3091 self.parent.exponentialBackoff(tries, deadline)) 3092 continue 3093 raise plumbing.convert_error_to_porcelain(e) from e 3094 tries = 0 3095 for plumbing_item in plumbing_response.roles: 3096 yield plumbing.convert_role_to_porcelain(plumbing_item) 3097 if plumbing_response.meta.next_cursor == '': 3098 break 3099 req.meta.cursor = plumbing_response.meta.next_cursor 3100 3101 return generator(self, req)
List gets a list of Roles matching a given set of criteria.
class
SnapshotRoles:
3104class SnapshotRoles: 3105 ''' 3106 SnapshotRoles exposes the read only methods of the Roles 3107 service for historical queries. 3108 ''' 3109 def __init__(self, roles): 3110 self.roles = roles 3111 3112 def get(self, id, timeout=None): 3113 ''' 3114 Get reads one Role by ID. 3115 ''' 3116 return self.roles.get(id, timeout=timeout) 3117 3118 def list(self, filter, *args, timeout=None): 3119 ''' 3120 List gets a list of Roles matching a given set of criteria. 3121 ''' 3122 return self.roles.list(filter, *args, timeout=timeout)
SnapshotRoles exposes the read only methods of the Roles service for historical queries.
class
Groups:
3125class Groups: 3126 ''' 3127 A Group is a set of principals. 3128 See `strongdm.models.Group`. 3129 ''' 3130 def __init__(self, channel, client): 3131 self.parent = client 3132 self.stub = GroupsStub(channel) 3133 3134 def create(self, group, timeout=None): 3135 ''' 3136 Create registers a new Group. 3137 ''' 3138 deadline = None if timeout is None else time.time() + timeout 3139 req = GroupCreateRequest() 3140 3141 if group is not None: 3142 req.group.CopyFrom(plumbing.convert_group_to_plumbing(group)) 3143 tries = 0 3144 plumbing_response = None 3145 while True: 3146 t = None if deadline is None else deadline - time.time() 3147 try: 3148 plumbing_response = self.stub.Create( 3149 req, 3150 metadata=self.parent.get_metadata('Groups.Create', req), 3151 timeout=t) 3152 except Exception as e: 3153 if self.parent.shouldRetry(tries, e, deadline): 3154 tries += 1 3155 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3156 continue 3157 raise plumbing.convert_error_to_porcelain(e) from e 3158 break 3159 3160 resp = models.GroupCreateResponse() 3161 resp.group = plumbing.convert_group_to_porcelain( 3162 plumbing_response.group) 3163 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3164 plumbing_response.rate_limit) 3165 return resp 3166 3167 def create_from_roles(self, role_ids, commit, timeout=None): 3168 deadline = None if timeout is None else time.time() + timeout 3169 req = GroupCreateFromRolesRequest() 3170 3171 req.role_ids.extend((role_ids)) 3172 req.commit = (commit) 3173 tries = 0 3174 plumbing_response = None 3175 while True: 3176 t = None if deadline is None else deadline - time.time() 3177 try: 3178 plumbing_response = self.stub.CreateFromRoles( 3179 req, 3180 metadata=self.parent.get_metadata('Groups.CreateFromRoles', 3181 req), 3182 timeout=t) 3183 except Exception as e: 3184 if self.parent.shouldRetry(tries, e, deadline): 3185 tries += 1 3186 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3187 continue 3188 raise plumbing.convert_error_to_porcelain(e) from e 3189 break 3190 3191 resp = models.GroupCreateFromRolesResponse() 3192 resp.group_from_role = plumbing.convert_repeated_group_from_role_to_porcelain( 3193 plumbing_response.group_from_role) 3194 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3195 plumbing_response.rate_limit) 3196 return resp 3197 3198 def get(self, id, timeout=None): 3199 ''' 3200 Get reads one Group by ID. 3201 ''' 3202 deadline = None if timeout is None else time.time() + timeout 3203 req = GroupGetRequest() 3204 if self.parent.snapshot_datetime is not None: 3205 req.meta.CopyFrom(GetRequestMetadata()) 3206 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3207 3208 req.id = (id) 3209 tries = 0 3210 plumbing_response = None 3211 while True: 3212 t = None if deadline is None else deadline - time.time() 3213 try: 3214 plumbing_response = self.stub.Get( 3215 req, 3216 metadata=self.parent.get_metadata('Groups.Get', req), 3217 timeout=t) 3218 except Exception as e: 3219 if self.parent.shouldRetry(tries, e, deadline): 3220 tries += 1 3221 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3222 continue 3223 raise plumbing.convert_error_to_porcelain(e) from e 3224 break 3225 3226 resp = models.GroupGetResponse() 3227 resp.group = plumbing.convert_group_to_porcelain( 3228 plumbing_response.group) 3229 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3230 plumbing_response.meta) 3231 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3232 plumbing_response.rate_limit) 3233 return resp 3234 3235 def update(self, group, timeout=None): 3236 ''' 3237 Update replaces all the fields of a Group by ID. 3238 ''' 3239 deadline = None if timeout is None else time.time() + timeout 3240 req = GroupUpdateRequest() 3241 3242 if group is not None: 3243 req.group.CopyFrom(plumbing.convert_group_to_plumbing(group)) 3244 tries = 0 3245 plumbing_response = None 3246 while True: 3247 t = None if deadline is None else deadline - time.time() 3248 try: 3249 plumbing_response = self.stub.Update( 3250 req, 3251 metadata=self.parent.get_metadata('Groups.Update', req), 3252 timeout=t) 3253 except Exception as e: 3254 if self.parent.shouldRetry(tries, e, deadline): 3255 tries += 1 3256 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3257 continue 3258 raise plumbing.convert_error_to_porcelain(e) from e 3259 break 3260 3261 resp = models.GroupUpdateResponse() 3262 resp.group = plumbing.convert_group_to_porcelain( 3263 plumbing_response.group) 3264 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3265 plumbing_response.rate_limit) 3266 return resp 3267 3268 def delete(self, id, timeout=None): 3269 ''' 3270 Delete removes a Group by ID. 3271 ''' 3272 deadline = None if timeout is None else time.time() + timeout 3273 req = GroupDeleteRequest() 3274 3275 req.id = (id) 3276 tries = 0 3277 plumbing_response = None 3278 while True: 3279 t = None if deadline is None else deadline - time.time() 3280 try: 3281 plumbing_response = self.stub.Delete( 3282 req, 3283 metadata=self.parent.get_metadata('Groups.Delete', req), 3284 timeout=t) 3285 except Exception as e: 3286 if self.parent.shouldRetry(tries, e, deadline): 3287 tries += 1 3288 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3289 continue 3290 raise plumbing.convert_error_to_porcelain(e) from e 3291 break 3292 3293 resp = models.GroupDeleteResponse() 3294 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3295 plumbing_response.meta) 3296 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3297 plumbing_response.rate_limit) 3298 return resp 3299 3300 def list(self, filter, *args, timeout=None): 3301 ''' 3302 List gets a list of Groups matching a given set of criteria. 3303 ''' 3304 deadline = None if timeout is None else time.time() + timeout 3305 req = GroupListRequest() 3306 req.meta.CopyFrom(ListRequestMetadata()) 3307 if self.parent.page_limit > 0: 3308 req.meta.limit = self.parent.page_limit 3309 if self.parent.snapshot_datetime is not None: 3310 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3311 3312 req.filter = plumbing.quote_filter_args(filter, *args) 3313 3314 def generator(svc, req): 3315 tries = 0 3316 while True: 3317 t = None if deadline is None else deadline - time.time() 3318 try: 3319 plumbing_response = svc.stub.List( 3320 req, 3321 metadata=svc.parent.get_metadata('Groups.List', req), 3322 timeout=t) 3323 except Exception as e: 3324 if self.parent.shouldRetry(tries, e, deadline): 3325 tries += 1 3326 time.sleep( 3327 self.parent.exponentialBackoff(tries, deadline)) 3328 continue 3329 raise plumbing.convert_error_to_porcelain(e) from e 3330 tries = 0 3331 for plumbing_item in plumbing_response.groups: 3332 yield plumbing.convert_group_to_porcelain(plumbing_item) 3333 if plumbing_response.meta.next_cursor == '': 3334 break 3335 req.meta.cursor = plumbing_response.meta.next_cursor 3336 3337 return generator(self, req)
A Group is a set of principals.
See strongdm.models.Group.
def
create(self, group, timeout=None)
3134 def create(self, group, timeout=None): 3135 ''' 3136 Create registers a new Group. 3137 ''' 3138 deadline = None if timeout is None else time.time() + timeout 3139 req = GroupCreateRequest() 3140 3141 if group is not None: 3142 req.group.CopyFrom(plumbing.convert_group_to_plumbing(group)) 3143 tries = 0 3144 plumbing_response = None 3145 while True: 3146 t = None if deadline is None else deadline - time.time() 3147 try: 3148 plumbing_response = self.stub.Create( 3149 req, 3150 metadata=self.parent.get_metadata('Groups.Create', req), 3151 timeout=t) 3152 except Exception as e: 3153 if self.parent.shouldRetry(tries, e, deadline): 3154 tries += 1 3155 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3156 continue 3157 raise plumbing.convert_error_to_porcelain(e) from e 3158 break 3159 3160 resp = models.GroupCreateResponse() 3161 resp.group = plumbing.convert_group_to_porcelain( 3162 plumbing_response.group) 3163 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3164 plumbing_response.rate_limit) 3165 return resp
Create registers a new Group.
def
create_from_roles(self, role_ids, commit, timeout=None)
3167 def create_from_roles(self, role_ids, commit, timeout=None): 3168 deadline = None if timeout is None else time.time() + timeout 3169 req = GroupCreateFromRolesRequest() 3170 3171 req.role_ids.extend((role_ids)) 3172 req.commit = (commit) 3173 tries = 0 3174 plumbing_response = None 3175 while True: 3176 t = None if deadline is None else deadline - time.time() 3177 try: 3178 plumbing_response = self.stub.CreateFromRoles( 3179 req, 3180 metadata=self.parent.get_metadata('Groups.CreateFromRoles', 3181 req), 3182 timeout=t) 3183 except Exception as e: 3184 if self.parent.shouldRetry(tries, e, deadline): 3185 tries += 1 3186 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3187 continue 3188 raise plumbing.convert_error_to_porcelain(e) from e 3189 break 3190 3191 resp = models.GroupCreateFromRolesResponse() 3192 resp.group_from_role = plumbing.convert_repeated_group_from_role_to_porcelain( 3193 plumbing_response.group_from_role) 3194 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3195 plumbing_response.rate_limit) 3196 return resp
def
get(self, id, timeout=None)
3198 def get(self, id, timeout=None): 3199 ''' 3200 Get reads one Group by ID. 3201 ''' 3202 deadline = None if timeout is None else time.time() + timeout 3203 req = GroupGetRequest() 3204 if self.parent.snapshot_datetime is not None: 3205 req.meta.CopyFrom(GetRequestMetadata()) 3206 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3207 3208 req.id = (id) 3209 tries = 0 3210 plumbing_response = None 3211 while True: 3212 t = None if deadline is None else deadline - time.time() 3213 try: 3214 plumbing_response = self.stub.Get( 3215 req, 3216 metadata=self.parent.get_metadata('Groups.Get', req), 3217 timeout=t) 3218 except Exception as e: 3219 if self.parent.shouldRetry(tries, e, deadline): 3220 tries += 1 3221 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3222 continue 3223 raise plumbing.convert_error_to_porcelain(e) from e 3224 break 3225 3226 resp = models.GroupGetResponse() 3227 resp.group = plumbing.convert_group_to_porcelain( 3228 plumbing_response.group) 3229 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3230 plumbing_response.meta) 3231 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3232 plumbing_response.rate_limit) 3233 return resp
Get reads one Group by ID.
def
update(self, group, timeout=None)
3235 def update(self, group, timeout=None): 3236 ''' 3237 Update replaces all the fields of a Group by ID. 3238 ''' 3239 deadline = None if timeout is None else time.time() + timeout 3240 req = GroupUpdateRequest() 3241 3242 if group is not None: 3243 req.group.CopyFrom(plumbing.convert_group_to_plumbing(group)) 3244 tries = 0 3245 plumbing_response = None 3246 while True: 3247 t = None if deadline is None else deadline - time.time() 3248 try: 3249 plumbing_response = self.stub.Update( 3250 req, 3251 metadata=self.parent.get_metadata('Groups.Update', req), 3252 timeout=t) 3253 except Exception as e: 3254 if self.parent.shouldRetry(tries, e, deadline): 3255 tries += 1 3256 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3257 continue 3258 raise plumbing.convert_error_to_porcelain(e) from e 3259 break 3260 3261 resp = models.GroupUpdateResponse() 3262 resp.group = plumbing.convert_group_to_porcelain( 3263 plumbing_response.group) 3264 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3265 plumbing_response.rate_limit) 3266 return resp
Update replaces all the fields of a Group by ID.
def
delete(self, id, timeout=None)
3268 def delete(self, id, timeout=None): 3269 ''' 3270 Delete removes a Group by ID. 3271 ''' 3272 deadline = None if timeout is None else time.time() + timeout 3273 req = GroupDeleteRequest() 3274 3275 req.id = (id) 3276 tries = 0 3277 plumbing_response = None 3278 while True: 3279 t = None if deadline is None else deadline - time.time() 3280 try: 3281 plumbing_response = self.stub.Delete( 3282 req, 3283 metadata=self.parent.get_metadata('Groups.Delete', req), 3284 timeout=t) 3285 except Exception as e: 3286 if self.parent.shouldRetry(tries, e, deadline): 3287 tries += 1 3288 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3289 continue 3290 raise plumbing.convert_error_to_porcelain(e) from e 3291 break 3292 3293 resp = models.GroupDeleteResponse() 3294 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3295 plumbing_response.meta) 3296 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3297 plumbing_response.rate_limit) 3298 return resp
Delete removes a Group by ID.
def
list(self, filter, *args, timeout=None)
3300 def list(self, filter, *args, timeout=None): 3301 ''' 3302 List gets a list of Groups matching a given set of criteria. 3303 ''' 3304 deadline = None if timeout is None else time.time() + timeout 3305 req = GroupListRequest() 3306 req.meta.CopyFrom(ListRequestMetadata()) 3307 if self.parent.page_limit > 0: 3308 req.meta.limit = self.parent.page_limit 3309 if self.parent.snapshot_datetime is not None: 3310 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3311 3312 req.filter = plumbing.quote_filter_args(filter, *args) 3313 3314 def generator(svc, req): 3315 tries = 0 3316 while True: 3317 t = None if deadline is None else deadline - time.time() 3318 try: 3319 plumbing_response = svc.stub.List( 3320 req, 3321 metadata=svc.parent.get_metadata('Groups.List', req), 3322 timeout=t) 3323 except Exception as e: 3324 if self.parent.shouldRetry(tries, e, deadline): 3325 tries += 1 3326 time.sleep( 3327 self.parent.exponentialBackoff(tries, deadline)) 3328 continue 3329 raise plumbing.convert_error_to_porcelain(e) from e 3330 tries = 0 3331 for plumbing_item in plumbing_response.groups: 3332 yield plumbing.convert_group_to_porcelain(plumbing_item) 3333 if plumbing_response.meta.next_cursor == '': 3334 break 3335 req.meta.cursor = plumbing_response.meta.next_cursor 3336 3337 return generator(self, req)
List gets a list of Groups matching a given set of criteria.
class
SnapshotGroups:
3340class SnapshotGroups: 3341 ''' 3342 SnapshotGroups exposes the read only methods of the Groups 3343 service for historical queries. 3344 ''' 3345 def __init__(self, groups): 3346 self.groups = groups 3347 3348 def get(self, id, timeout=None): 3349 ''' 3350 Get reads one Group by ID. 3351 ''' 3352 return self.groups.get(id, timeout=timeout) 3353 3354 def list(self, filter, *args, timeout=None): 3355 ''' 3356 List gets a list of Groups matching a given set of criteria. 3357 ''' 3358 return self.groups.list(filter, *args, timeout=timeout)
SnapshotGroups exposes the read only methods of the Groups service for historical queries.
class
GroupsHistory:
3361class GroupsHistory: 3362 ''' 3363 GroupsHistory records all changes to the state of a Group. 3364 See `strongdm.models.GroupHistory`. 3365 ''' 3366 def __init__(self, channel, client): 3367 self.parent = client 3368 self.stub = GroupsHistoryStub(channel) 3369 3370 def list(self, filter, *args, timeout=None): 3371 ''' 3372 List gets a list of GroupHistory records matching a given set of criteria. 3373 ''' 3374 deadline = None if timeout is None else time.time() + timeout 3375 req = GroupHistoryListRequest() 3376 req.meta.CopyFrom(ListRequestMetadata()) 3377 if self.parent.page_limit > 0: 3378 req.meta.limit = self.parent.page_limit 3379 if self.parent.snapshot_datetime is not None: 3380 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3381 3382 req.filter = plumbing.quote_filter_args(filter, *args) 3383 3384 def generator(svc, req): 3385 tries = 0 3386 while True: 3387 t = None if deadline is None else deadline - time.time() 3388 try: 3389 plumbing_response = svc.stub.List( 3390 req, 3391 metadata=svc.parent.get_metadata( 3392 'GroupsHistory.List', req), 3393 timeout=t) 3394 except Exception as e: 3395 if self.parent.shouldRetry(tries, e, deadline): 3396 tries += 1 3397 time.sleep( 3398 self.parent.exponentialBackoff(tries, deadline)) 3399 continue 3400 raise plumbing.convert_error_to_porcelain(e) from e 3401 tries = 0 3402 for plumbing_item in plumbing_response.history: 3403 yield plumbing.convert_group_history_to_porcelain( 3404 plumbing_item) 3405 if plumbing_response.meta.next_cursor == '': 3406 break 3407 req.meta.cursor = plumbing_response.meta.next_cursor 3408 3409 return generator(self, req)
GroupsHistory records all changes to the state of a Group.
See strongdm.models.GroupHistory.
def
list(self, filter, *args, timeout=None)
3370 def list(self, filter, *args, timeout=None): 3371 ''' 3372 List gets a list of GroupHistory records matching a given set of criteria. 3373 ''' 3374 deadline = None if timeout is None else time.time() + timeout 3375 req = GroupHistoryListRequest() 3376 req.meta.CopyFrom(ListRequestMetadata()) 3377 if self.parent.page_limit > 0: 3378 req.meta.limit = self.parent.page_limit 3379 if self.parent.snapshot_datetime is not None: 3380 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3381 3382 req.filter = plumbing.quote_filter_args(filter, *args) 3383 3384 def generator(svc, req): 3385 tries = 0 3386 while True: 3387 t = None if deadline is None else deadline - time.time() 3388 try: 3389 plumbing_response = svc.stub.List( 3390 req, 3391 metadata=svc.parent.get_metadata( 3392 'GroupsHistory.List', req), 3393 timeout=t) 3394 except Exception as e: 3395 if self.parent.shouldRetry(tries, e, deadline): 3396 tries += 1 3397 time.sleep( 3398 self.parent.exponentialBackoff(tries, deadline)) 3399 continue 3400 raise plumbing.convert_error_to_porcelain(e) from e 3401 tries = 0 3402 for plumbing_item in plumbing_response.history: 3403 yield plumbing.convert_group_history_to_porcelain( 3404 plumbing_item) 3405 if plumbing_response.meta.next_cursor == '': 3406 break 3407 req.meta.cursor = plumbing_response.meta.next_cursor 3408 3409 return generator(self, req)
List gets a list of GroupHistory records matching a given set of criteria.
class
GroupsRoles:
3412class GroupsRoles: 3413 ''' 3414 A GroupRole is an assignment of a Group to a Role. 3415 See `strongdm.models.GroupRole`. 3416 ''' 3417 def __init__(self, channel, client): 3418 self.parent = client 3419 self.stub = GroupsRolesStub(channel) 3420 3421 def create(self, group_role, timeout=None): 3422 ''' 3423 Create registers a new GroupRole. 3424 ''' 3425 deadline = None if timeout is None else time.time() + timeout 3426 req = GroupRoleCreateRequest() 3427 3428 if group_role is not None: 3429 req.group_role.CopyFrom( 3430 plumbing.convert_group_role_to_plumbing(group_role)) 3431 tries = 0 3432 plumbing_response = None 3433 while True: 3434 t = None if deadline is None else deadline - time.time() 3435 try: 3436 plumbing_response = self.stub.Create( 3437 req, 3438 metadata=self.parent.get_metadata('GroupsRoles.Create', 3439 req), 3440 timeout=t) 3441 except Exception as e: 3442 if self.parent.shouldRetry(tries, e, deadline): 3443 tries += 1 3444 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3445 continue 3446 raise plumbing.convert_error_to_porcelain(e) from e 3447 break 3448 3449 resp = models.GroupRoleCreateResponse() 3450 resp.group_role = plumbing.convert_group_role_to_porcelain( 3451 plumbing_response.group_role) 3452 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3453 plumbing_response.rate_limit) 3454 return resp 3455 3456 def get(self, id, timeout=None): 3457 ''' 3458 Get reads one GroupRole by ID. 3459 ''' 3460 deadline = None if timeout is None else time.time() + timeout 3461 req = GroupRoleGetRequest() 3462 if self.parent.snapshot_datetime is not None: 3463 req.meta.CopyFrom(GetRequestMetadata()) 3464 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3465 3466 req.id = (id) 3467 tries = 0 3468 plumbing_response = None 3469 while True: 3470 t = None if deadline is None else deadline - time.time() 3471 try: 3472 plumbing_response = self.stub.Get( 3473 req, 3474 metadata=self.parent.get_metadata('GroupsRoles.Get', req), 3475 timeout=t) 3476 except Exception as e: 3477 if self.parent.shouldRetry(tries, e, deadline): 3478 tries += 1 3479 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3480 continue 3481 raise plumbing.convert_error_to_porcelain(e) from e 3482 break 3483 3484 resp = models.GroupRoleGetResponse() 3485 resp.group_role = plumbing.convert_group_role_to_porcelain( 3486 plumbing_response.group_role) 3487 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3488 plumbing_response.meta) 3489 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3490 plumbing_response.rate_limit) 3491 return resp 3492 3493 def delete(self, id, timeout=None): 3494 ''' 3495 Delete removes a GroupRole by ID. 3496 ''' 3497 deadline = None if timeout is None else time.time() + timeout 3498 req = GroupRoleDeleteRequest() 3499 3500 req.id = (id) 3501 tries = 0 3502 plumbing_response = None 3503 while True: 3504 t = None if deadline is None else deadline - time.time() 3505 try: 3506 plumbing_response = self.stub.Delete( 3507 req, 3508 metadata=self.parent.get_metadata('GroupsRoles.Delete', 3509 req), 3510 timeout=t) 3511 except Exception as e: 3512 if self.parent.shouldRetry(tries, e, deadline): 3513 tries += 1 3514 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3515 continue 3516 raise plumbing.convert_error_to_porcelain(e) from e 3517 break 3518 3519 resp = models.GroupRoleDeleteResponse() 3520 resp.group_role = plumbing.convert_group_role_to_porcelain( 3521 plumbing_response.group_role) 3522 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3523 plumbing_response.meta) 3524 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3525 plumbing_response.rate_limit) 3526 return resp 3527 3528 def list(self, filter, *args, timeout=None): 3529 ''' 3530 List gets a list of GroupRoles matching a given set of criteria. 3531 ''' 3532 deadline = None if timeout is None else time.time() + timeout 3533 req = GroupRoleListRequest() 3534 req.meta.CopyFrom(ListRequestMetadata()) 3535 if self.parent.page_limit > 0: 3536 req.meta.limit = self.parent.page_limit 3537 if self.parent.snapshot_datetime is not None: 3538 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3539 3540 req.filter = plumbing.quote_filter_args(filter, *args) 3541 3542 def generator(svc, req): 3543 tries = 0 3544 while True: 3545 t = None if deadline is None else deadline - time.time() 3546 try: 3547 plumbing_response = svc.stub.List( 3548 req, 3549 metadata=svc.parent.get_metadata( 3550 'GroupsRoles.List', req), 3551 timeout=t) 3552 except Exception as e: 3553 if self.parent.shouldRetry(tries, e, deadline): 3554 tries += 1 3555 time.sleep( 3556 self.parent.exponentialBackoff(tries, deadline)) 3557 continue 3558 raise plumbing.convert_error_to_porcelain(e) from e 3559 tries = 0 3560 for plumbing_item in plumbing_response.groups_roles: 3561 yield plumbing.convert_group_role_to_porcelain( 3562 plumbing_item) 3563 if plumbing_response.meta.next_cursor == '': 3564 break 3565 req.meta.cursor = plumbing_response.meta.next_cursor 3566 3567 return generator(self, req)
A GroupRole is an assignment of a Group to a Role.
See strongdm.models.GroupRole.
def
create(self, group_role, timeout=None)
3421 def create(self, group_role, timeout=None): 3422 ''' 3423 Create registers a new GroupRole. 3424 ''' 3425 deadline = None if timeout is None else time.time() + timeout 3426 req = GroupRoleCreateRequest() 3427 3428 if group_role is not None: 3429 req.group_role.CopyFrom( 3430 plumbing.convert_group_role_to_plumbing(group_role)) 3431 tries = 0 3432 plumbing_response = None 3433 while True: 3434 t = None if deadline is None else deadline - time.time() 3435 try: 3436 plumbing_response = self.stub.Create( 3437 req, 3438 metadata=self.parent.get_metadata('GroupsRoles.Create', 3439 req), 3440 timeout=t) 3441 except Exception as e: 3442 if self.parent.shouldRetry(tries, e, deadline): 3443 tries += 1 3444 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3445 continue 3446 raise plumbing.convert_error_to_porcelain(e) from e 3447 break 3448 3449 resp = models.GroupRoleCreateResponse() 3450 resp.group_role = plumbing.convert_group_role_to_porcelain( 3451 plumbing_response.group_role) 3452 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3453 plumbing_response.rate_limit) 3454 return resp
Create registers a new GroupRole.
def
get(self, id, timeout=None)
3456 def get(self, id, timeout=None): 3457 ''' 3458 Get reads one GroupRole by ID. 3459 ''' 3460 deadline = None if timeout is None else time.time() + timeout 3461 req = GroupRoleGetRequest() 3462 if self.parent.snapshot_datetime is not None: 3463 req.meta.CopyFrom(GetRequestMetadata()) 3464 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3465 3466 req.id = (id) 3467 tries = 0 3468 plumbing_response = None 3469 while True: 3470 t = None if deadline is None else deadline - time.time() 3471 try: 3472 plumbing_response = self.stub.Get( 3473 req, 3474 metadata=self.parent.get_metadata('GroupsRoles.Get', req), 3475 timeout=t) 3476 except Exception as e: 3477 if self.parent.shouldRetry(tries, e, deadline): 3478 tries += 1 3479 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3480 continue 3481 raise plumbing.convert_error_to_porcelain(e) from e 3482 break 3483 3484 resp = models.GroupRoleGetResponse() 3485 resp.group_role = plumbing.convert_group_role_to_porcelain( 3486 plumbing_response.group_role) 3487 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3488 plumbing_response.meta) 3489 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3490 plumbing_response.rate_limit) 3491 return resp
Get reads one GroupRole by ID.
def
delete(self, id, timeout=None)
3493 def delete(self, id, timeout=None): 3494 ''' 3495 Delete removes a GroupRole by ID. 3496 ''' 3497 deadline = None if timeout is None else time.time() + timeout 3498 req = GroupRoleDeleteRequest() 3499 3500 req.id = (id) 3501 tries = 0 3502 plumbing_response = None 3503 while True: 3504 t = None if deadline is None else deadline - time.time() 3505 try: 3506 plumbing_response = self.stub.Delete( 3507 req, 3508 metadata=self.parent.get_metadata('GroupsRoles.Delete', 3509 req), 3510 timeout=t) 3511 except Exception as e: 3512 if self.parent.shouldRetry(tries, e, deadline): 3513 tries += 1 3514 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3515 continue 3516 raise plumbing.convert_error_to_porcelain(e) from e 3517 break 3518 3519 resp = models.GroupRoleDeleteResponse() 3520 resp.group_role = plumbing.convert_group_role_to_porcelain( 3521 plumbing_response.group_role) 3522 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3523 plumbing_response.meta) 3524 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3525 plumbing_response.rate_limit) 3526 return resp
Delete removes a GroupRole by ID.
def
list(self, filter, *args, timeout=None)
3528 def list(self, filter, *args, timeout=None): 3529 ''' 3530 List gets a list of GroupRoles matching a given set of criteria. 3531 ''' 3532 deadline = None if timeout is None else time.time() + timeout 3533 req = GroupRoleListRequest() 3534 req.meta.CopyFrom(ListRequestMetadata()) 3535 if self.parent.page_limit > 0: 3536 req.meta.limit = self.parent.page_limit 3537 if self.parent.snapshot_datetime is not None: 3538 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3539 3540 req.filter = plumbing.quote_filter_args(filter, *args) 3541 3542 def generator(svc, req): 3543 tries = 0 3544 while True: 3545 t = None if deadline is None else deadline - time.time() 3546 try: 3547 plumbing_response = svc.stub.List( 3548 req, 3549 metadata=svc.parent.get_metadata( 3550 'GroupsRoles.List', req), 3551 timeout=t) 3552 except Exception as e: 3553 if self.parent.shouldRetry(tries, e, deadline): 3554 tries += 1 3555 time.sleep( 3556 self.parent.exponentialBackoff(tries, deadline)) 3557 continue 3558 raise plumbing.convert_error_to_porcelain(e) from e 3559 tries = 0 3560 for plumbing_item in plumbing_response.groups_roles: 3561 yield plumbing.convert_group_role_to_porcelain( 3562 plumbing_item) 3563 if plumbing_response.meta.next_cursor == '': 3564 break 3565 req.meta.cursor = plumbing_response.meta.next_cursor 3566 3567 return generator(self, req)
List gets a list of GroupRoles matching a given set of criteria.
class
SnapshotGroupsRoles:
3570class SnapshotGroupsRoles: 3571 ''' 3572 SnapshotGroupsRoles exposes the read only methods of the GroupsRoles 3573 service for historical queries. 3574 ''' 3575 def __init__(self, groups_roles): 3576 self.groups_roles = groups_roles 3577 3578 def get(self, id, timeout=None): 3579 ''' 3580 Get reads one GroupRole by ID. 3581 ''' 3582 return self.groups_roles.get(id, timeout=timeout) 3583 3584 def list(self, filter, *args, timeout=None): 3585 ''' 3586 List gets a list of GroupRoles matching a given set of criteria. 3587 ''' 3588 return self.groups_roles.list(filter, *args, timeout=timeout)
SnapshotGroupsRoles exposes the read only methods of the GroupsRoles service for historical queries.
def
get(self, id, timeout=None)
3578 def get(self, id, timeout=None): 3579 ''' 3580 Get reads one GroupRole by ID. 3581 ''' 3582 return self.groups_roles.get(id, timeout=timeout)
Get reads one GroupRole by ID.
def
list(self, filter, *args, timeout=None)
3584 def list(self, filter, *args, timeout=None): 3585 ''' 3586 List gets a list of GroupRoles matching a given set of criteria. 3587 ''' 3588 return self.groups_roles.list(filter, *args, timeout=timeout)
List gets a list of GroupRoles matching a given set of criteria.
class
GroupsRolesHistory:
3591class GroupsRolesHistory: 3592 ''' 3593 GroupsRolesHistory records all changes to the state of a GroupRole. 3594 See `strongdm.models.GroupRoleHistory`. 3595 ''' 3596 def __init__(self, channel, client): 3597 self.parent = client 3598 self.stub = GroupsRolesHistoryStub(channel) 3599 3600 def list(self, filter, *args, timeout=None): 3601 ''' 3602 List gets a list of GroupRoleHistory records matching a given set of criteria. 3603 ''' 3604 deadline = None if timeout is None else time.time() + timeout 3605 req = GroupRoleHistoryListRequest() 3606 req.meta.CopyFrom(ListRequestMetadata()) 3607 if self.parent.page_limit > 0: 3608 req.meta.limit = self.parent.page_limit 3609 if self.parent.snapshot_datetime is not None: 3610 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3611 3612 req.filter = plumbing.quote_filter_args(filter, *args) 3613 3614 def generator(svc, req): 3615 tries = 0 3616 while True: 3617 t = None if deadline is None else deadline - time.time() 3618 try: 3619 plumbing_response = svc.stub.List( 3620 req, 3621 metadata=svc.parent.get_metadata( 3622 'GroupsRolesHistory.List', req), 3623 timeout=t) 3624 except Exception as e: 3625 if self.parent.shouldRetry(tries, e, deadline): 3626 tries += 1 3627 time.sleep( 3628 self.parent.exponentialBackoff(tries, deadline)) 3629 continue 3630 raise plumbing.convert_error_to_porcelain(e) from e 3631 tries = 0 3632 for plumbing_item in plumbing_response.history: 3633 yield plumbing.convert_group_role_history_to_porcelain( 3634 plumbing_item) 3635 if plumbing_response.meta.next_cursor == '': 3636 break 3637 req.meta.cursor = plumbing_response.meta.next_cursor 3638 3639 return generator(self, req)
GroupsRolesHistory records all changes to the state of a GroupRole.
See strongdm.models.GroupRoleHistory.
def
list(self, filter, *args, timeout=None)
3600 def list(self, filter, *args, timeout=None): 3601 ''' 3602 List gets a list of GroupRoleHistory records matching a given set of criteria. 3603 ''' 3604 deadline = None if timeout is None else time.time() + timeout 3605 req = GroupRoleHistoryListRequest() 3606 req.meta.CopyFrom(ListRequestMetadata()) 3607 if self.parent.page_limit > 0: 3608 req.meta.limit = self.parent.page_limit 3609 if self.parent.snapshot_datetime is not None: 3610 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3611 3612 req.filter = plumbing.quote_filter_args(filter, *args) 3613 3614 def generator(svc, req): 3615 tries = 0 3616 while True: 3617 t = None if deadline is None else deadline - time.time() 3618 try: 3619 plumbing_response = svc.stub.List( 3620 req, 3621 metadata=svc.parent.get_metadata( 3622 'GroupsRolesHistory.List', req), 3623 timeout=t) 3624 except Exception as e: 3625 if self.parent.shouldRetry(tries, e, deadline): 3626 tries += 1 3627 time.sleep( 3628 self.parent.exponentialBackoff(tries, deadline)) 3629 continue 3630 raise plumbing.convert_error_to_porcelain(e) from e 3631 tries = 0 3632 for plumbing_item in plumbing_response.history: 3633 yield plumbing.convert_group_role_history_to_porcelain( 3634 plumbing_item) 3635 if plumbing_response.meta.next_cursor == '': 3636 break 3637 req.meta.cursor = plumbing_response.meta.next_cursor 3638 3639 return generator(self, req)
List gets a list of GroupRoleHistory records matching a given set of criteria.
class
HealthChecks:
3642class HealthChecks: 3643 ''' 3644 HealthChecks lists the last healthcheck between each node and resource. 3645 Note the unconventional capitalization here is to prevent having a collision with GRPC 3646 See `strongdm.models.Healthcheck`. 3647 ''' 3648 def __init__(self, channel, client): 3649 self.parent = client 3650 self.stub = HealthChecksStub(channel) 3651 3652 def list(self, filter, *args, timeout=None): 3653 ''' 3654 List gets a list of Healthchecks matching a given set of criteria. 3655 ''' 3656 deadline = None if timeout is None else time.time() + timeout 3657 req = HealthcheckListRequest() 3658 req.meta.CopyFrom(ListRequestMetadata()) 3659 if self.parent.page_limit > 0: 3660 req.meta.limit = self.parent.page_limit 3661 if self.parent.snapshot_datetime is not None: 3662 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3663 3664 req.filter = plumbing.quote_filter_args(filter, *args) 3665 3666 def generator(svc, req): 3667 tries = 0 3668 while True: 3669 t = None if deadline is None else deadline - time.time() 3670 try: 3671 plumbing_response = svc.stub.List( 3672 req, 3673 metadata=svc.parent.get_metadata( 3674 'HealthChecks.List', req), 3675 timeout=t) 3676 except Exception as e: 3677 if self.parent.shouldRetry(tries, e, deadline): 3678 tries += 1 3679 time.sleep( 3680 self.parent.exponentialBackoff(tries, deadline)) 3681 continue 3682 raise plumbing.convert_error_to_porcelain(e) from e 3683 tries = 0 3684 for plumbing_item in plumbing_response.healthchecks: 3685 yield plumbing.convert_healthcheck_to_porcelain( 3686 plumbing_item) 3687 if plumbing_response.meta.next_cursor == '': 3688 break 3689 req.meta.cursor = plumbing_response.meta.next_cursor 3690 3691 return generator(self, req)
HealthChecks lists the last healthcheck between each node and resource.
Note the unconventional capitalization here is to prevent having a collision with GRPC
See strongdm.models.Healthcheck.
def
list(self, filter, *args, timeout=None)
3652 def list(self, filter, *args, timeout=None): 3653 ''' 3654 List gets a list of Healthchecks matching a given set of criteria. 3655 ''' 3656 deadline = None if timeout is None else time.time() + timeout 3657 req = HealthcheckListRequest() 3658 req.meta.CopyFrom(ListRequestMetadata()) 3659 if self.parent.page_limit > 0: 3660 req.meta.limit = self.parent.page_limit 3661 if self.parent.snapshot_datetime is not None: 3662 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3663 3664 req.filter = plumbing.quote_filter_args(filter, *args) 3665 3666 def generator(svc, req): 3667 tries = 0 3668 while True: 3669 t = None if deadline is None else deadline - time.time() 3670 try: 3671 plumbing_response = svc.stub.List( 3672 req, 3673 metadata=svc.parent.get_metadata( 3674 'HealthChecks.List', req), 3675 timeout=t) 3676 except Exception as e: 3677 if self.parent.shouldRetry(tries, e, deadline): 3678 tries += 1 3679 time.sleep( 3680 self.parent.exponentialBackoff(tries, deadline)) 3681 continue 3682 raise plumbing.convert_error_to_porcelain(e) from e 3683 tries = 0 3684 for plumbing_item in plumbing_response.healthchecks: 3685 yield plumbing.convert_healthcheck_to_porcelain( 3686 plumbing_item) 3687 if plumbing_response.meta.next_cursor == '': 3688 break 3689 req.meta.cursor = plumbing_response.meta.next_cursor 3690 3691 return generator(self, req)
List gets a list of Healthchecks matching a given set of criteria.
class
IdentityAliases:
3694class IdentityAliases: 3695 ''' 3696 IdentityAliases assign an alias to an account within an IdentitySet. 3697 The alias is used as the username when connecting to a identity supported resource. 3698 See `strongdm.models.IdentityAlias`. 3699 ''' 3700 def __init__(self, channel, client): 3701 self.parent = client 3702 self.stub = IdentityAliasesStub(channel) 3703 3704 def create(self, identity_alias, timeout=None): 3705 ''' 3706 Create registers a new IdentityAlias. 3707 ''' 3708 deadline = None if timeout is None else time.time() + timeout 3709 req = IdentityAliasCreateRequest() 3710 3711 if identity_alias is not None: 3712 req.identity_alias.CopyFrom( 3713 plumbing.convert_identity_alias_to_plumbing(identity_alias)) 3714 tries = 0 3715 plumbing_response = None 3716 while True: 3717 t = None if deadline is None else deadline - time.time() 3718 try: 3719 plumbing_response = self.stub.Create( 3720 req, 3721 metadata=self.parent.get_metadata('IdentityAliases.Create', 3722 req), 3723 timeout=t) 3724 except Exception as e: 3725 if self.parent.shouldRetry(tries, e, deadline): 3726 tries += 1 3727 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3728 continue 3729 raise plumbing.convert_error_to_porcelain(e) from e 3730 break 3731 3732 resp = models.IdentityAliasCreateResponse() 3733 resp.identity_alias = plumbing.convert_identity_alias_to_porcelain( 3734 plumbing_response.identity_alias) 3735 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 3736 plumbing_response.meta) 3737 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3738 plumbing_response.rate_limit) 3739 return resp 3740 3741 def get(self, id, timeout=None): 3742 ''' 3743 Get reads one IdentityAlias by ID. 3744 ''' 3745 deadline = None if timeout is None else time.time() + timeout 3746 req = IdentityAliasGetRequest() 3747 if self.parent.snapshot_datetime is not None: 3748 req.meta.CopyFrom(GetRequestMetadata()) 3749 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3750 3751 req.id = (id) 3752 tries = 0 3753 plumbing_response = None 3754 while True: 3755 t = None if deadline is None else deadline - time.time() 3756 try: 3757 plumbing_response = self.stub.Get( 3758 req, 3759 metadata=self.parent.get_metadata('IdentityAliases.Get', 3760 req), 3761 timeout=t) 3762 except Exception as e: 3763 if self.parent.shouldRetry(tries, e, deadline): 3764 tries += 1 3765 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3766 continue 3767 raise plumbing.convert_error_to_porcelain(e) from e 3768 break 3769 3770 resp = models.IdentityAliasGetResponse() 3771 resp.identity_alias = plumbing.convert_identity_alias_to_porcelain( 3772 plumbing_response.identity_alias) 3773 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3774 plumbing_response.meta) 3775 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3776 plumbing_response.rate_limit) 3777 return resp 3778 3779 def update(self, identity_alias, timeout=None): 3780 ''' 3781 Update replaces all the fields of a IdentityAlias by ID. 3782 ''' 3783 deadline = None if timeout is None else time.time() + timeout 3784 req = IdentityAliasUpdateRequest() 3785 3786 if identity_alias is not None: 3787 req.identity_alias.CopyFrom( 3788 plumbing.convert_identity_alias_to_plumbing(identity_alias)) 3789 tries = 0 3790 plumbing_response = None 3791 while True: 3792 t = None if deadline is None else deadline - time.time() 3793 try: 3794 plumbing_response = self.stub.Update( 3795 req, 3796 metadata=self.parent.get_metadata('IdentityAliases.Update', 3797 req), 3798 timeout=t) 3799 except Exception as e: 3800 if self.parent.shouldRetry(tries, e, deadline): 3801 tries += 1 3802 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3803 continue 3804 raise plumbing.convert_error_to_porcelain(e) from e 3805 break 3806 3807 resp = models.IdentityAliasUpdateResponse() 3808 resp.identity_alias = plumbing.convert_identity_alias_to_porcelain( 3809 plumbing_response.identity_alias) 3810 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 3811 plumbing_response.meta) 3812 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3813 plumbing_response.rate_limit) 3814 return resp 3815 3816 def delete(self, id, timeout=None): 3817 ''' 3818 Delete removes a IdentityAlias by ID. 3819 ''' 3820 deadline = None if timeout is None else time.time() + timeout 3821 req = IdentityAliasDeleteRequest() 3822 3823 req.id = (id) 3824 tries = 0 3825 plumbing_response = None 3826 while True: 3827 t = None if deadline is None else deadline - time.time() 3828 try: 3829 plumbing_response = self.stub.Delete( 3830 req, 3831 metadata=self.parent.get_metadata('IdentityAliases.Delete', 3832 req), 3833 timeout=t) 3834 except Exception as e: 3835 if self.parent.shouldRetry(tries, e, deadline): 3836 tries += 1 3837 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3838 continue 3839 raise plumbing.convert_error_to_porcelain(e) from e 3840 break 3841 3842 resp = models.IdentityAliasDeleteResponse() 3843 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3844 plumbing_response.meta) 3845 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3846 plumbing_response.rate_limit) 3847 return resp 3848 3849 def list(self, filter, *args, timeout=None): 3850 ''' 3851 List gets a list of IdentityAliases matching a given set of criteria. 3852 ''' 3853 deadline = None if timeout is None else time.time() + timeout 3854 req = IdentityAliasListRequest() 3855 req.meta.CopyFrom(ListRequestMetadata()) 3856 if self.parent.page_limit > 0: 3857 req.meta.limit = self.parent.page_limit 3858 if self.parent.snapshot_datetime is not None: 3859 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3860 3861 req.filter = plumbing.quote_filter_args(filter, *args) 3862 3863 def generator(svc, req): 3864 tries = 0 3865 while True: 3866 t = None if deadline is None else deadline - time.time() 3867 try: 3868 plumbing_response = svc.stub.List( 3869 req, 3870 metadata=svc.parent.get_metadata( 3871 'IdentityAliases.List', req), 3872 timeout=t) 3873 except Exception as e: 3874 if self.parent.shouldRetry(tries, e, deadline): 3875 tries += 1 3876 time.sleep( 3877 self.parent.exponentialBackoff(tries, deadline)) 3878 continue 3879 raise plumbing.convert_error_to_porcelain(e) from e 3880 tries = 0 3881 for plumbing_item in plumbing_response.identity_aliases: 3882 yield plumbing.convert_identity_alias_to_porcelain( 3883 plumbing_item) 3884 if plumbing_response.meta.next_cursor == '': 3885 break 3886 req.meta.cursor = plumbing_response.meta.next_cursor 3887 3888 return generator(self, req)
IdentityAliases assign an alias to an account within an IdentitySet.
The alias is used as the username when connecting to a identity supported resource.
See strongdm.models.IdentityAlias.
def
create(self, identity_alias, timeout=None)
3704 def create(self, identity_alias, timeout=None): 3705 ''' 3706 Create registers a new IdentityAlias. 3707 ''' 3708 deadline = None if timeout is None else time.time() + timeout 3709 req = IdentityAliasCreateRequest() 3710 3711 if identity_alias is not None: 3712 req.identity_alias.CopyFrom( 3713 plumbing.convert_identity_alias_to_plumbing(identity_alias)) 3714 tries = 0 3715 plumbing_response = None 3716 while True: 3717 t = None if deadline is None else deadline - time.time() 3718 try: 3719 plumbing_response = self.stub.Create( 3720 req, 3721 metadata=self.parent.get_metadata('IdentityAliases.Create', 3722 req), 3723 timeout=t) 3724 except Exception as e: 3725 if self.parent.shouldRetry(tries, e, deadline): 3726 tries += 1 3727 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3728 continue 3729 raise plumbing.convert_error_to_porcelain(e) from e 3730 break 3731 3732 resp = models.IdentityAliasCreateResponse() 3733 resp.identity_alias = plumbing.convert_identity_alias_to_porcelain( 3734 plumbing_response.identity_alias) 3735 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 3736 plumbing_response.meta) 3737 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3738 plumbing_response.rate_limit) 3739 return resp
Create registers a new IdentityAlias.
def
get(self, id, timeout=None)
3741 def get(self, id, timeout=None): 3742 ''' 3743 Get reads one IdentityAlias by ID. 3744 ''' 3745 deadline = None if timeout is None else time.time() + timeout 3746 req = IdentityAliasGetRequest() 3747 if self.parent.snapshot_datetime is not None: 3748 req.meta.CopyFrom(GetRequestMetadata()) 3749 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3750 3751 req.id = (id) 3752 tries = 0 3753 plumbing_response = None 3754 while True: 3755 t = None if deadline is None else deadline - time.time() 3756 try: 3757 plumbing_response = self.stub.Get( 3758 req, 3759 metadata=self.parent.get_metadata('IdentityAliases.Get', 3760 req), 3761 timeout=t) 3762 except Exception as e: 3763 if self.parent.shouldRetry(tries, e, deadline): 3764 tries += 1 3765 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3766 continue 3767 raise plumbing.convert_error_to_porcelain(e) from e 3768 break 3769 3770 resp = models.IdentityAliasGetResponse() 3771 resp.identity_alias = plumbing.convert_identity_alias_to_porcelain( 3772 plumbing_response.identity_alias) 3773 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3774 plumbing_response.meta) 3775 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3776 plumbing_response.rate_limit) 3777 return resp
Get reads one IdentityAlias by ID.
def
update(self, identity_alias, timeout=None)
3779 def update(self, identity_alias, timeout=None): 3780 ''' 3781 Update replaces all the fields of a IdentityAlias by ID. 3782 ''' 3783 deadline = None if timeout is None else time.time() + timeout 3784 req = IdentityAliasUpdateRequest() 3785 3786 if identity_alias is not None: 3787 req.identity_alias.CopyFrom( 3788 plumbing.convert_identity_alias_to_plumbing(identity_alias)) 3789 tries = 0 3790 plumbing_response = None 3791 while True: 3792 t = None if deadline is None else deadline - time.time() 3793 try: 3794 plumbing_response = self.stub.Update( 3795 req, 3796 metadata=self.parent.get_metadata('IdentityAliases.Update', 3797 req), 3798 timeout=t) 3799 except Exception as e: 3800 if self.parent.shouldRetry(tries, e, deadline): 3801 tries += 1 3802 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3803 continue 3804 raise plumbing.convert_error_to_porcelain(e) from e 3805 break 3806 3807 resp = models.IdentityAliasUpdateResponse() 3808 resp.identity_alias = plumbing.convert_identity_alias_to_porcelain( 3809 plumbing_response.identity_alias) 3810 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 3811 plumbing_response.meta) 3812 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3813 plumbing_response.rate_limit) 3814 return resp
Update replaces all the fields of a IdentityAlias by ID.
def
delete(self, id, timeout=None)
3816 def delete(self, id, timeout=None): 3817 ''' 3818 Delete removes a IdentityAlias by ID. 3819 ''' 3820 deadline = None if timeout is None else time.time() + timeout 3821 req = IdentityAliasDeleteRequest() 3822 3823 req.id = (id) 3824 tries = 0 3825 plumbing_response = None 3826 while True: 3827 t = None if deadline is None else deadline - time.time() 3828 try: 3829 plumbing_response = self.stub.Delete( 3830 req, 3831 metadata=self.parent.get_metadata('IdentityAliases.Delete', 3832 req), 3833 timeout=t) 3834 except Exception as e: 3835 if self.parent.shouldRetry(tries, e, deadline): 3836 tries += 1 3837 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3838 continue 3839 raise plumbing.convert_error_to_porcelain(e) from e 3840 break 3841 3842 resp = models.IdentityAliasDeleteResponse() 3843 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3844 plumbing_response.meta) 3845 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3846 plumbing_response.rate_limit) 3847 return resp
Delete removes a IdentityAlias by ID.
def
list(self, filter, *args, timeout=None)
3849 def list(self, filter, *args, timeout=None): 3850 ''' 3851 List gets a list of IdentityAliases matching a given set of criteria. 3852 ''' 3853 deadline = None if timeout is None else time.time() + timeout 3854 req = IdentityAliasListRequest() 3855 req.meta.CopyFrom(ListRequestMetadata()) 3856 if self.parent.page_limit > 0: 3857 req.meta.limit = self.parent.page_limit 3858 if self.parent.snapshot_datetime is not None: 3859 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3860 3861 req.filter = plumbing.quote_filter_args(filter, *args) 3862 3863 def generator(svc, req): 3864 tries = 0 3865 while True: 3866 t = None if deadline is None else deadline - time.time() 3867 try: 3868 plumbing_response = svc.stub.List( 3869 req, 3870 metadata=svc.parent.get_metadata( 3871 'IdentityAliases.List', req), 3872 timeout=t) 3873 except Exception as e: 3874 if self.parent.shouldRetry(tries, e, deadline): 3875 tries += 1 3876 time.sleep( 3877 self.parent.exponentialBackoff(tries, deadline)) 3878 continue 3879 raise plumbing.convert_error_to_porcelain(e) from e 3880 tries = 0 3881 for plumbing_item in plumbing_response.identity_aliases: 3882 yield plumbing.convert_identity_alias_to_porcelain( 3883 plumbing_item) 3884 if plumbing_response.meta.next_cursor == '': 3885 break 3886 req.meta.cursor = plumbing_response.meta.next_cursor 3887 3888 return generator(self, req)
List gets a list of IdentityAliases matching a given set of criteria.
class
SnapshotIdentityAliases:
3891class SnapshotIdentityAliases: 3892 ''' 3893 SnapshotIdentityAliases exposes the read only methods of the IdentityAliases 3894 service for historical queries. 3895 ''' 3896 def __init__(self, identity_aliases): 3897 self.identity_aliases = identity_aliases 3898 3899 def get(self, id, timeout=None): 3900 ''' 3901 Get reads one IdentityAlias by ID. 3902 ''' 3903 return self.identity_aliases.get(id, timeout=timeout) 3904 3905 def list(self, filter, *args, timeout=None): 3906 ''' 3907 List gets a list of IdentityAliases matching a given set of criteria. 3908 ''' 3909 return self.identity_aliases.list(filter, *args, timeout=timeout)
SnapshotIdentityAliases exposes the read only methods of the IdentityAliases service for historical queries.
def
get(self, id, timeout=None)
3899 def get(self, id, timeout=None): 3900 ''' 3901 Get reads one IdentityAlias by ID. 3902 ''' 3903 return self.identity_aliases.get(id, timeout=timeout)
Get reads one IdentityAlias by ID.
def
list(self, filter, *args, timeout=None)
3905 def list(self, filter, *args, timeout=None): 3906 ''' 3907 List gets a list of IdentityAliases matching a given set of criteria. 3908 ''' 3909 return self.identity_aliases.list(filter, *args, timeout=timeout)
List gets a list of IdentityAliases matching a given set of criteria.
class
IdentityAliasesHistory:
3912class IdentityAliasesHistory: 3913 ''' 3914 IdentityAliasesHistory records all changes to the state of a IdentityAlias. 3915 See `strongdm.models.IdentityAliasHistory`. 3916 ''' 3917 def __init__(self, channel, client): 3918 self.parent = client 3919 self.stub = IdentityAliasesHistoryStub(channel) 3920 3921 def list(self, filter, *args, timeout=None): 3922 ''' 3923 List gets a list of IdentityAliasHistory records matching a given set of criteria. 3924 ''' 3925 deadline = None if timeout is None else time.time() + timeout 3926 req = IdentityAliasHistoryListRequest() 3927 req.meta.CopyFrom(ListRequestMetadata()) 3928 if self.parent.page_limit > 0: 3929 req.meta.limit = self.parent.page_limit 3930 if self.parent.snapshot_datetime is not None: 3931 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3932 3933 req.filter = plumbing.quote_filter_args(filter, *args) 3934 3935 def generator(svc, req): 3936 tries = 0 3937 while True: 3938 t = None if deadline is None else deadline - time.time() 3939 try: 3940 plumbing_response = svc.stub.List( 3941 req, 3942 metadata=svc.parent.get_metadata( 3943 'IdentityAliasesHistory.List', req), 3944 timeout=t) 3945 except Exception as e: 3946 if self.parent.shouldRetry(tries, e, deadline): 3947 tries += 1 3948 time.sleep( 3949 self.parent.exponentialBackoff(tries, deadline)) 3950 continue 3951 raise plumbing.convert_error_to_porcelain(e) from e 3952 tries = 0 3953 for plumbing_item in plumbing_response.history: 3954 yield plumbing.convert_identity_alias_history_to_porcelain( 3955 plumbing_item) 3956 if plumbing_response.meta.next_cursor == '': 3957 break 3958 req.meta.cursor = plumbing_response.meta.next_cursor 3959 3960 return generator(self, req)
IdentityAliasesHistory records all changes to the state of a IdentityAlias.
See strongdm.models.IdentityAliasHistory.
def
list(self, filter, *args, timeout=None)
3921 def list(self, filter, *args, timeout=None): 3922 ''' 3923 List gets a list of IdentityAliasHistory records matching a given set of criteria. 3924 ''' 3925 deadline = None if timeout is None else time.time() + timeout 3926 req = IdentityAliasHistoryListRequest() 3927 req.meta.CopyFrom(ListRequestMetadata()) 3928 if self.parent.page_limit > 0: 3929 req.meta.limit = self.parent.page_limit 3930 if self.parent.snapshot_datetime is not None: 3931 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3932 3933 req.filter = plumbing.quote_filter_args(filter, *args) 3934 3935 def generator(svc, req): 3936 tries = 0 3937 while True: 3938 t = None if deadline is None else deadline - time.time() 3939 try: 3940 plumbing_response = svc.stub.List( 3941 req, 3942 metadata=svc.parent.get_metadata( 3943 'IdentityAliasesHistory.List', req), 3944 timeout=t) 3945 except Exception as e: 3946 if self.parent.shouldRetry(tries, e, deadline): 3947 tries += 1 3948 time.sleep( 3949 self.parent.exponentialBackoff(tries, deadline)) 3950 continue 3951 raise plumbing.convert_error_to_porcelain(e) from e 3952 tries = 0 3953 for plumbing_item in plumbing_response.history: 3954 yield plumbing.convert_identity_alias_history_to_porcelain( 3955 plumbing_item) 3956 if plumbing_response.meta.next_cursor == '': 3957 break 3958 req.meta.cursor = plumbing_response.meta.next_cursor 3959 3960 return generator(self, req)
List gets a list of IdentityAliasHistory records matching a given set of criteria.
class
IdentitySets:
3963class IdentitySets: 3964 ''' 3965 A IdentitySet is a named grouping of Identity Aliases for Accounts. 3966 An Account's relationship to a IdentitySet is defined via IdentityAlias objects. 3967 See `strongdm.models.IdentitySet`. 3968 ''' 3969 def __init__(self, channel, client): 3970 self.parent = client 3971 self.stub = IdentitySetsStub(channel) 3972 3973 def create(self, identity_set, timeout=None): 3974 ''' 3975 Create registers a new IdentitySet. 3976 ''' 3977 deadline = None if timeout is None else time.time() + timeout 3978 req = IdentitySetCreateRequest() 3979 3980 if identity_set is not None: 3981 req.identity_set.CopyFrom( 3982 plumbing.convert_identity_set_to_plumbing(identity_set)) 3983 tries = 0 3984 plumbing_response = None 3985 while True: 3986 t = None if deadline is None else deadline - time.time() 3987 try: 3988 plumbing_response = self.stub.Create( 3989 req, 3990 metadata=self.parent.get_metadata('IdentitySets.Create', 3991 req), 3992 timeout=t) 3993 except Exception as e: 3994 if self.parent.shouldRetry(tries, e, deadline): 3995 tries += 1 3996 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3997 continue 3998 raise plumbing.convert_error_to_porcelain(e) from e 3999 break 4000 4001 resp = models.IdentitySetCreateResponse() 4002 resp.identity_set = plumbing.convert_identity_set_to_porcelain( 4003 plumbing_response.identity_set) 4004 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4005 plumbing_response.meta) 4006 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4007 plumbing_response.rate_limit) 4008 return resp 4009 4010 def get(self, id, timeout=None): 4011 ''' 4012 Get reads one IdentitySet by ID. 4013 ''' 4014 deadline = None if timeout is None else time.time() + timeout 4015 req = IdentitySetGetRequest() 4016 if self.parent.snapshot_datetime is not None: 4017 req.meta.CopyFrom(GetRequestMetadata()) 4018 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4019 4020 req.id = (id) 4021 tries = 0 4022 plumbing_response = None 4023 while True: 4024 t = None if deadline is None else deadline - time.time() 4025 try: 4026 plumbing_response = self.stub.Get( 4027 req, 4028 metadata=self.parent.get_metadata('IdentitySets.Get', req), 4029 timeout=t) 4030 except Exception as e: 4031 if self.parent.shouldRetry(tries, e, deadline): 4032 tries += 1 4033 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4034 continue 4035 raise plumbing.convert_error_to_porcelain(e) from e 4036 break 4037 4038 resp = models.IdentitySetGetResponse() 4039 resp.identity_set = plumbing.convert_identity_set_to_porcelain( 4040 plumbing_response.identity_set) 4041 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4042 plumbing_response.meta) 4043 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4044 plumbing_response.rate_limit) 4045 return resp 4046 4047 def update(self, identity_set, timeout=None): 4048 ''' 4049 Update replaces all the fields of a IdentitySet by ID. 4050 ''' 4051 deadline = None if timeout is None else time.time() + timeout 4052 req = IdentitySetUpdateRequest() 4053 4054 if identity_set is not None: 4055 req.identity_set.CopyFrom( 4056 plumbing.convert_identity_set_to_plumbing(identity_set)) 4057 tries = 0 4058 plumbing_response = None 4059 while True: 4060 t = None if deadline is None else deadline - time.time() 4061 try: 4062 plumbing_response = self.stub.Update( 4063 req, 4064 metadata=self.parent.get_metadata('IdentitySets.Update', 4065 req), 4066 timeout=t) 4067 except Exception as e: 4068 if self.parent.shouldRetry(tries, e, deadline): 4069 tries += 1 4070 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4071 continue 4072 raise plumbing.convert_error_to_porcelain(e) from e 4073 break 4074 4075 resp = models.IdentitySetUpdateResponse() 4076 resp.identity_set = plumbing.convert_identity_set_to_porcelain( 4077 plumbing_response.identity_set) 4078 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 4079 plumbing_response.meta) 4080 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4081 plumbing_response.rate_limit) 4082 return resp 4083 4084 def delete(self, id, timeout=None): 4085 ''' 4086 Delete removes a IdentitySet by ID. 4087 ''' 4088 deadline = None if timeout is None else time.time() + timeout 4089 req = IdentitySetDeleteRequest() 4090 4091 req.id = (id) 4092 tries = 0 4093 plumbing_response = None 4094 while True: 4095 t = None if deadline is None else deadline - time.time() 4096 try: 4097 plumbing_response = self.stub.Delete( 4098 req, 4099 metadata=self.parent.get_metadata('IdentitySets.Delete', 4100 req), 4101 timeout=t) 4102 except Exception as e: 4103 if self.parent.shouldRetry(tries, e, deadline): 4104 tries += 1 4105 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4106 continue 4107 raise plumbing.convert_error_to_porcelain(e) from e 4108 break 4109 4110 resp = models.IdentitySetDeleteResponse() 4111 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 4112 plumbing_response.meta) 4113 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4114 plumbing_response.rate_limit) 4115 return resp 4116 4117 def list(self, filter, *args, timeout=None): 4118 ''' 4119 List gets a list of IdentitySets matching a given set of criteria. 4120 ''' 4121 deadline = None if timeout is None else time.time() + timeout 4122 req = IdentitySetListRequest() 4123 req.meta.CopyFrom(ListRequestMetadata()) 4124 if self.parent.page_limit > 0: 4125 req.meta.limit = self.parent.page_limit 4126 if self.parent.snapshot_datetime is not None: 4127 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4128 4129 req.filter = plumbing.quote_filter_args(filter, *args) 4130 4131 def generator(svc, req): 4132 tries = 0 4133 while True: 4134 t = None if deadline is None else deadline - time.time() 4135 try: 4136 plumbing_response = svc.stub.List( 4137 req, 4138 metadata=svc.parent.get_metadata( 4139 'IdentitySets.List', req), 4140 timeout=t) 4141 except Exception as e: 4142 if self.parent.shouldRetry(tries, e, deadline): 4143 tries += 1 4144 time.sleep( 4145 self.parent.exponentialBackoff(tries, deadline)) 4146 continue 4147 raise plumbing.convert_error_to_porcelain(e) from e 4148 tries = 0 4149 for plumbing_item in plumbing_response.identity_sets: 4150 yield plumbing.convert_identity_set_to_porcelain( 4151 plumbing_item) 4152 if plumbing_response.meta.next_cursor == '': 4153 break 4154 req.meta.cursor = plumbing_response.meta.next_cursor 4155 4156 return generator(self, req)
A IdentitySet is a named grouping of Identity Aliases for Accounts.
An Account's relationship to a IdentitySet is defined via IdentityAlias objects.
See strongdm.models.IdentitySet.
def
create(self, identity_set, timeout=None)
3973 def create(self, identity_set, timeout=None): 3974 ''' 3975 Create registers a new IdentitySet. 3976 ''' 3977 deadline = None if timeout is None else time.time() + timeout 3978 req = IdentitySetCreateRequest() 3979 3980 if identity_set is not None: 3981 req.identity_set.CopyFrom( 3982 plumbing.convert_identity_set_to_plumbing(identity_set)) 3983 tries = 0 3984 plumbing_response = None 3985 while True: 3986 t = None if deadline is None else deadline - time.time() 3987 try: 3988 plumbing_response = self.stub.Create( 3989 req, 3990 metadata=self.parent.get_metadata('IdentitySets.Create', 3991 req), 3992 timeout=t) 3993 except Exception as e: 3994 if self.parent.shouldRetry(tries, e, deadline): 3995 tries += 1 3996 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3997 continue 3998 raise plumbing.convert_error_to_porcelain(e) from e 3999 break 4000 4001 resp = models.IdentitySetCreateResponse() 4002 resp.identity_set = plumbing.convert_identity_set_to_porcelain( 4003 plumbing_response.identity_set) 4004 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4005 plumbing_response.meta) 4006 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4007 plumbing_response.rate_limit) 4008 return resp
Create registers a new IdentitySet.
def
get(self, id, timeout=None)
4010 def get(self, id, timeout=None): 4011 ''' 4012 Get reads one IdentitySet by ID. 4013 ''' 4014 deadline = None if timeout is None else time.time() + timeout 4015 req = IdentitySetGetRequest() 4016 if self.parent.snapshot_datetime is not None: 4017 req.meta.CopyFrom(GetRequestMetadata()) 4018 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4019 4020 req.id = (id) 4021 tries = 0 4022 plumbing_response = None 4023 while True: 4024 t = None if deadline is None else deadline - time.time() 4025 try: 4026 plumbing_response = self.stub.Get( 4027 req, 4028 metadata=self.parent.get_metadata('IdentitySets.Get', req), 4029 timeout=t) 4030 except Exception as e: 4031 if self.parent.shouldRetry(tries, e, deadline): 4032 tries += 1 4033 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4034 continue 4035 raise plumbing.convert_error_to_porcelain(e) from e 4036 break 4037 4038 resp = models.IdentitySetGetResponse() 4039 resp.identity_set = plumbing.convert_identity_set_to_porcelain( 4040 plumbing_response.identity_set) 4041 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4042 plumbing_response.meta) 4043 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4044 plumbing_response.rate_limit) 4045 return resp
Get reads one IdentitySet by ID.
def
update(self, identity_set, timeout=None)
4047 def update(self, identity_set, timeout=None): 4048 ''' 4049 Update replaces all the fields of a IdentitySet by ID. 4050 ''' 4051 deadline = None if timeout is None else time.time() + timeout 4052 req = IdentitySetUpdateRequest() 4053 4054 if identity_set is not None: 4055 req.identity_set.CopyFrom( 4056 plumbing.convert_identity_set_to_plumbing(identity_set)) 4057 tries = 0 4058 plumbing_response = None 4059 while True: 4060 t = None if deadline is None else deadline - time.time() 4061 try: 4062 plumbing_response = self.stub.Update( 4063 req, 4064 metadata=self.parent.get_metadata('IdentitySets.Update', 4065 req), 4066 timeout=t) 4067 except Exception as e: 4068 if self.parent.shouldRetry(tries, e, deadline): 4069 tries += 1 4070 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4071 continue 4072 raise plumbing.convert_error_to_porcelain(e) from e 4073 break 4074 4075 resp = models.IdentitySetUpdateResponse() 4076 resp.identity_set = plumbing.convert_identity_set_to_porcelain( 4077 plumbing_response.identity_set) 4078 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 4079 plumbing_response.meta) 4080 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4081 plumbing_response.rate_limit) 4082 return resp
Update replaces all the fields of a IdentitySet by ID.
def
delete(self, id, timeout=None)
4084 def delete(self, id, timeout=None): 4085 ''' 4086 Delete removes a IdentitySet by ID. 4087 ''' 4088 deadline = None if timeout is None else time.time() + timeout 4089 req = IdentitySetDeleteRequest() 4090 4091 req.id = (id) 4092 tries = 0 4093 plumbing_response = None 4094 while True: 4095 t = None if deadline is None else deadline - time.time() 4096 try: 4097 plumbing_response = self.stub.Delete( 4098 req, 4099 metadata=self.parent.get_metadata('IdentitySets.Delete', 4100 req), 4101 timeout=t) 4102 except Exception as e: 4103 if self.parent.shouldRetry(tries, e, deadline): 4104 tries += 1 4105 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4106 continue 4107 raise plumbing.convert_error_to_porcelain(e) from e 4108 break 4109 4110 resp = models.IdentitySetDeleteResponse() 4111 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 4112 plumbing_response.meta) 4113 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4114 plumbing_response.rate_limit) 4115 return resp
Delete removes a IdentitySet by ID.
def
list(self, filter, *args, timeout=None)
4117 def list(self, filter, *args, timeout=None): 4118 ''' 4119 List gets a list of IdentitySets matching a given set of criteria. 4120 ''' 4121 deadline = None if timeout is None else time.time() + timeout 4122 req = IdentitySetListRequest() 4123 req.meta.CopyFrom(ListRequestMetadata()) 4124 if self.parent.page_limit > 0: 4125 req.meta.limit = self.parent.page_limit 4126 if self.parent.snapshot_datetime is not None: 4127 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4128 4129 req.filter = plumbing.quote_filter_args(filter, *args) 4130 4131 def generator(svc, req): 4132 tries = 0 4133 while True: 4134 t = None if deadline is None else deadline - time.time() 4135 try: 4136 plumbing_response = svc.stub.List( 4137 req, 4138 metadata=svc.parent.get_metadata( 4139 'IdentitySets.List', req), 4140 timeout=t) 4141 except Exception as e: 4142 if self.parent.shouldRetry(tries, e, deadline): 4143 tries += 1 4144 time.sleep( 4145 self.parent.exponentialBackoff(tries, deadline)) 4146 continue 4147 raise plumbing.convert_error_to_porcelain(e) from e 4148 tries = 0 4149 for plumbing_item in plumbing_response.identity_sets: 4150 yield plumbing.convert_identity_set_to_porcelain( 4151 plumbing_item) 4152 if plumbing_response.meta.next_cursor == '': 4153 break 4154 req.meta.cursor = plumbing_response.meta.next_cursor 4155 4156 return generator(self, req)
List gets a list of IdentitySets matching a given set of criteria.
class
SnapshotIdentitySets:
4159class SnapshotIdentitySets: 4160 ''' 4161 SnapshotIdentitySets exposes the read only methods of the IdentitySets 4162 service for historical queries. 4163 ''' 4164 def __init__(self, identity_sets): 4165 self.identity_sets = identity_sets 4166 4167 def get(self, id, timeout=None): 4168 ''' 4169 Get reads one IdentitySet by ID. 4170 ''' 4171 return self.identity_sets.get(id, timeout=timeout) 4172 4173 def list(self, filter, *args, timeout=None): 4174 ''' 4175 List gets a list of IdentitySets matching a given set of criteria. 4176 ''' 4177 return self.identity_sets.list(filter, *args, timeout=timeout)
SnapshotIdentitySets exposes the read only methods of the IdentitySets service for historical queries.
def
get(self, id, timeout=None)
4167 def get(self, id, timeout=None): 4168 ''' 4169 Get reads one IdentitySet by ID. 4170 ''' 4171 return self.identity_sets.get(id, timeout=timeout)
Get reads one IdentitySet by ID.
def
list(self, filter, *args, timeout=None)
4173 def list(self, filter, *args, timeout=None): 4174 ''' 4175 List gets a list of IdentitySets matching a given set of criteria. 4176 ''' 4177 return self.identity_sets.list(filter, *args, timeout=timeout)
List gets a list of IdentitySets matching a given set of criteria.
class
IdentitySetsHistory:
4180class IdentitySetsHistory: 4181 ''' 4182 IdentitySetsHistory records all changes to the state of a IdentitySet. 4183 See `strongdm.models.IdentitySetHistory`. 4184 ''' 4185 def __init__(self, channel, client): 4186 self.parent = client 4187 self.stub = IdentitySetsHistoryStub(channel) 4188 4189 def list(self, filter, *args, timeout=None): 4190 ''' 4191 List gets a list of IdentitySetHistory records matching a given set of criteria. 4192 ''' 4193 deadline = None if timeout is None else time.time() + timeout 4194 req = IdentitySetHistoryListRequest() 4195 req.meta.CopyFrom(ListRequestMetadata()) 4196 if self.parent.page_limit > 0: 4197 req.meta.limit = self.parent.page_limit 4198 if self.parent.snapshot_datetime is not None: 4199 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4200 4201 req.filter = plumbing.quote_filter_args(filter, *args) 4202 4203 def generator(svc, req): 4204 tries = 0 4205 while True: 4206 t = None if deadline is None else deadline - time.time() 4207 try: 4208 plumbing_response = svc.stub.List( 4209 req, 4210 metadata=svc.parent.get_metadata( 4211 'IdentitySetsHistory.List', req), 4212 timeout=t) 4213 except Exception as e: 4214 if self.parent.shouldRetry(tries, e, deadline): 4215 tries += 1 4216 time.sleep( 4217 self.parent.exponentialBackoff(tries, deadline)) 4218 continue 4219 raise plumbing.convert_error_to_porcelain(e) from e 4220 tries = 0 4221 for plumbing_item in plumbing_response.history: 4222 yield plumbing.convert_identity_set_history_to_porcelain( 4223 plumbing_item) 4224 if plumbing_response.meta.next_cursor == '': 4225 break 4226 req.meta.cursor = plumbing_response.meta.next_cursor 4227 4228 return generator(self, req)
IdentitySetsHistory records all changes to the state of a IdentitySet.
See strongdm.models.IdentitySetHistory.
def
list(self, filter, *args, timeout=None)
4189 def list(self, filter, *args, timeout=None): 4190 ''' 4191 List gets a list of IdentitySetHistory records matching a given set of criteria. 4192 ''' 4193 deadline = None if timeout is None else time.time() + timeout 4194 req = IdentitySetHistoryListRequest() 4195 req.meta.CopyFrom(ListRequestMetadata()) 4196 if self.parent.page_limit > 0: 4197 req.meta.limit = self.parent.page_limit 4198 if self.parent.snapshot_datetime is not None: 4199 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4200 4201 req.filter = plumbing.quote_filter_args(filter, *args) 4202 4203 def generator(svc, req): 4204 tries = 0 4205 while True: 4206 t = None if deadline is None else deadline - time.time() 4207 try: 4208 plumbing_response = svc.stub.List( 4209 req, 4210 metadata=svc.parent.get_metadata( 4211 'IdentitySetsHistory.List', req), 4212 timeout=t) 4213 except Exception as e: 4214 if self.parent.shouldRetry(tries, e, deadline): 4215 tries += 1 4216 time.sleep( 4217 self.parent.exponentialBackoff(tries, deadline)) 4218 continue 4219 raise plumbing.convert_error_to_porcelain(e) from e 4220 tries = 0 4221 for plumbing_item in plumbing_response.history: 4222 yield plumbing.convert_identity_set_history_to_porcelain( 4223 plumbing_item) 4224 if plumbing_response.meta.next_cursor == '': 4225 break 4226 req.meta.cursor = plumbing_response.meta.next_cursor 4227 4228 return generator(self, req)
List gets a list of IdentitySetHistory records matching a given set of criteria.
class
ManagedSecrets:
4231class ManagedSecrets: 4232 ''' 4233 ManagedSecret is a private vertical for creating, reading, updating, 4234 deleting, listing and rotating the managed secrets in the secrets engines as 4235 an authenticated user. 4236 See `strongdm.models.ManagedSecret`. 4237 ''' 4238 def __init__(self, channel, client): 4239 self.parent = client 4240 self.stub = ManagedSecretsStub(channel) 4241 4242 def list(self, filter, *args, timeout=None): 4243 ''' 4244 List returns Managed Secrets from a Secret Engine. 4245 ''' 4246 deadline = None if timeout is None else time.time() + timeout 4247 req = ManagedSecretListRequest() 4248 req.meta.CopyFrom(ListRequestMetadata()) 4249 if self.parent.page_limit > 0: 4250 req.meta.limit = self.parent.page_limit 4251 if self.parent.snapshot_datetime is not None: 4252 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4253 4254 req.filter = plumbing.quote_filter_args(filter, *args) 4255 4256 def generator(svc, req): 4257 tries = 0 4258 while True: 4259 t = None if deadline is None else deadline - time.time() 4260 try: 4261 plumbing_response = svc.stub.List( 4262 req, 4263 metadata=svc.parent.get_metadata( 4264 'ManagedSecrets.List', req), 4265 timeout=t) 4266 except Exception as e: 4267 if self.parent.shouldRetry(tries, e, deadline): 4268 tries += 1 4269 time.sleep( 4270 self.parent.exponentialBackoff(tries, deadline)) 4271 continue 4272 raise plumbing.convert_error_to_porcelain(e) from e 4273 tries = 0 4274 for plumbing_item in plumbing_response.managed_secrets: 4275 yield plumbing.convert_managed_secret_to_porcelain( 4276 plumbing_item) 4277 if plumbing_response.meta.next_cursor == '': 4278 break 4279 req.meta.cursor = plumbing_response.meta.next_cursor 4280 4281 return generator(self, req) 4282 4283 def list_by_actor(self, filter, *args, timeout=None): 4284 ''' 4285 List returns Managed Secrets for an Actor from a Secret Engine. 4286 ''' 4287 deadline = None if timeout is None else time.time() + timeout 4288 req = ManagedSecretListRequest() 4289 req.meta.CopyFrom(ListRequestMetadata()) 4290 if self.parent.page_limit > 0: 4291 req.meta.limit = self.parent.page_limit 4292 if self.parent.snapshot_datetime is not None: 4293 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4294 4295 req.filter = plumbing.quote_filter_args(filter, *args) 4296 4297 def generator(svc, req): 4298 tries = 0 4299 while True: 4300 t = None if deadline is None else deadline - time.time() 4301 try: 4302 plumbing_response = svc.stub.ListByActor( 4303 req, 4304 metadata=svc.parent.get_metadata( 4305 'ManagedSecrets.ListByActor', req), 4306 timeout=t) 4307 except Exception as e: 4308 if self.parent.shouldRetry(tries, e, deadline): 4309 tries += 1 4310 time.sleep( 4311 self.parent.exponentialBackoff(tries, deadline)) 4312 continue 4313 raise plumbing.convert_error_to_porcelain(e) from e 4314 tries = 0 4315 for plumbing_item in plumbing_response.managed_secrets: 4316 yield plumbing.convert_managed_secret_to_porcelain( 4317 plumbing_item) 4318 if plumbing_response.meta.next_cursor == '': 4319 break 4320 req.meta.cursor = plumbing_response.meta.next_cursor 4321 4322 return generator(self, req) 4323 4324 def create(self, managed_secret, timeout=None): 4325 ''' 4326 Create creates a Managed Secret 4327 ''' 4328 deadline = None if timeout is None else time.time() + timeout 4329 req = ManagedSecretCreateRequest() 4330 4331 if managed_secret is not None: 4332 req.managed_secret.CopyFrom( 4333 plumbing.convert_managed_secret_to_plumbing(managed_secret)) 4334 tries = 0 4335 plumbing_response = None 4336 while True: 4337 t = None if deadline is None else deadline - time.time() 4338 try: 4339 plumbing_response = self.stub.Create( 4340 req, 4341 metadata=self.parent.get_metadata('ManagedSecrets.Create', 4342 req), 4343 timeout=t) 4344 except Exception as e: 4345 if self.parent.shouldRetry(tries, e, deadline): 4346 tries += 1 4347 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4348 continue 4349 raise plumbing.convert_error_to_porcelain(e) from e 4350 break 4351 4352 resp = models.ManagedSecretCreateResponse() 4353 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 4354 plumbing_response.managed_secret) 4355 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4356 plumbing_response.meta) 4357 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4358 plumbing_response.rate_limit) 4359 return resp 4360 4361 def update(self, managed_secret, timeout=None): 4362 ''' 4363 Update updates a Managed Secret 4364 ''' 4365 deadline = None if timeout is None else time.time() + timeout 4366 req = ManagedSecretUpdateRequest() 4367 4368 if managed_secret is not None: 4369 req.managed_secret.CopyFrom( 4370 plumbing.convert_managed_secret_to_plumbing(managed_secret)) 4371 tries = 0 4372 plumbing_response = None 4373 while True: 4374 t = None if deadline is None else deadline - time.time() 4375 try: 4376 plumbing_response = self.stub.Update( 4377 req, 4378 metadata=self.parent.get_metadata('ManagedSecrets.Update', 4379 req), 4380 timeout=t) 4381 except Exception as e: 4382 if self.parent.shouldRetry(tries, e, deadline): 4383 tries += 1 4384 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4385 continue 4386 raise plumbing.convert_error_to_porcelain(e) from e 4387 break 4388 4389 resp = models.ManagedSecretUpdateResponse() 4390 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 4391 plumbing_response.managed_secret) 4392 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 4393 plumbing_response.meta) 4394 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4395 plumbing_response.rate_limit) 4396 return resp 4397 4398 def rotate(self, id, timeout=None): 4399 ''' 4400 Rotate forces rotation of Managed Secret 4401 ''' 4402 deadline = None if timeout is None else time.time() + timeout 4403 req = ManagedSecretRotateRequest() 4404 4405 req.id = (id) 4406 tries = 0 4407 plumbing_response = None 4408 while True: 4409 t = None if deadline is None else deadline - time.time() 4410 try: 4411 plumbing_response = self.stub.Rotate( 4412 req, 4413 metadata=self.parent.get_metadata('ManagedSecrets.Rotate', 4414 req), 4415 timeout=t) 4416 except Exception as e: 4417 if self.parent.shouldRetry(tries, e, deadline): 4418 tries += 1 4419 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4420 continue 4421 raise plumbing.convert_error_to_porcelain(e) from e 4422 break 4423 4424 resp = models.ManagedSecretRotateResponse() 4425 resp.meta = plumbing.convert_generic_response_metadata_to_porcelain( 4426 plumbing_response.meta) 4427 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4428 plumbing_response.rate_limit) 4429 return resp 4430 4431 def delete(self, id, timeout=None): 4432 ''' 4433 Delete deletes a Managed Secret 4434 ''' 4435 deadline = None if timeout is None else time.time() + timeout 4436 req = ManagedSecretDeleteRequest() 4437 4438 req.id = (id) 4439 tries = 0 4440 plumbing_response = None 4441 while True: 4442 t = None if deadline is None else deadline - time.time() 4443 try: 4444 plumbing_response = self.stub.Delete( 4445 req, 4446 metadata=self.parent.get_metadata('ManagedSecrets.Delete', 4447 req), 4448 timeout=t) 4449 except Exception as e: 4450 if self.parent.shouldRetry(tries, e, deadline): 4451 tries += 1 4452 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4453 continue 4454 raise plumbing.convert_error_to_porcelain(e) from e 4455 break 4456 4457 resp = models.ManagedSecretDeleteResponse() 4458 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4459 plumbing_response.rate_limit) 4460 return resp 4461 4462 def force_delete(self, id, timeout=None): 4463 ''' 4464 ForceDelete deletes a Managed Secret regardless of errors on external system 4465 ''' 4466 deadline = None if timeout is None else time.time() + timeout 4467 req = ManagedSecretDeleteRequest() 4468 4469 req.id = (id) 4470 tries = 0 4471 plumbing_response = None 4472 while True: 4473 t = None if deadline is None else deadline - time.time() 4474 try: 4475 plumbing_response = self.stub.ForceDelete( 4476 req, 4477 metadata=self.parent.get_metadata( 4478 'ManagedSecrets.ForceDelete', req), 4479 timeout=t) 4480 except Exception as e: 4481 if self.parent.shouldRetry(tries, e, deadline): 4482 tries += 1 4483 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4484 continue 4485 raise plumbing.convert_error_to_porcelain(e) from e 4486 break 4487 4488 resp = models.ManagedSecretDeleteResponse() 4489 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4490 plumbing_response.rate_limit) 4491 return resp 4492 4493 def get(self, id, timeout=None): 4494 ''' 4495 Get gets details of a Managed Secret without sensitive data 4496 ''' 4497 deadline = None if timeout is None else time.time() + timeout 4498 req = ManagedSecretGetRequest() 4499 if self.parent.snapshot_datetime is not None: 4500 req.meta.CopyFrom(GetRequestMetadata()) 4501 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4502 4503 req.id = (id) 4504 tries = 0 4505 plumbing_response = None 4506 while True: 4507 t = None if deadline is None else deadline - time.time() 4508 try: 4509 plumbing_response = self.stub.Get( 4510 req, 4511 metadata=self.parent.get_metadata('ManagedSecrets.Get', 4512 req), 4513 timeout=t) 4514 except Exception as e: 4515 if self.parent.shouldRetry(tries, e, deadline): 4516 tries += 1 4517 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4518 continue 4519 raise plumbing.convert_error_to_porcelain(e) from e 4520 break 4521 4522 resp = models.ManagedSecretGetResponse() 4523 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 4524 plumbing_response.managed_secret) 4525 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4526 plumbing_response.meta) 4527 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4528 plumbing_response.rate_limit) 4529 return resp 4530 4531 def retrieve(self, id, timeout=None): 4532 ''' 4533 Retrieve returns Managed Secret with sensitive data 4534 ''' 4535 deadline = None if timeout is None else time.time() + timeout 4536 req = ManagedSecretRetrieveRequest() 4537 4538 req.id = (id) 4539 tries = 0 4540 plumbing_response = None 4541 while True: 4542 t = None if deadline is None else deadline - time.time() 4543 try: 4544 plumbing_response = self.stub.Retrieve( 4545 req, 4546 metadata=self.parent.get_metadata( 4547 'ManagedSecrets.Retrieve', req), 4548 timeout=t) 4549 except Exception as e: 4550 if self.parent.shouldRetry(tries, e, deadline): 4551 tries += 1 4552 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4553 continue 4554 raise plumbing.convert_error_to_porcelain(e) from e 4555 break 4556 4557 resp = models.ManagedSecretRetrieveResponse() 4558 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 4559 plumbing_response.managed_secret) 4560 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4561 plumbing_response.meta) 4562 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4563 plumbing_response.rate_limit) 4564 return resp 4565 4566 def validate(self, id, timeout=None): 4567 ''' 4568 Validate returns the result of testing the stored credential against the 4569 secret engine. 4570 ''' 4571 deadline = None if timeout is None else time.time() + timeout 4572 req = ManagedSecretValidateRequest() 4573 4574 req.id = (id) 4575 tries = 0 4576 plumbing_response = None 4577 while True: 4578 t = None if deadline is None else deadline - time.time() 4579 try: 4580 plumbing_response = self.stub.Validate( 4581 req, 4582 metadata=self.parent.get_metadata( 4583 'ManagedSecrets.Validate', req), 4584 timeout=t) 4585 except Exception as e: 4586 if self.parent.shouldRetry(tries, e, deadline): 4587 tries += 1 4588 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4589 continue 4590 raise plumbing.convert_error_to_porcelain(e) from e 4591 break 4592 4593 resp = models.ManagedSecretValidateResponse() 4594 resp.invalid_info = (plumbing_response.invalid_info) 4595 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4596 plumbing_response.meta) 4597 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4598 plumbing_response.rate_limit) 4599 resp.valid = (plumbing_response.valid) 4600 return resp 4601 4602 def logs(self, filter, *args, timeout=None): 4603 ''' 4604 Logs returns the audit records for the managed secret. This may be replaced 4605 in the future. 4606 ''' 4607 deadline = None if timeout is None else time.time() + timeout 4608 req = ManagedSecretLogsRequest() 4609 req.meta.CopyFrom(ListRequestMetadata()) 4610 if self.parent.page_limit > 0: 4611 req.meta.limit = self.parent.page_limit 4612 if self.parent.snapshot_datetime is not None: 4613 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4614 4615 req.filter = plumbing.quote_filter_args(filter, *args) 4616 4617 def generator(svc, req): 4618 tries = 0 4619 while True: 4620 t = None if deadline is None else deadline - time.time() 4621 try: 4622 plumbing_response = svc.stub.Logs( 4623 req, 4624 metadata=svc.parent.get_metadata( 4625 'ManagedSecrets.Logs', req), 4626 timeout=t) 4627 except Exception as e: 4628 if self.parent.shouldRetry(tries, e, deadline): 4629 tries += 1 4630 time.sleep( 4631 self.parent.exponentialBackoff(tries, deadline)) 4632 continue 4633 raise plumbing.convert_error_to_porcelain(e) from e 4634 tries = 0 4635 for plumbing_item in plumbing_response.managed_secret_logs: 4636 yield plumbing.convert_managed_secret_log_to_porcelain( 4637 plumbing_item) 4638 if plumbing_response.meta.next_cursor == '': 4639 break 4640 req.meta.cursor = plumbing_response.meta.next_cursor 4641 4642 return generator(self, req)
ManagedSecret is a private vertical for creating, reading, updating,
deleting, listing and rotating the managed secrets in the secrets engines as
an authenticated user.
See strongdm.models.ManagedSecret.
def
list(self, filter, *args, timeout=None)
4242 def list(self, filter, *args, timeout=None): 4243 ''' 4244 List returns Managed Secrets from a Secret Engine. 4245 ''' 4246 deadline = None if timeout is None else time.time() + timeout 4247 req = ManagedSecretListRequest() 4248 req.meta.CopyFrom(ListRequestMetadata()) 4249 if self.parent.page_limit > 0: 4250 req.meta.limit = self.parent.page_limit 4251 if self.parent.snapshot_datetime is not None: 4252 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4253 4254 req.filter = plumbing.quote_filter_args(filter, *args) 4255 4256 def generator(svc, req): 4257 tries = 0 4258 while True: 4259 t = None if deadline is None else deadline - time.time() 4260 try: 4261 plumbing_response = svc.stub.List( 4262 req, 4263 metadata=svc.parent.get_metadata( 4264 'ManagedSecrets.List', req), 4265 timeout=t) 4266 except Exception as e: 4267 if self.parent.shouldRetry(tries, e, deadline): 4268 tries += 1 4269 time.sleep( 4270 self.parent.exponentialBackoff(tries, deadline)) 4271 continue 4272 raise plumbing.convert_error_to_porcelain(e) from e 4273 tries = 0 4274 for plumbing_item in plumbing_response.managed_secrets: 4275 yield plumbing.convert_managed_secret_to_porcelain( 4276 plumbing_item) 4277 if plumbing_response.meta.next_cursor == '': 4278 break 4279 req.meta.cursor = plumbing_response.meta.next_cursor 4280 4281 return generator(self, req)
List returns Managed Secrets from a Secret Engine.
def
list_by_actor(self, filter, *args, timeout=None)
4283 def list_by_actor(self, filter, *args, timeout=None): 4284 ''' 4285 List returns Managed Secrets for an Actor from a Secret Engine. 4286 ''' 4287 deadline = None if timeout is None else time.time() + timeout 4288 req = ManagedSecretListRequest() 4289 req.meta.CopyFrom(ListRequestMetadata()) 4290 if self.parent.page_limit > 0: 4291 req.meta.limit = self.parent.page_limit 4292 if self.parent.snapshot_datetime is not None: 4293 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4294 4295 req.filter = plumbing.quote_filter_args(filter, *args) 4296 4297 def generator(svc, req): 4298 tries = 0 4299 while True: 4300 t = None if deadline is None else deadline - time.time() 4301 try: 4302 plumbing_response = svc.stub.ListByActor( 4303 req, 4304 metadata=svc.parent.get_metadata( 4305 'ManagedSecrets.ListByActor', req), 4306 timeout=t) 4307 except Exception as e: 4308 if self.parent.shouldRetry(tries, e, deadline): 4309 tries += 1 4310 time.sleep( 4311 self.parent.exponentialBackoff(tries, deadline)) 4312 continue 4313 raise plumbing.convert_error_to_porcelain(e) from e 4314 tries = 0 4315 for plumbing_item in plumbing_response.managed_secrets: 4316 yield plumbing.convert_managed_secret_to_porcelain( 4317 plumbing_item) 4318 if plumbing_response.meta.next_cursor == '': 4319 break 4320 req.meta.cursor = plumbing_response.meta.next_cursor 4321 4322 return generator(self, req)
List returns Managed Secrets for an Actor from a Secret Engine.
def
create(self, managed_secret, timeout=None)
4324 def create(self, managed_secret, timeout=None): 4325 ''' 4326 Create creates a Managed Secret 4327 ''' 4328 deadline = None if timeout is None else time.time() + timeout 4329 req = ManagedSecretCreateRequest() 4330 4331 if managed_secret is not None: 4332 req.managed_secret.CopyFrom( 4333 plumbing.convert_managed_secret_to_plumbing(managed_secret)) 4334 tries = 0 4335 plumbing_response = None 4336 while True: 4337 t = None if deadline is None else deadline - time.time() 4338 try: 4339 plumbing_response = self.stub.Create( 4340 req, 4341 metadata=self.parent.get_metadata('ManagedSecrets.Create', 4342 req), 4343 timeout=t) 4344 except Exception as e: 4345 if self.parent.shouldRetry(tries, e, deadline): 4346 tries += 1 4347 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4348 continue 4349 raise plumbing.convert_error_to_porcelain(e) from e 4350 break 4351 4352 resp = models.ManagedSecretCreateResponse() 4353 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 4354 plumbing_response.managed_secret) 4355 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4356 plumbing_response.meta) 4357 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4358 plumbing_response.rate_limit) 4359 return resp
Create creates a Managed Secret
def
update(self, managed_secret, timeout=None)
4361 def update(self, managed_secret, timeout=None): 4362 ''' 4363 Update updates a Managed Secret 4364 ''' 4365 deadline = None if timeout is None else time.time() + timeout 4366 req = ManagedSecretUpdateRequest() 4367 4368 if managed_secret is not None: 4369 req.managed_secret.CopyFrom( 4370 plumbing.convert_managed_secret_to_plumbing(managed_secret)) 4371 tries = 0 4372 plumbing_response = None 4373 while True: 4374 t = None if deadline is None else deadline - time.time() 4375 try: 4376 plumbing_response = self.stub.Update( 4377 req, 4378 metadata=self.parent.get_metadata('ManagedSecrets.Update', 4379 req), 4380 timeout=t) 4381 except Exception as e: 4382 if self.parent.shouldRetry(tries, e, deadline): 4383 tries += 1 4384 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4385 continue 4386 raise plumbing.convert_error_to_porcelain(e) from e 4387 break 4388 4389 resp = models.ManagedSecretUpdateResponse() 4390 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 4391 plumbing_response.managed_secret) 4392 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 4393 plumbing_response.meta) 4394 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4395 plumbing_response.rate_limit) 4396 return resp
Update updates a Managed Secret
def
rotate(self, id, timeout=None)
4398 def rotate(self, id, timeout=None): 4399 ''' 4400 Rotate forces rotation of Managed Secret 4401 ''' 4402 deadline = None if timeout is None else time.time() + timeout 4403 req = ManagedSecretRotateRequest() 4404 4405 req.id = (id) 4406 tries = 0 4407 plumbing_response = None 4408 while True: 4409 t = None if deadline is None else deadline - time.time() 4410 try: 4411 plumbing_response = self.stub.Rotate( 4412 req, 4413 metadata=self.parent.get_metadata('ManagedSecrets.Rotate', 4414 req), 4415 timeout=t) 4416 except Exception as e: 4417 if self.parent.shouldRetry(tries, e, deadline): 4418 tries += 1 4419 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4420 continue 4421 raise plumbing.convert_error_to_porcelain(e) from e 4422 break 4423 4424 resp = models.ManagedSecretRotateResponse() 4425 resp.meta = plumbing.convert_generic_response_metadata_to_porcelain( 4426 plumbing_response.meta) 4427 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4428 plumbing_response.rate_limit) 4429 return resp
Rotate forces rotation of Managed Secret
def
delete(self, id, timeout=None)
4431 def delete(self, id, timeout=None): 4432 ''' 4433 Delete deletes a Managed Secret 4434 ''' 4435 deadline = None if timeout is None else time.time() + timeout 4436 req = ManagedSecretDeleteRequest() 4437 4438 req.id = (id) 4439 tries = 0 4440 plumbing_response = None 4441 while True: 4442 t = None if deadline is None else deadline - time.time() 4443 try: 4444 plumbing_response = self.stub.Delete( 4445 req, 4446 metadata=self.parent.get_metadata('ManagedSecrets.Delete', 4447 req), 4448 timeout=t) 4449 except Exception as e: 4450 if self.parent.shouldRetry(tries, e, deadline): 4451 tries += 1 4452 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4453 continue 4454 raise plumbing.convert_error_to_porcelain(e) from e 4455 break 4456 4457 resp = models.ManagedSecretDeleteResponse() 4458 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4459 plumbing_response.rate_limit) 4460 return resp
Delete deletes a Managed Secret
def
force_delete(self, id, timeout=None)
4462 def force_delete(self, id, timeout=None): 4463 ''' 4464 ForceDelete deletes a Managed Secret regardless of errors on external system 4465 ''' 4466 deadline = None if timeout is None else time.time() + timeout 4467 req = ManagedSecretDeleteRequest() 4468 4469 req.id = (id) 4470 tries = 0 4471 plumbing_response = None 4472 while True: 4473 t = None if deadline is None else deadline - time.time() 4474 try: 4475 plumbing_response = self.stub.ForceDelete( 4476 req, 4477 metadata=self.parent.get_metadata( 4478 'ManagedSecrets.ForceDelete', req), 4479 timeout=t) 4480 except Exception as e: 4481 if self.parent.shouldRetry(tries, e, deadline): 4482 tries += 1 4483 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4484 continue 4485 raise plumbing.convert_error_to_porcelain(e) from e 4486 break 4487 4488 resp = models.ManagedSecretDeleteResponse() 4489 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4490 plumbing_response.rate_limit) 4491 return resp
ForceDelete deletes a Managed Secret regardless of errors on external system
def
get(self, id, timeout=None)
4493 def get(self, id, timeout=None): 4494 ''' 4495 Get gets details of a Managed Secret without sensitive data 4496 ''' 4497 deadline = None if timeout is None else time.time() + timeout 4498 req = ManagedSecretGetRequest() 4499 if self.parent.snapshot_datetime is not None: 4500 req.meta.CopyFrom(GetRequestMetadata()) 4501 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4502 4503 req.id = (id) 4504 tries = 0 4505 plumbing_response = None 4506 while True: 4507 t = None if deadline is None else deadline - time.time() 4508 try: 4509 plumbing_response = self.stub.Get( 4510 req, 4511 metadata=self.parent.get_metadata('ManagedSecrets.Get', 4512 req), 4513 timeout=t) 4514 except Exception as e: 4515 if self.parent.shouldRetry(tries, e, deadline): 4516 tries += 1 4517 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4518 continue 4519 raise plumbing.convert_error_to_porcelain(e) from e 4520 break 4521 4522 resp = models.ManagedSecretGetResponse() 4523 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 4524 plumbing_response.managed_secret) 4525 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4526 plumbing_response.meta) 4527 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4528 plumbing_response.rate_limit) 4529 return resp
Get gets details of a Managed Secret without sensitive data
def
retrieve(self, id, timeout=None)
4531 def retrieve(self, id, timeout=None): 4532 ''' 4533 Retrieve returns Managed Secret with sensitive data 4534 ''' 4535 deadline = None if timeout is None else time.time() + timeout 4536 req = ManagedSecretRetrieveRequest() 4537 4538 req.id = (id) 4539 tries = 0 4540 plumbing_response = None 4541 while True: 4542 t = None if deadline is None else deadline - time.time() 4543 try: 4544 plumbing_response = self.stub.Retrieve( 4545 req, 4546 metadata=self.parent.get_metadata( 4547 'ManagedSecrets.Retrieve', req), 4548 timeout=t) 4549 except Exception as e: 4550 if self.parent.shouldRetry(tries, e, deadline): 4551 tries += 1 4552 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4553 continue 4554 raise plumbing.convert_error_to_porcelain(e) from e 4555 break 4556 4557 resp = models.ManagedSecretRetrieveResponse() 4558 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 4559 plumbing_response.managed_secret) 4560 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4561 plumbing_response.meta) 4562 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4563 plumbing_response.rate_limit) 4564 return resp
Retrieve returns Managed Secret with sensitive data
def
validate(self, id, timeout=None)
4566 def validate(self, id, timeout=None): 4567 ''' 4568 Validate returns the result of testing the stored credential against the 4569 secret engine. 4570 ''' 4571 deadline = None if timeout is None else time.time() + timeout 4572 req = ManagedSecretValidateRequest() 4573 4574 req.id = (id) 4575 tries = 0 4576 plumbing_response = None 4577 while True: 4578 t = None if deadline is None else deadline - time.time() 4579 try: 4580 plumbing_response = self.stub.Validate( 4581 req, 4582 metadata=self.parent.get_metadata( 4583 'ManagedSecrets.Validate', req), 4584 timeout=t) 4585 except Exception as e: 4586 if self.parent.shouldRetry(tries, e, deadline): 4587 tries += 1 4588 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4589 continue 4590 raise plumbing.convert_error_to_porcelain(e) from e 4591 break 4592 4593 resp = models.ManagedSecretValidateResponse() 4594 resp.invalid_info = (plumbing_response.invalid_info) 4595 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4596 plumbing_response.meta) 4597 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4598 plumbing_response.rate_limit) 4599 resp.valid = (plumbing_response.valid) 4600 return resp
Validate returns the result of testing the stored credential against the secret engine.
def
logs(self, filter, *args, timeout=None)
4602 def logs(self, filter, *args, timeout=None): 4603 ''' 4604 Logs returns the audit records for the managed secret. This may be replaced 4605 in the future. 4606 ''' 4607 deadline = None if timeout is None else time.time() + timeout 4608 req = ManagedSecretLogsRequest() 4609 req.meta.CopyFrom(ListRequestMetadata()) 4610 if self.parent.page_limit > 0: 4611 req.meta.limit = self.parent.page_limit 4612 if self.parent.snapshot_datetime is not None: 4613 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4614 4615 req.filter = plumbing.quote_filter_args(filter, *args) 4616 4617 def generator(svc, req): 4618 tries = 0 4619 while True: 4620 t = None if deadline is None else deadline - time.time() 4621 try: 4622 plumbing_response = svc.stub.Logs( 4623 req, 4624 metadata=svc.parent.get_metadata( 4625 'ManagedSecrets.Logs', req), 4626 timeout=t) 4627 except Exception as e: 4628 if self.parent.shouldRetry(tries, e, deadline): 4629 tries += 1 4630 time.sleep( 4631 self.parent.exponentialBackoff(tries, deadline)) 4632 continue 4633 raise plumbing.convert_error_to_porcelain(e) from e 4634 tries = 0 4635 for plumbing_item in plumbing_response.managed_secret_logs: 4636 yield plumbing.convert_managed_secret_log_to_porcelain( 4637 plumbing_item) 4638 if plumbing_response.meta.next_cursor == '': 4639 break 4640 req.meta.cursor = plumbing_response.meta.next_cursor 4641 4642 return generator(self, req)
Logs returns the audit records for the managed secret. This may be replaced in the future.
class
Nodes:
4645class Nodes: 4646 ''' 4647 Nodes make up the StrongDM network, and allow your users to connect securely to your resources. 4648 There are three types of nodes: 4649 1. **Relay:** creates connectivity to your datasources, while maintaining the egress-only nature of your firewall 4650 2. **Gateway:** a relay that also listens for connections from StrongDM clients 4651 3. **Proxy Cluster:** a cluster of workers that together mediate access from clients to resources 4652 See: 4653 `strongdm.models.Gateway` 4654 `strongdm.models.ProxyCluster` 4655 `strongdm.models.Relay` 4656 ''' 4657 def __init__(self, channel, client): 4658 self.parent = client 4659 self.stub = NodesStub(channel) 4660 4661 def create(self, node, timeout=None): 4662 ''' 4663 Create registers a new Node. 4664 ''' 4665 deadline = None if timeout is None else time.time() + timeout 4666 req = NodeCreateRequest() 4667 4668 if node is not None: 4669 req.node.CopyFrom(plumbing.convert_node_to_plumbing(node)) 4670 tries = 0 4671 plumbing_response = None 4672 while True: 4673 t = None if deadline is None else deadline - time.time() 4674 try: 4675 plumbing_response = self.stub.Create( 4676 req, 4677 metadata=self.parent.get_metadata('Nodes.Create', req), 4678 timeout=t) 4679 except Exception as e: 4680 if self.parent.shouldRetry(tries, e, deadline): 4681 tries += 1 4682 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4683 continue 4684 raise plumbing.convert_error_to_porcelain(e) from e 4685 break 4686 4687 resp = models.NodeCreateResponse() 4688 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4689 plumbing_response.meta) 4690 resp.node = plumbing.convert_node_to_porcelain(plumbing_response.node) 4691 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4692 plumbing_response.rate_limit) 4693 resp.token = (plumbing_response.token) 4694 return resp 4695 4696 def get(self, id, timeout=None): 4697 ''' 4698 Get reads one Node by ID. 4699 ''' 4700 deadline = None if timeout is None else time.time() + timeout 4701 req = NodeGetRequest() 4702 if self.parent.snapshot_datetime is not None: 4703 req.meta.CopyFrom(GetRequestMetadata()) 4704 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4705 4706 req.id = (id) 4707 tries = 0 4708 plumbing_response = None 4709 while True: 4710 t = None if deadline is None else deadline - time.time() 4711 try: 4712 plumbing_response = self.stub.Get( 4713 req, 4714 metadata=self.parent.get_metadata('Nodes.Get', req), 4715 timeout=t) 4716 except Exception as e: 4717 if self.parent.shouldRetry(tries, e, deadline): 4718 tries += 1 4719 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4720 continue 4721 raise plumbing.convert_error_to_porcelain(e) from e 4722 break 4723 4724 resp = models.NodeGetResponse() 4725 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4726 plumbing_response.meta) 4727 resp.node = plumbing.convert_node_to_porcelain(plumbing_response.node) 4728 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4729 plumbing_response.rate_limit) 4730 return resp 4731 4732 def update(self, node, timeout=None): 4733 ''' 4734 Update replaces all the fields of a Node by ID. 4735 ''' 4736 deadline = None if timeout is None else time.time() + timeout 4737 req = NodeUpdateRequest() 4738 4739 if node is not None: 4740 req.node.CopyFrom(plumbing.convert_node_to_plumbing(node)) 4741 tries = 0 4742 plumbing_response = None 4743 while True: 4744 t = None if deadline is None else deadline - time.time() 4745 try: 4746 plumbing_response = self.stub.Update( 4747 req, 4748 metadata=self.parent.get_metadata('Nodes.Update', req), 4749 timeout=t) 4750 except Exception as e: 4751 if self.parent.shouldRetry(tries, e, deadline): 4752 tries += 1 4753 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4754 continue 4755 raise plumbing.convert_error_to_porcelain(e) from e 4756 break 4757 4758 resp = models.NodeUpdateResponse() 4759 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 4760 plumbing_response.meta) 4761 resp.node = plumbing.convert_node_to_porcelain(plumbing_response.node) 4762 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4763 plumbing_response.rate_limit) 4764 return resp 4765 4766 def delete(self, id, timeout=None): 4767 ''' 4768 Delete removes a Node by ID. 4769 ''' 4770 deadline = None if timeout is None else time.time() + timeout 4771 req = NodeDeleteRequest() 4772 4773 req.id = (id) 4774 tries = 0 4775 plumbing_response = None 4776 while True: 4777 t = None if deadline is None else deadline - time.time() 4778 try: 4779 plumbing_response = self.stub.Delete( 4780 req, 4781 metadata=self.parent.get_metadata('Nodes.Delete', req), 4782 timeout=t) 4783 except Exception as e: 4784 if self.parent.shouldRetry(tries, e, deadline): 4785 tries += 1 4786 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4787 continue 4788 raise plumbing.convert_error_to_porcelain(e) from e 4789 break 4790 4791 resp = models.NodeDeleteResponse() 4792 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 4793 plumbing_response.meta) 4794 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4795 plumbing_response.rate_limit) 4796 return resp 4797 4798 def list(self, filter, *args, timeout=None): 4799 ''' 4800 List gets a list of Nodes matching a given set of criteria. 4801 ''' 4802 deadline = None if timeout is None else time.time() + timeout 4803 req = NodeListRequest() 4804 req.meta.CopyFrom(ListRequestMetadata()) 4805 if self.parent.page_limit > 0: 4806 req.meta.limit = self.parent.page_limit 4807 if self.parent.snapshot_datetime is not None: 4808 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4809 4810 req.filter = plumbing.quote_filter_args(filter, *args) 4811 4812 def generator(svc, req): 4813 tries = 0 4814 while True: 4815 t = None if deadline is None else deadline - time.time() 4816 try: 4817 plumbing_response = svc.stub.List( 4818 req, 4819 metadata=svc.parent.get_metadata('Nodes.List', req), 4820 timeout=t) 4821 except Exception as e: 4822 if self.parent.shouldRetry(tries, e, deadline): 4823 tries += 1 4824 time.sleep( 4825 self.parent.exponentialBackoff(tries, deadline)) 4826 continue 4827 raise plumbing.convert_error_to_porcelain(e) from e 4828 tries = 0 4829 for plumbing_item in plumbing_response.nodes: 4830 yield plumbing.convert_node_to_porcelain(plumbing_item) 4831 if plumbing_response.meta.next_cursor == '': 4832 break 4833 req.meta.cursor = plumbing_response.meta.next_cursor 4834 4835 return generator(self, req) 4836 4837 def tcp_probe(self, node_id, host, port, timeout=None): 4838 ''' 4839 TCPProbe instructs a Node to connect to an address via TCP and report the 4840 result. 4841 ''' 4842 deadline = None if timeout is None else time.time() + timeout 4843 req = NodeTCPProbeRequest() 4844 4845 req.node_id = (node_id) 4846 req.host = (host) 4847 req.port = (port) 4848 tries = 0 4849 plumbing_response = None 4850 while True: 4851 t = None if deadline is None else deadline - time.time() 4852 try: 4853 plumbing_response = self.stub.TCPProbe( 4854 req, 4855 metadata=self.parent.get_metadata('Nodes.TCPProbe', req), 4856 timeout=t) 4857 except Exception as e: 4858 if self.parent.shouldRetry(tries, e, deadline): 4859 tries += 1 4860 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4861 continue 4862 raise plumbing.convert_error_to_porcelain(e) from e 4863 break 4864 4865 resp = models.NodeTCPProbeResponse() 4866 resp.error = (plumbing_response.error) 4867 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4868 plumbing_response.meta) 4869 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4870 plumbing_response.rate_limit) 4871 resp.succeeded = (plumbing_response.succeeded) 4872 return resp
Nodes make up the StrongDM network, and allow your users to connect securely to your resources. There are three types of nodes:
- Relay: creates connectivity to your datasources, while maintaining the egress-only nature of your firewall
- Gateway: a relay that also listens for connections from StrongDM clients
- Proxy Cluster: a cluster of workers that together mediate access from clients to resources
See:
strongdm.models.Gatewaystrongdm.models.ProxyClusterstrongdm.models.Relay
def
create(self, node, timeout=None)
4661 def create(self, node, timeout=None): 4662 ''' 4663 Create registers a new Node. 4664 ''' 4665 deadline = None if timeout is None else time.time() + timeout 4666 req = NodeCreateRequest() 4667 4668 if node is not None: 4669 req.node.CopyFrom(plumbing.convert_node_to_plumbing(node)) 4670 tries = 0 4671 plumbing_response = None 4672 while True: 4673 t = None if deadline is None else deadline - time.time() 4674 try: 4675 plumbing_response = self.stub.Create( 4676 req, 4677 metadata=self.parent.get_metadata('Nodes.Create', req), 4678 timeout=t) 4679 except Exception as e: 4680 if self.parent.shouldRetry(tries, e, deadline): 4681 tries += 1 4682 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4683 continue 4684 raise plumbing.convert_error_to_porcelain(e) from e 4685 break 4686 4687 resp = models.NodeCreateResponse() 4688 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4689 plumbing_response.meta) 4690 resp.node = plumbing.convert_node_to_porcelain(plumbing_response.node) 4691 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4692 plumbing_response.rate_limit) 4693 resp.token = (plumbing_response.token) 4694 return resp
Create registers a new Node.
def
get(self, id, timeout=None)
4696 def get(self, id, timeout=None): 4697 ''' 4698 Get reads one Node by ID. 4699 ''' 4700 deadline = None if timeout is None else time.time() + timeout 4701 req = NodeGetRequest() 4702 if self.parent.snapshot_datetime is not None: 4703 req.meta.CopyFrom(GetRequestMetadata()) 4704 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4705 4706 req.id = (id) 4707 tries = 0 4708 plumbing_response = None 4709 while True: 4710 t = None if deadline is None else deadline - time.time() 4711 try: 4712 plumbing_response = self.stub.Get( 4713 req, 4714 metadata=self.parent.get_metadata('Nodes.Get', req), 4715 timeout=t) 4716 except Exception as e: 4717 if self.parent.shouldRetry(tries, e, deadline): 4718 tries += 1 4719 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4720 continue 4721 raise plumbing.convert_error_to_porcelain(e) from e 4722 break 4723 4724 resp = models.NodeGetResponse() 4725 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4726 plumbing_response.meta) 4727 resp.node = plumbing.convert_node_to_porcelain(plumbing_response.node) 4728 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4729 plumbing_response.rate_limit) 4730 return resp
Get reads one Node by ID.
def
update(self, node, timeout=None)
4732 def update(self, node, timeout=None): 4733 ''' 4734 Update replaces all the fields of a Node by ID. 4735 ''' 4736 deadline = None if timeout is None else time.time() + timeout 4737 req = NodeUpdateRequest() 4738 4739 if node is not None: 4740 req.node.CopyFrom(plumbing.convert_node_to_plumbing(node)) 4741 tries = 0 4742 plumbing_response = None 4743 while True: 4744 t = None if deadline is None else deadline - time.time() 4745 try: 4746 plumbing_response = self.stub.Update( 4747 req, 4748 metadata=self.parent.get_metadata('Nodes.Update', req), 4749 timeout=t) 4750 except Exception as e: 4751 if self.parent.shouldRetry(tries, e, deadline): 4752 tries += 1 4753 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4754 continue 4755 raise plumbing.convert_error_to_porcelain(e) from e 4756 break 4757 4758 resp = models.NodeUpdateResponse() 4759 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 4760 plumbing_response.meta) 4761 resp.node = plumbing.convert_node_to_porcelain(plumbing_response.node) 4762 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4763 plumbing_response.rate_limit) 4764 return resp
Update replaces all the fields of a Node by ID.
def
delete(self, id, timeout=None)
4766 def delete(self, id, timeout=None): 4767 ''' 4768 Delete removes a Node by ID. 4769 ''' 4770 deadline = None if timeout is None else time.time() + timeout 4771 req = NodeDeleteRequest() 4772 4773 req.id = (id) 4774 tries = 0 4775 plumbing_response = None 4776 while True: 4777 t = None if deadline is None else deadline - time.time() 4778 try: 4779 plumbing_response = self.stub.Delete( 4780 req, 4781 metadata=self.parent.get_metadata('Nodes.Delete', req), 4782 timeout=t) 4783 except Exception as e: 4784 if self.parent.shouldRetry(tries, e, deadline): 4785 tries += 1 4786 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4787 continue 4788 raise plumbing.convert_error_to_porcelain(e) from e 4789 break 4790 4791 resp = models.NodeDeleteResponse() 4792 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 4793 plumbing_response.meta) 4794 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4795 plumbing_response.rate_limit) 4796 return resp
Delete removes a Node by ID.
def
list(self, filter, *args, timeout=None)
4798 def list(self, filter, *args, timeout=None): 4799 ''' 4800 List gets a list of Nodes matching a given set of criteria. 4801 ''' 4802 deadline = None if timeout is None else time.time() + timeout 4803 req = NodeListRequest() 4804 req.meta.CopyFrom(ListRequestMetadata()) 4805 if self.parent.page_limit > 0: 4806 req.meta.limit = self.parent.page_limit 4807 if self.parent.snapshot_datetime is not None: 4808 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4809 4810 req.filter = plumbing.quote_filter_args(filter, *args) 4811 4812 def generator(svc, req): 4813 tries = 0 4814 while True: 4815 t = None if deadline is None else deadline - time.time() 4816 try: 4817 plumbing_response = svc.stub.List( 4818 req, 4819 metadata=svc.parent.get_metadata('Nodes.List', req), 4820 timeout=t) 4821 except Exception as e: 4822 if self.parent.shouldRetry(tries, e, deadline): 4823 tries += 1 4824 time.sleep( 4825 self.parent.exponentialBackoff(tries, deadline)) 4826 continue 4827 raise plumbing.convert_error_to_porcelain(e) from e 4828 tries = 0 4829 for plumbing_item in plumbing_response.nodes: 4830 yield plumbing.convert_node_to_porcelain(plumbing_item) 4831 if plumbing_response.meta.next_cursor == '': 4832 break 4833 req.meta.cursor = plumbing_response.meta.next_cursor 4834 4835 return generator(self, req)
List gets a list of Nodes matching a given set of criteria.
def
tcp_probe(self, node_id, host, port, timeout=None)
4837 def tcp_probe(self, node_id, host, port, timeout=None): 4838 ''' 4839 TCPProbe instructs a Node to connect to an address via TCP and report the 4840 result. 4841 ''' 4842 deadline = None if timeout is None else time.time() + timeout 4843 req = NodeTCPProbeRequest() 4844 4845 req.node_id = (node_id) 4846 req.host = (host) 4847 req.port = (port) 4848 tries = 0 4849 plumbing_response = None 4850 while True: 4851 t = None if deadline is None else deadline - time.time() 4852 try: 4853 plumbing_response = self.stub.TCPProbe( 4854 req, 4855 metadata=self.parent.get_metadata('Nodes.TCPProbe', req), 4856 timeout=t) 4857 except Exception as e: 4858 if self.parent.shouldRetry(tries, e, deadline): 4859 tries += 1 4860 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4861 continue 4862 raise plumbing.convert_error_to_porcelain(e) from e 4863 break 4864 4865 resp = models.NodeTCPProbeResponse() 4866 resp.error = (plumbing_response.error) 4867 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4868 plumbing_response.meta) 4869 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4870 plumbing_response.rate_limit) 4871 resp.succeeded = (plumbing_response.succeeded) 4872 return resp
TCPProbe instructs a Node to connect to an address via TCP and report the result.
class
SnapshotNodes:
4875class SnapshotNodes: 4876 ''' 4877 SnapshotNodes exposes the read only methods of the Nodes 4878 service for historical queries. 4879 ''' 4880 def __init__(self, nodes): 4881 self.nodes = nodes 4882 4883 def get(self, id, timeout=None): 4884 ''' 4885 Get reads one Node by ID. 4886 ''' 4887 return self.nodes.get(id, timeout=timeout) 4888 4889 def list(self, filter, *args, timeout=None): 4890 ''' 4891 List gets a list of Nodes matching a given set of criteria. 4892 ''' 4893 return self.nodes.list(filter, *args, timeout=timeout)
SnapshotNodes exposes the read only methods of the Nodes service for historical queries.
class
NodesHistory:
4896class NodesHistory: 4897 ''' 4898 NodesHistory records all changes to the state of a Node. 4899 See `strongdm.models.NodeHistory`. 4900 ''' 4901 def __init__(self, channel, client): 4902 self.parent = client 4903 self.stub = NodesHistoryStub(channel) 4904 4905 def list(self, filter, *args, timeout=None): 4906 ''' 4907 List gets a list of NodeHistory records matching a given set of criteria. 4908 ''' 4909 deadline = None if timeout is None else time.time() + timeout 4910 req = NodeHistoryListRequest() 4911 req.meta.CopyFrom(ListRequestMetadata()) 4912 if self.parent.page_limit > 0: 4913 req.meta.limit = self.parent.page_limit 4914 if self.parent.snapshot_datetime is not None: 4915 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4916 4917 req.filter = plumbing.quote_filter_args(filter, *args) 4918 4919 def generator(svc, req): 4920 tries = 0 4921 while True: 4922 t = None if deadline is None else deadline - time.time() 4923 try: 4924 plumbing_response = svc.stub.List( 4925 req, 4926 metadata=svc.parent.get_metadata( 4927 'NodesHistory.List', req), 4928 timeout=t) 4929 except Exception as e: 4930 if self.parent.shouldRetry(tries, e, deadline): 4931 tries += 1 4932 time.sleep( 4933 self.parent.exponentialBackoff(tries, deadline)) 4934 continue 4935 raise plumbing.convert_error_to_porcelain(e) from e 4936 tries = 0 4937 for plumbing_item in plumbing_response.history: 4938 yield plumbing.convert_node_history_to_porcelain( 4939 plumbing_item) 4940 if plumbing_response.meta.next_cursor == '': 4941 break 4942 req.meta.cursor = plumbing_response.meta.next_cursor 4943 4944 return generator(self, req)
NodesHistory records all changes to the state of a Node.
See strongdm.models.NodeHistory.
def
list(self, filter, *args, timeout=None)
4905 def list(self, filter, *args, timeout=None): 4906 ''' 4907 List gets a list of NodeHistory records matching a given set of criteria. 4908 ''' 4909 deadline = None if timeout is None else time.time() + timeout 4910 req = NodeHistoryListRequest() 4911 req.meta.CopyFrom(ListRequestMetadata()) 4912 if self.parent.page_limit > 0: 4913 req.meta.limit = self.parent.page_limit 4914 if self.parent.snapshot_datetime is not None: 4915 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4916 4917 req.filter = plumbing.quote_filter_args(filter, *args) 4918 4919 def generator(svc, req): 4920 tries = 0 4921 while True: 4922 t = None if deadline is None else deadline - time.time() 4923 try: 4924 plumbing_response = svc.stub.List( 4925 req, 4926 metadata=svc.parent.get_metadata( 4927 'NodesHistory.List', req), 4928 timeout=t) 4929 except Exception as e: 4930 if self.parent.shouldRetry(tries, e, deadline): 4931 tries += 1 4932 time.sleep( 4933 self.parent.exponentialBackoff(tries, deadline)) 4934 continue 4935 raise plumbing.convert_error_to_porcelain(e) from e 4936 tries = 0 4937 for plumbing_item in plumbing_response.history: 4938 yield plumbing.convert_node_history_to_porcelain( 4939 plumbing_item) 4940 if plumbing_response.meta.next_cursor == '': 4941 break 4942 req.meta.cursor = plumbing_response.meta.next_cursor 4943 4944 return generator(self, req)
List gets a list of NodeHistory records matching a given set of criteria.
class
OrganizationHistory:
4947class OrganizationHistory: 4948 ''' 4949 OrganizationHistory records all changes to the state of an Organization. 4950 See `strongdm.models.OrganizationHistoryRecord`. 4951 ''' 4952 def __init__(self, channel, client): 4953 self.parent = client 4954 self.stub = OrganizationHistoryStub(channel) 4955 4956 def list(self, filter, *args, timeout=None): 4957 ''' 4958 List gets a list of OrganizationHistory records matching a given set of criteria. 4959 ''' 4960 deadline = None if timeout is None else time.time() + timeout 4961 req = OrganizationHistoryListRequest() 4962 req.meta.CopyFrom(ListRequestMetadata()) 4963 if self.parent.page_limit > 0: 4964 req.meta.limit = self.parent.page_limit 4965 if self.parent.snapshot_datetime is not None: 4966 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4967 4968 req.filter = plumbing.quote_filter_args(filter, *args) 4969 4970 def generator(svc, req): 4971 tries = 0 4972 while True: 4973 t = None if deadline is None else deadline - time.time() 4974 try: 4975 plumbing_response = svc.stub.List( 4976 req, 4977 metadata=svc.parent.get_metadata( 4978 'OrganizationHistory.List', req), 4979 timeout=t) 4980 except Exception as e: 4981 if self.parent.shouldRetry(tries, e, deadline): 4982 tries += 1 4983 time.sleep( 4984 self.parent.exponentialBackoff(tries, deadline)) 4985 continue 4986 raise plumbing.convert_error_to_porcelain(e) from e 4987 tries = 0 4988 for plumbing_item in plumbing_response.history: 4989 yield plumbing.convert_organization_history_record_to_porcelain( 4990 plumbing_item) 4991 if plumbing_response.meta.next_cursor == '': 4992 break 4993 req.meta.cursor = plumbing_response.meta.next_cursor 4994 4995 return generator(self, req)
OrganizationHistory records all changes to the state of an Organization.
See strongdm.models.OrganizationHistoryRecord.
def
list(self, filter, *args, timeout=None)
4956 def list(self, filter, *args, timeout=None): 4957 ''' 4958 List gets a list of OrganizationHistory records matching a given set of criteria. 4959 ''' 4960 deadline = None if timeout is None else time.time() + timeout 4961 req = OrganizationHistoryListRequest() 4962 req.meta.CopyFrom(ListRequestMetadata()) 4963 if self.parent.page_limit > 0: 4964 req.meta.limit = self.parent.page_limit 4965 if self.parent.snapshot_datetime is not None: 4966 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4967 4968 req.filter = plumbing.quote_filter_args(filter, *args) 4969 4970 def generator(svc, req): 4971 tries = 0 4972 while True: 4973 t = None if deadline is None else deadline - time.time() 4974 try: 4975 plumbing_response = svc.stub.List( 4976 req, 4977 metadata=svc.parent.get_metadata( 4978 'OrganizationHistory.List', req), 4979 timeout=t) 4980 except Exception as e: 4981 if self.parent.shouldRetry(tries, e, deadline): 4982 tries += 1 4983 time.sleep( 4984 self.parent.exponentialBackoff(tries, deadline)) 4985 continue 4986 raise plumbing.convert_error_to_porcelain(e) from e 4987 tries = 0 4988 for plumbing_item in plumbing_response.history: 4989 yield plumbing.convert_organization_history_record_to_porcelain( 4990 plumbing_item) 4991 if plumbing_response.meta.next_cursor == '': 4992 break 4993 req.meta.cursor = plumbing_response.meta.next_cursor 4994 4995 return generator(self, req)
List gets a list of OrganizationHistory records matching a given set of criteria.
class
Organizations:
4998class Organizations: 4999 ''' 5000 Organizations exposes organization configuration. Most RPCs remain private to the 5001 go_private SDK; public MFA management is exposed to all public SDK targets. 5002 The terraform-provider target is opted out at the service level because the 5003 provider's data-source generator assumes every service has a List RPC; MFA is 5004 instead surfaced via a hand-written resource template. 5005 See `strongdm.models.Organization`. 5006 ''' 5007 def __init__(self, channel, client): 5008 self.parent = client 5009 self.stub = OrganizationsStub(channel) 5010 5011 def get_mfa(self, timeout=None): 5012 ''' 5013 GetMFA gets the organization's MFA configuration. 5014 ''' 5015 deadline = None if timeout is None else time.time() + timeout 5016 req = OrganizationGetMFARequest() 5017 5018 tries = 0 5019 plumbing_response = None 5020 while True: 5021 t = None if deadline is None else deadline - time.time() 5022 try: 5023 plumbing_response = self.stub.GetMFA( 5024 req, 5025 metadata=self.parent.get_metadata('Organizations.GetMFA', 5026 req), 5027 timeout=t) 5028 except Exception as e: 5029 if self.parent.shouldRetry(tries, e, deadline): 5030 tries += 1 5031 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5032 continue 5033 raise plumbing.convert_error_to_porcelain(e) from e 5034 break 5035 5036 resp = models.OrganizationGetMFAResponse() 5037 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5038 plumbing_response.meta) 5039 resp.mfa = plumbing.convert_mfa_config_to_porcelain( 5040 plumbing_response.mfa) 5041 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5042 plumbing_response.rate_limit) 5043 return resp 5044 5045 def update_mfa(self, mfa, timeout=None): 5046 ''' 5047 UpdateMFA updates the organization's MFA configuration. 5048 ''' 5049 deadline = None if timeout is None else time.time() + timeout 5050 req = OrganizationUpdateMFARequest() 5051 5052 if mfa is not None: 5053 req.mfa.CopyFrom(plumbing.convert_mfa_config_to_plumbing(mfa)) 5054 tries = 0 5055 plumbing_response = None 5056 while True: 5057 t = None if deadline is None else deadline - time.time() 5058 try: 5059 plumbing_response = self.stub.UpdateMFA( 5060 req, 5061 metadata=self.parent.get_metadata( 5062 'Organizations.UpdateMFA', req), 5063 timeout=t) 5064 except Exception as e: 5065 if self.parent.shouldRetry(tries, e, deadline): 5066 tries += 1 5067 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5068 continue 5069 raise plumbing.convert_error_to_porcelain(e) from e 5070 break 5071 5072 resp = models.OrganizationUpdateMFAResponse() 5073 resp.mfa = plumbing.convert_mfa_config_to_porcelain( 5074 plumbing_response.mfa) 5075 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5076 plumbing_response.rate_limit) 5077 return resp 5078 5079 def test_mfa(self, mfa, timeout=None): 5080 ''' 5081 TestMFA validates MFA connectivity without persisting changes. 5082 ''' 5083 deadline = None if timeout is None else time.time() + timeout 5084 req = OrganizationTestMFARequest() 5085 5086 if mfa is not None: 5087 req.mfa.CopyFrom(plumbing.convert_mfa_config_to_plumbing(mfa)) 5088 tries = 0 5089 plumbing_response = None 5090 while True: 5091 t = None if deadline is None else deadline - time.time() 5092 try: 5093 plumbing_response = self.stub.TestMFA( 5094 req, 5095 metadata=self.parent.get_metadata('Organizations.TestMFA', 5096 req), 5097 timeout=t) 5098 except Exception as e: 5099 if self.parent.shouldRetry(tries, e, deadline): 5100 tries += 1 5101 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5102 continue 5103 raise plumbing.convert_error_to_porcelain(e) from e 5104 break 5105 5106 resp = models.OrganizationTestMFAResponse() 5107 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5108 plumbing_response.rate_limit) 5109 return resp
Organizations exposes organization configuration. Most RPCs remain private to the
go_private SDK; public MFA management is exposed to all public SDK targets.
The terraform-provider target is opted out at the service level because the
provider's data-source generator assumes every service has a List RPC; MFA is
instead surfaced via a hand-written resource template.
See strongdm.models.Organization.
def
get_mfa(self, timeout=None)
5011 def get_mfa(self, timeout=None): 5012 ''' 5013 GetMFA gets the organization's MFA configuration. 5014 ''' 5015 deadline = None if timeout is None else time.time() + timeout 5016 req = OrganizationGetMFARequest() 5017 5018 tries = 0 5019 plumbing_response = None 5020 while True: 5021 t = None if deadline is None else deadline - time.time() 5022 try: 5023 plumbing_response = self.stub.GetMFA( 5024 req, 5025 metadata=self.parent.get_metadata('Organizations.GetMFA', 5026 req), 5027 timeout=t) 5028 except Exception as e: 5029 if self.parent.shouldRetry(tries, e, deadline): 5030 tries += 1 5031 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5032 continue 5033 raise plumbing.convert_error_to_porcelain(e) from e 5034 break 5035 5036 resp = models.OrganizationGetMFAResponse() 5037 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5038 plumbing_response.meta) 5039 resp.mfa = plumbing.convert_mfa_config_to_porcelain( 5040 plumbing_response.mfa) 5041 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5042 plumbing_response.rate_limit) 5043 return resp
GetMFA gets the organization's MFA configuration.
def
update_mfa(self, mfa, timeout=None)
5045 def update_mfa(self, mfa, timeout=None): 5046 ''' 5047 UpdateMFA updates the organization's MFA configuration. 5048 ''' 5049 deadline = None if timeout is None else time.time() + timeout 5050 req = OrganizationUpdateMFARequest() 5051 5052 if mfa is not None: 5053 req.mfa.CopyFrom(plumbing.convert_mfa_config_to_plumbing(mfa)) 5054 tries = 0 5055 plumbing_response = None 5056 while True: 5057 t = None if deadline is None else deadline - time.time() 5058 try: 5059 plumbing_response = self.stub.UpdateMFA( 5060 req, 5061 metadata=self.parent.get_metadata( 5062 'Organizations.UpdateMFA', req), 5063 timeout=t) 5064 except Exception as e: 5065 if self.parent.shouldRetry(tries, e, deadline): 5066 tries += 1 5067 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5068 continue 5069 raise plumbing.convert_error_to_porcelain(e) from e 5070 break 5071 5072 resp = models.OrganizationUpdateMFAResponse() 5073 resp.mfa = plumbing.convert_mfa_config_to_porcelain( 5074 plumbing_response.mfa) 5075 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5076 plumbing_response.rate_limit) 5077 return resp
UpdateMFA updates the organization's MFA configuration.
def
test_mfa(self, mfa, timeout=None)
5079 def test_mfa(self, mfa, timeout=None): 5080 ''' 5081 TestMFA validates MFA connectivity without persisting changes. 5082 ''' 5083 deadline = None if timeout is None else time.time() + timeout 5084 req = OrganizationTestMFARequest() 5085 5086 if mfa is not None: 5087 req.mfa.CopyFrom(plumbing.convert_mfa_config_to_plumbing(mfa)) 5088 tries = 0 5089 plumbing_response = None 5090 while True: 5091 t = None if deadline is None else deadline - time.time() 5092 try: 5093 plumbing_response = self.stub.TestMFA( 5094 req, 5095 metadata=self.parent.get_metadata('Organizations.TestMFA', 5096 req), 5097 timeout=t) 5098 except Exception as e: 5099 if self.parent.shouldRetry(tries, e, deadline): 5100 tries += 1 5101 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5102 continue 5103 raise plumbing.convert_error_to_porcelain(e) from e 5104 break 5105 5106 resp = models.OrganizationTestMFAResponse() 5107 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5108 plumbing_response.rate_limit) 5109 return resp
TestMFA validates MFA connectivity without persisting changes.
class
PeeringGroupNodes:
5112class PeeringGroupNodes: 5113 ''' 5114 PeeringGroupNodes provides the building blocks necessary to obtain attach a node to a peering group. 5115 See `strongdm.models.PeeringGroupNode`. 5116 ''' 5117 def __init__(self, channel, client): 5118 self.parent = client 5119 self.stub = PeeringGroupNodesStub(channel) 5120 5121 def create(self, peering_group_node, timeout=None): 5122 ''' 5123 Create attaches a Node to a PeeringGroup 5124 ''' 5125 deadline = None if timeout is None else time.time() + timeout 5126 req = PeeringGroupNodeCreateRequest() 5127 5128 if peering_group_node is not None: 5129 req.peering_group_node.CopyFrom( 5130 plumbing.convert_peering_group_node_to_plumbing( 5131 peering_group_node)) 5132 tries = 0 5133 plumbing_response = None 5134 while True: 5135 t = None if deadline is None else deadline - time.time() 5136 try: 5137 plumbing_response = self.stub.Create( 5138 req, 5139 metadata=self.parent.get_metadata( 5140 'PeeringGroupNodes.Create', req), 5141 timeout=t) 5142 except Exception as e: 5143 if self.parent.shouldRetry(tries, e, deadline): 5144 tries += 1 5145 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5146 continue 5147 raise plumbing.convert_error_to_porcelain(e) from e 5148 break 5149 5150 resp = models.PeeringGroupNodeCreateResponse() 5151 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5152 plumbing_response.meta) 5153 resp.peering_group_node = plumbing.convert_peering_group_node_to_porcelain( 5154 plumbing_response.peering_group_node) 5155 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5156 plumbing_response.rate_limit) 5157 return resp 5158 5159 def delete(self, id, timeout=None): 5160 ''' 5161 Delete detaches a Node to a PeeringGroup. 5162 ''' 5163 deadline = None if timeout is None else time.time() + timeout 5164 req = PeeringGroupNodeDeleteRequest() 5165 5166 req.id = (id) 5167 tries = 0 5168 plumbing_response = None 5169 while True: 5170 t = None if deadline is None else deadline - time.time() 5171 try: 5172 plumbing_response = self.stub.Delete( 5173 req, 5174 metadata=self.parent.get_metadata( 5175 'PeeringGroupNodes.Delete', req), 5176 timeout=t) 5177 except Exception as e: 5178 if self.parent.shouldRetry(tries, e, deadline): 5179 tries += 1 5180 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5181 continue 5182 raise plumbing.convert_error_to_porcelain(e) from e 5183 break 5184 5185 resp = models.PeeringGroupNodeDeleteResponse() 5186 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 5187 plumbing_response.meta) 5188 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5189 plumbing_response.rate_limit) 5190 return resp 5191 5192 def get(self, id, timeout=None): 5193 ''' 5194 Get reads the information of one peering group to node attachment. 5195 ''' 5196 deadline = None if timeout is None else time.time() + timeout 5197 req = PeeringGroupNodeGetRequest() 5198 if self.parent.snapshot_datetime is not None: 5199 req.meta.CopyFrom(GetRequestMetadata()) 5200 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5201 5202 req.id = (id) 5203 tries = 0 5204 plumbing_response = None 5205 while True: 5206 t = None if deadline is None else deadline - time.time() 5207 try: 5208 plumbing_response = self.stub.Get( 5209 req, 5210 metadata=self.parent.get_metadata('PeeringGroupNodes.Get', 5211 req), 5212 timeout=t) 5213 except Exception as e: 5214 if self.parent.shouldRetry(tries, e, deadline): 5215 tries += 1 5216 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5217 continue 5218 raise plumbing.convert_error_to_porcelain(e) from e 5219 break 5220 5221 resp = models.PeeringGroupNodeGetResponse() 5222 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5223 plumbing_response.meta) 5224 resp.peering_group_node = plumbing.convert_peering_group_node_to_porcelain( 5225 plumbing_response.peering_group_node) 5226 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5227 plumbing_response.rate_limit) 5228 return resp 5229 5230 def list(self, filter, *args, timeout=None): 5231 ''' 5232 List gets a list of peering group node attachments. 5233 ''' 5234 deadline = None if timeout is None else time.time() + timeout 5235 req = PeeringGroupNodeListRequest() 5236 req.meta.CopyFrom(ListRequestMetadata()) 5237 if self.parent.page_limit > 0: 5238 req.meta.limit = self.parent.page_limit 5239 if self.parent.snapshot_datetime is not None: 5240 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5241 5242 req.filter = plumbing.quote_filter_args(filter, *args) 5243 5244 def generator(svc, req): 5245 tries = 0 5246 while True: 5247 t = None if deadline is None else deadline - time.time() 5248 try: 5249 plumbing_response = svc.stub.List( 5250 req, 5251 metadata=svc.parent.get_metadata( 5252 'PeeringGroupNodes.List', req), 5253 timeout=t) 5254 except Exception as e: 5255 if self.parent.shouldRetry(tries, e, deadline): 5256 tries += 1 5257 time.sleep( 5258 self.parent.exponentialBackoff(tries, deadline)) 5259 continue 5260 raise plumbing.convert_error_to_porcelain(e) from e 5261 tries = 0 5262 for plumbing_item in plumbing_response.peering_group_nodes: 5263 yield plumbing.convert_peering_group_node_to_porcelain( 5264 plumbing_item) 5265 if plumbing_response.meta.next_cursor == '': 5266 break 5267 req.meta.cursor = plumbing_response.meta.next_cursor 5268 5269 return generator(self, req)
PeeringGroupNodes provides the building blocks necessary to obtain attach a node to a peering group.
See strongdm.models.PeeringGroupNode.
def
create(self, peering_group_node, timeout=None)
5121 def create(self, peering_group_node, timeout=None): 5122 ''' 5123 Create attaches a Node to a PeeringGroup 5124 ''' 5125 deadline = None if timeout is None else time.time() + timeout 5126 req = PeeringGroupNodeCreateRequest() 5127 5128 if peering_group_node is not None: 5129 req.peering_group_node.CopyFrom( 5130 plumbing.convert_peering_group_node_to_plumbing( 5131 peering_group_node)) 5132 tries = 0 5133 plumbing_response = None 5134 while True: 5135 t = None if deadline is None else deadline - time.time() 5136 try: 5137 plumbing_response = self.stub.Create( 5138 req, 5139 metadata=self.parent.get_metadata( 5140 'PeeringGroupNodes.Create', req), 5141 timeout=t) 5142 except Exception as e: 5143 if self.parent.shouldRetry(tries, e, deadline): 5144 tries += 1 5145 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5146 continue 5147 raise plumbing.convert_error_to_porcelain(e) from e 5148 break 5149 5150 resp = models.PeeringGroupNodeCreateResponse() 5151 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5152 plumbing_response.meta) 5153 resp.peering_group_node = plumbing.convert_peering_group_node_to_porcelain( 5154 plumbing_response.peering_group_node) 5155 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5156 plumbing_response.rate_limit) 5157 return resp
Create attaches a Node to a PeeringGroup
def
delete(self, id, timeout=None)
5159 def delete(self, id, timeout=None): 5160 ''' 5161 Delete detaches a Node to a PeeringGroup. 5162 ''' 5163 deadline = None if timeout is None else time.time() + timeout 5164 req = PeeringGroupNodeDeleteRequest() 5165 5166 req.id = (id) 5167 tries = 0 5168 plumbing_response = None 5169 while True: 5170 t = None if deadline is None else deadline - time.time() 5171 try: 5172 plumbing_response = self.stub.Delete( 5173 req, 5174 metadata=self.parent.get_metadata( 5175 'PeeringGroupNodes.Delete', req), 5176 timeout=t) 5177 except Exception as e: 5178 if self.parent.shouldRetry(tries, e, deadline): 5179 tries += 1 5180 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5181 continue 5182 raise plumbing.convert_error_to_porcelain(e) from e 5183 break 5184 5185 resp = models.PeeringGroupNodeDeleteResponse() 5186 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 5187 plumbing_response.meta) 5188 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5189 plumbing_response.rate_limit) 5190 return resp
Delete detaches a Node to a PeeringGroup.
def
get(self, id, timeout=None)
5192 def get(self, id, timeout=None): 5193 ''' 5194 Get reads the information of one peering group to node attachment. 5195 ''' 5196 deadline = None if timeout is None else time.time() + timeout 5197 req = PeeringGroupNodeGetRequest() 5198 if self.parent.snapshot_datetime is not None: 5199 req.meta.CopyFrom(GetRequestMetadata()) 5200 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5201 5202 req.id = (id) 5203 tries = 0 5204 plumbing_response = None 5205 while True: 5206 t = None if deadline is None else deadline - time.time() 5207 try: 5208 plumbing_response = self.stub.Get( 5209 req, 5210 metadata=self.parent.get_metadata('PeeringGroupNodes.Get', 5211 req), 5212 timeout=t) 5213 except Exception as e: 5214 if self.parent.shouldRetry(tries, e, deadline): 5215 tries += 1 5216 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5217 continue 5218 raise plumbing.convert_error_to_porcelain(e) from e 5219 break 5220 5221 resp = models.PeeringGroupNodeGetResponse() 5222 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5223 plumbing_response.meta) 5224 resp.peering_group_node = plumbing.convert_peering_group_node_to_porcelain( 5225 plumbing_response.peering_group_node) 5226 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5227 plumbing_response.rate_limit) 5228 return resp
Get reads the information of one peering group to node attachment.
def
list(self, filter, *args, timeout=None)
5230 def list(self, filter, *args, timeout=None): 5231 ''' 5232 List gets a list of peering group node attachments. 5233 ''' 5234 deadline = None if timeout is None else time.time() + timeout 5235 req = PeeringGroupNodeListRequest() 5236 req.meta.CopyFrom(ListRequestMetadata()) 5237 if self.parent.page_limit > 0: 5238 req.meta.limit = self.parent.page_limit 5239 if self.parent.snapshot_datetime is not None: 5240 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5241 5242 req.filter = plumbing.quote_filter_args(filter, *args) 5243 5244 def generator(svc, req): 5245 tries = 0 5246 while True: 5247 t = None if deadline is None else deadline - time.time() 5248 try: 5249 plumbing_response = svc.stub.List( 5250 req, 5251 metadata=svc.parent.get_metadata( 5252 'PeeringGroupNodes.List', req), 5253 timeout=t) 5254 except Exception as e: 5255 if self.parent.shouldRetry(tries, e, deadline): 5256 tries += 1 5257 time.sleep( 5258 self.parent.exponentialBackoff(tries, deadline)) 5259 continue 5260 raise plumbing.convert_error_to_porcelain(e) from e 5261 tries = 0 5262 for plumbing_item in plumbing_response.peering_group_nodes: 5263 yield plumbing.convert_peering_group_node_to_porcelain( 5264 plumbing_item) 5265 if plumbing_response.meta.next_cursor == '': 5266 break 5267 req.meta.cursor = plumbing_response.meta.next_cursor 5268 5269 return generator(self, req)
List gets a list of peering group node attachments.
class
PeeringGroupPeers:
5272class PeeringGroupPeers: 5273 ''' 5274 PeeringGroupPeers provides the building blocks necessary to link two peering groups. 5275 See `strongdm.models.PeeringGroupPeer`. 5276 ''' 5277 def __init__(self, channel, client): 5278 self.parent = client 5279 self.stub = PeeringGroupPeersStub(channel) 5280 5281 def create(self, peering_group_peer, timeout=None): 5282 ''' 5283 Create links two peering groups. 5284 ''' 5285 deadline = None if timeout is None else time.time() + timeout 5286 req = PeeringGroupPeerCreateRequest() 5287 5288 if peering_group_peer is not None: 5289 req.peering_group_peer.CopyFrom( 5290 plumbing.convert_peering_group_peer_to_plumbing( 5291 peering_group_peer)) 5292 tries = 0 5293 plumbing_response = None 5294 while True: 5295 t = None if deadline is None else deadline - time.time() 5296 try: 5297 plumbing_response = self.stub.Create( 5298 req, 5299 metadata=self.parent.get_metadata( 5300 'PeeringGroupPeers.Create', req), 5301 timeout=t) 5302 except Exception as e: 5303 if self.parent.shouldRetry(tries, e, deadline): 5304 tries += 1 5305 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5306 continue 5307 raise plumbing.convert_error_to_porcelain(e) from e 5308 break 5309 5310 resp = models.PeeringGroupPeerCreateResponse() 5311 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5312 plumbing_response.meta) 5313 resp.peering_group_peer = plumbing.convert_peering_group_peer_to_porcelain( 5314 plumbing_response.peering_group_peer) 5315 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5316 plumbing_response.rate_limit) 5317 return resp 5318 5319 def delete(self, id, timeout=None): 5320 ''' 5321 Delete unlinks two peering groups. 5322 ''' 5323 deadline = None if timeout is None else time.time() + timeout 5324 req = PeeringGroupPeerDeleteRequest() 5325 5326 req.id = (id) 5327 tries = 0 5328 plumbing_response = None 5329 while True: 5330 t = None if deadline is None else deadline - time.time() 5331 try: 5332 plumbing_response = self.stub.Delete( 5333 req, 5334 metadata=self.parent.get_metadata( 5335 'PeeringGroupPeers.Delete', req), 5336 timeout=t) 5337 except Exception as e: 5338 if self.parent.shouldRetry(tries, e, deadline): 5339 tries += 1 5340 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5341 continue 5342 raise plumbing.convert_error_to_porcelain(e) from e 5343 break 5344 5345 resp = models.PeeringGroupPeerDeleteResponse() 5346 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 5347 plumbing_response.meta) 5348 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5349 plumbing_response.rate_limit) 5350 return resp 5351 5352 def get(self, id, timeout=None): 5353 ''' 5354 Get reads the information of one peering group link. 5355 ''' 5356 deadline = None if timeout is None else time.time() + timeout 5357 req = PeeringGroupPeerGetRequest() 5358 if self.parent.snapshot_datetime is not None: 5359 req.meta.CopyFrom(GetRequestMetadata()) 5360 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5361 5362 req.id = (id) 5363 tries = 0 5364 plumbing_response = None 5365 while True: 5366 t = None if deadline is None else deadline - time.time() 5367 try: 5368 plumbing_response = self.stub.Get( 5369 req, 5370 metadata=self.parent.get_metadata('PeeringGroupPeers.Get', 5371 req), 5372 timeout=t) 5373 except Exception as e: 5374 if self.parent.shouldRetry(tries, e, deadline): 5375 tries += 1 5376 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5377 continue 5378 raise plumbing.convert_error_to_porcelain(e) from e 5379 break 5380 5381 resp = models.PeeringGroupPeerGetResponse() 5382 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5383 plumbing_response.meta) 5384 resp.peering_group_peer = plumbing.convert_peering_group_peer_to_porcelain( 5385 plumbing_response.peering_group_peer) 5386 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5387 plumbing_response.rate_limit) 5388 return resp 5389 5390 def list(self, filter, *args, timeout=None): 5391 ''' 5392 List gets a list of peering group links. 5393 ''' 5394 deadline = None if timeout is None else time.time() + timeout 5395 req = PeeringGroupPeerListRequest() 5396 req.meta.CopyFrom(ListRequestMetadata()) 5397 if self.parent.page_limit > 0: 5398 req.meta.limit = self.parent.page_limit 5399 if self.parent.snapshot_datetime is not None: 5400 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5401 5402 req.filter = plumbing.quote_filter_args(filter, *args) 5403 5404 def generator(svc, req): 5405 tries = 0 5406 while True: 5407 t = None if deadline is None else deadline - time.time() 5408 try: 5409 plumbing_response = svc.stub.List( 5410 req, 5411 metadata=svc.parent.get_metadata( 5412 'PeeringGroupPeers.List', req), 5413 timeout=t) 5414 except Exception as e: 5415 if self.parent.shouldRetry(tries, e, deadline): 5416 tries += 1 5417 time.sleep( 5418 self.parent.exponentialBackoff(tries, deadline)) 5419 continue 5420 raise plumbing.convert_error_to_porcelain(e) from e 5421 tries = 0 5422 for plumbing_item in plumbing_response.peering_group_peers: 5423 yield plumbing.convert_peering_group_peer_to_porcelain( 5424 plumbing_item) 5425 if plumbing_response.meta.next_cursor == '': 5426 break 5427 req.meta.cursor = plumbing_response.meta.next_cursor 5428 5429 return generator(self, req)
PeeringGroupPeers provides the building blocks necessary to link two peering groups.
See strongdm.models.PeeringGroupPeer.
def
create(self, peering_group_peer, timeout=None)
5281 def create(self, peering_group_peer, timeout=None): 5282 ''' 5283 Create links two peering groups. 5284 ''' 5285 deadline = None if timeout is None else time.time() + timeout 5286 req = PeeringGroupPeerCreateRequest() 5287 5288 if peering_group_peer is not None: 5289 req.peering_group_peer.CopyFrom( 5290 plumbing.convert_peering_group_peer_to_plumbing( 5291 peering_group_peer)) 5292 tries = 0 5293 plumbing_response = None 5294 while True: 5295 t = None if deadline is None else deadline - time.time() 5296 try: 5297 plumbing_response = self.stub.Create( 5298 req, 5299 metadata=self.parent.get_metadata( 5300 'PeeringGroupPeers.Create', req), 5301 timeout=t) 5302 except Exception as e: 5303 if self.parent.shouldRetry(tries, e, deadline): 5304 tries += 1 5305 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5306 continue 5307 raise plumbing.convert_error_to_porcelain(e) from e 5308 break 5309 5310 resp = models.PeeringGroupPeerCreateResponse() 5311 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5312 plumbing_response.meta) 5313 resp.peering_group_peer = plumbing.convert_peering_group_peer_to_porcelain( 5314 plumbing_response.peering_group_peer) 5315 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5316 plumbing_response.rate_limit) 5317 return resp
Create links two peering groups.
def
delete(self, id, timeout=None)
5319 def delete(self, id, timeout=None): 5320 ''' 5321 Delete unlinks two peering groups. 5322 ''' 5323 deadline = None if timeout is None else time.time() + timeout 5324 req = PeeringGroupPeerDeleteRequest() 5325 5326 req.id = (id) 5327 tries = 0 5328 plumbing_response = None 5329 while True: 5330 t = None if deadline is None else deadline - time.time() 5331 try: 5332 plumbing_response = self.stub.Delete( 5333 req, 5334 metadata=self.parent.get_metadata( 5335 'PeeringGroupPeers.Delete', req), 5336 timeout=t) 5337 except Exception as e: 5338 if self.parent.shouldRetry(tries, e, deadline): 5339 tries += 1 5340 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5341 continue 5342 raise plumbing.convert_error_to_porcelain(e) from e 5343 break 5344 5345 resp = models.PeeringGroupPeerDeleteResponse() 5346 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 5347 plumbing_response.meta) 5348 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5349 plumbing_response.rate_limit) 5350 return resp
Delete unlinks two peering groups.
def
get(self, id, timeout=None)
5352 def get(self, id, timeout=None): 5353 ''' 5354 Get reads the information of one peering group link. 5355 ''' 5356 deadline = None if timeout is None else time.time() + timeout 5357 req = PeeringGroupPeerGetRequest() 5358 if self.parent.snapshot_datetime is not None: 5359 req.meta.CopyFrom(GetRequestMetadata()) 5360 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5361 5362 req.id = (id) 5363 tries = 0 5364 plumbing_response = None 5365 while True: 5366 t = None if deadline is None else deadline - time.time() 5367 try: 5368 plumbing_response = self.stub.Get( 5369 req, 5370 metadata=self.parent.get_metadata('PeeringGroupPeers.Get', 5371 req), 5372 timeout=t) 5373 except Exception as e: 5374 if self.parent.shouldRetry(tries, e, deadline): 5375 tries += 1 5376 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5377 continue 5378 raise plumbing.convert_error_to_porcelain(e) from e 5379 break 5380 5381 resp = models.PeeringGroupPeerGetResponse() 5382 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5383 plumbing_response.meta) 5384 resp.peering_group_peer = plumbing.convert_peering_group_peer_to_porcelain( 5385 plumbing_response.peering_group_peer) 5386 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5387 plumbing_response.rate_limit) 5388 return resp
Get reads the information of one peering group link.
def
list(self, filter, *args, timeout=None)
5390 def list(self, filter, *args, timeout=None): 5391 ''' 5392 List gets a list of peering group links. 5393 ''' 5394 deadline = None if timeout is None else time.time() + timeout 5395 req = PeeringGroupPeerListRequest() 5396 req.meta.CopyFrom(ListRequestMetadata()) 5397 if self.parent.page_limit > 0: 5398 req.meta.limit = self.parent.page_limit 5399 if self.parent.snapshot_datetime is not None: 5400 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5401 5402 req.filter = plumbing.quote_filter_args(filter, *args) 5403 5404 def generator(svc, req): 5405 tries = 0 5406 while True: 5407 t = None if deadline is None else deadline - time.time() 5408 try: 5409 plumbing_response = svc.stub.List( 5410 req, 5411 metadata=svc.parent.get_metadata( 5412 'PeeringGroupPeers.List', req), 5413 timeout=t) 5414 except Exception as e: 5415 if self.parent.shouldRetry(tries, e, deadline): 5416 tries += 1 5417 time.sleep( 5418 self.parent.exponentialBackoff(tries, deadline)) 5419 continue 5420 raise plumbing.convert_error_to_porcelain(e) from e 5421 tries = 0 5422 for plumbing_item in plumbing_response.peering_group_peers: 5423 yield plumbing.convert_peering_group_peer_to_porcelain( 5424 plumbing_item) 5425 if plumbing_response.meta.next_cursor == '': 5426 break 5427 req.meta.cursor = plumbing_response.meta.next_cursor 5428 5429 return generator(self, req)
List gets a list of peering group links.
class
PeeringGroupResources:
5432class PeeringGroupResources: 5433 ''' 5434 PeeringGroupResources provides the building blocks necessary to obtain attach a resource to a peering group. 5435 See `strongdm.models.PeeringGroupResource`. 5436 ''' 5437 def __init__(self, channel, client): 5438 self.parent = client 5439 self.stub = PeeringGroupResourcesStub(channel) 5440 5441 def create(self, peering_group_resource, timeout=None): 5442 ''' 5443 Create attaches a Resource to a PeeringGroup 5444 ''' 5445 deadline = None if timeout is None else time.time() + timeout 5446 req = PeeringGroupResourceCreateRequest() 5447 5448 if peering_group_resource is not None: 5449 req.peering_group_resource.CopyFrom( 5450 plumbing.convert_peering_group_resource_to_plumbing( 5451 peering_group_resource)) 5452 tries = 0 5453 plumbing_response = None 5454 while True: 5455 t = None if deadline is None else deadline - time.time() 5456 try: 5457 plumbing_response = self.stub.Create( 5458 req, 5459 metadata=self.parent.get_metadata( 5460 'PeeringGroupResources.Create', req), 5461 timeout=t) 5462 except Exception as e: 5463 if self.parent.shouldRetry(tries, e, deadline): 5464 tries += 1 5465 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5466 continue 5467 raise plumbing.convert_error_to_porcelain(e) from e 5468 break 5469 5470 resp = models.PeeringGroupResourceCreateResponse() 5471 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5472 plumbing_response.meta) 5473 resp.peering_group_resource = plumbing.convert_peering_group_resource_to_porcelain( 5474 plumbing_response.peering_group_resource) 5475 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5476 plumbing_response.rate_limit) 5477 return resp 5478 5479 def delete(self, id, timeout=None): 5480 ''' 5481 Delete detaches a Resource to a PeeringGroup 5482 ''' 5483 deadline = None if timeout is None else time.time() + timeout 5484 req = PeeringGroupResourceDeleteRequest() 5485 5486 req.id = (id) 5487 tries = 0 5488 plumbing_response = None 5489 while True: 5490 t = None if deadline is None else deadline - time.time() 5491 try: 5492 plumbing_response = self.stub.Delete( 5493 req, 5494 metadata=self.parent.get_metadata( 5495 'PeeringGroupResources.Delete', req), 5496 timeout=t) 5497 except Exception as e: 5498 if self.parent.shouldRetry(tries, e, deadline): 5499 tries += 1 5500 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5501 continue 5502 raise plumbing.convert_error_to_porcelain(e) from e 5503 break 5504 5505 resp = models.PeeringGroupResourceDeleteResponse() 5506 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 5507 plumbing_response.meta) 5508 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5509 plumbing_response.rate_limit) 5510 return resp 5511 5512 def get(self, id, timeout=None): 5513 ''' 5514 Get reads the information of one peering group to resource attachment. 5515 ''' 5516 deadline = None if timeout is None else time.time() + timeout 5517 req = PeeringGroupResourceGetRequest() 5518 if self.parent.snapshot_datetime is not None: 5519 req.meta.CopyFrom(GetRequestMetadata()) 5520 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5521 5522 req.id = (id) 5523 tries = 0 5524 plumbing_response = None 5525 while True: 5526 t = None if deadline is None else deadline - time.time() 5527 try: 5528 plumbing_response = self.stub.Get( 5529 req, 5530 metadata=self.parent.get_metadata( 5531 'PeeringGroupResources.Get', req), 5532 timeout=t) 5533 except Exception as e: 5534 if self.parent.shouldRetry(tries, e, deadline): 5535 tries += 1 5536 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5537 continue 5538 raise plumbing.convert_error_to_porcelain(e) from e 5539 break 5540 5541 resp = models.PeeringGroupResourceGetResponse() 5542 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5543 plumbing_response.meta) 5544 resp.peering_group_resource = plumbing.convert_peering_group_resource_to_porcelain( 5545 plumbing_response.peering_group_resource) 5546 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5547 plumbing_response.rate_limit) 5548 return resp 5549 5550 def list(self, filter, *args, timeout=None): 5551 ''' 5552 List gets a list of peering group resource attachments. 5553 ''' 5554 deadline = None if timeout is None else time.time() + timeout 5555 req = PeeringGroupResourceListRequest() 5556 req.meta.CopyFrom(ListRequestMetadata()) 5557 if self.parent.page_limit > 0: 5558 req.meta.limit = self.parent.page_limit 5559 if self.parent.snapshot_datetime is not None: 5560 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5561 5562 req.filter = plumbing.quote_filter_args(filter, *args) 5563 5564 def generator(svc, req): 5565 tries = 0 5566 while True: 5567 t = None if deadline is None else deadline - time.time() 5568 try: 5569 plumbing_response = svc.stub.List( 5570 req, 5571 metadata=svc.parent.get_metadata( 5572 'PeeringGroupResources.List', req), 5573 timeout=t) 5574 except Exception as e: 5575 if self.parent.shouldRetry(tries, e, deadline): 5576 tries += 1 5577 time.sleep( 5578 self.parent.exponentialBackoff(tries, deadline)) 5579 continue 5580 raise plumbing.convert_error_to_porcelain(e) from e 5581 tries = 0 5582 for plumbing_item in plumbing_response.peering_group_resources: 5583 yield plumbing.convert_peering_group_resource_to_porcelain( 5584 plumbing_item) 5585 if plumbing_response.meta.next_cursor == '': 5586 break 5587 req.meta.cursor = plumbing_response.meta.next_cursor 5588 5589 return generator(self, req)
PeeringGroupResources provides the building blocks necessary to obtain attach a resource to a peering group.
See strongdm.models.PeeringGroupResource.
def
create(self, peering_group_resource, timeout=None)
5441 def create(self, peering_group_resource, timeout=None): 5442 ''' 5443 Create attaches a Resource to a PeeringGroup 5444 ''' 5445 deadline = None if timeout is None else time.time() + timeout 5446 req = PeeringGroupResourceCreateRequest() 5447 5448 if peering_group_resource is not None: 5449 req.peering_group_resource.CopyFrom( 5450 plumbing.convert_peering_group_resource_to_plumbing( 5451 peering_group_resource)) 5452 tries = 0 5453 plumbing_response = None 5454 while True: 5455 t = None if deadline is None else deadline - time.time() 5456 try: 5457 plumbing_response = self.stub.Create( 5458 req, 5459 metadata=self.parent.get_metadata( 5460 'PeeringGroupResources.Create', req), 5461 timeout=t) 5462 except Exception as e: 5463 if self.parent.shouldRetry(tries, e, deadline): 5464 tries += 1 5465 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5466 continue 5467 raise plumbing.convert_error_to_porcelain(e) from e 5468 break 5469 5470 resp = models.PeeringGroupResourceCreateResponse() 5471 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5472 plumbing_response.meta) 5473 resp.peering_group_resource = plumbing.convert_peering_group_resource_to_porcelain( 5474 plumbing_response.peering_group_resource) 5475 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5476 plumbing_response.rate_limit) 5477 return resp
Create attaches a Resource to a PeeringGroup
def
delete(self, id, timeout=None)
5479 def delete(self, id, timeout=None): 5480 ''' 5481 Delete detaches a Resource to a PeeringGroup 5482 ''' 5483 deadline = None if timeout is None else time.time() + timeout 5484 req = PeeringGroupResourceDeleteRequest() 5485 5486 req.id = (id) 5487 tries = 0 5488 plumbing_response = None 5489 while True: 5490 t = None if deadline is None else deadline - time.time() 5491 try: 5492 plumbing_response = self.stub.Delete( 5493 req, 5494 metadata=self.parent.get_metadata( 5495 'PeeringGroupResources.Delete', req), 5496 timeout=t) 5497 except Exception as e: 5498 if self.parent.shouldRetry(tries, e, deadline): 5499 tries += 1 5500 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5501 continue 5502 raise plumbing.convert_error_to_porcelain(e) from e 5503 break 5504 5505 resp = models.PeeringGroupResourceDeleteResponse() 5506 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 5507 plumbing_response.meta) 5508 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5509 plumbing_response.rate_limit) 5510 return resp
Delete detaches a Resource to a PeeringGroup
def
get(self, id, timeout=None)
5512 def get(self, id, timeout=None): 5513 ''' 5514 Get reads the information of one peering group to resource attachment. 5515 ''' 5516 deadline = None if timeout is None else time.time() + timeout 5517 req = PeeringGroupResourceGetRequest() 5518 if self.parent.snapshot_datetime is not None: 5519 req.meta.CopyFrom(GetRequestMetadata()) 5520 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5521 5522 req.id = (id) 5523 tries = 0 5524 plumbing_response = None 5525 while True: 5526 t = None if deadline is None else deadline - time.time() 5527 try: 5528 plumbing_response = self.stub.Get( 5529 req, 5530 metadata=self.parent.get_metadata( 5531 'PeeringGroupResources.Get', req), 5532 timeout=t) 5533 except Exception as e: 5534 if self.parent.shouldRetry(tries, e, deadline): 5535 tries += 1 5536 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5537 continue 5538 raise plumbing.convert_error_to_porcelain(e) from e 5539 break 5540 5541 resp = models.PeeringGroupResourceGetResponse() 5542 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5543 plumbing_response.meta) 5544 resp.peering_group_resource = plumbing.convert_peering_group_resource_to_porcelain( 5545 plumbing_response.peering_group_resource) 5546 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5547 plumbing_response.rate_limit) 5548 return resp
Get reads the information of one peering group to resource attachment.
def
list(self, filter, *args, timeout=None)
5550 def list(self, filter, *args, timeout=None): 5551 ''' 5552 List gets a list of peering group resource attachments. 5553 ''' 5554 deadline = None if timeout is None else time.time() + timeout 5555 req = PeeringGroupResourceListRequest() 5556 req.meta.CopyFrom(ListRequestMetadata()) 5557 if self.parent.page_limit > 0: 5558 req.meta.limit = self.parent.page_limit 5559 if self.parent.snapshot_datetime is not None: 5560 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5561 5562 req.filter = plumbing.quote_filter_args(filter, *args) 5563 5564 def generator(svc, req): 5565 tries = 0 5566 while True: 5567 t = None if deadline is None else deadline - time.time() 5568 try: 5569 plumbing_response = svc.stub.List( 5570 req, 5571 metadata=svc.parent.get_metadata( 5572 'PeeringGroupResources.List', req), 5573 timeout=t) 5574 except Exception as e: 5575 if self.parent.shouldRetry(tries, e, deadline): 5576 tries += 1 5577 time.sleep( 5578 self.parent.exponentialBackoff(tries, deadline)) 5579 continue 5580 raise plumbing.convert_error_to_porcelain(e) from e 5581 tries = 0 5582 for plumbing_item in plumbing_response.peering_group_resources: 5583 yield plumbing.convert_peering_group_resource_to_porcelain( 5584 plumbing_item) 5585 if plumbing_response.meta.next_cursor == '': 5586 break 5587 req.meta.cursor = plumbing_response.meta.next_cursor 5588 5589 return generator(self, req)
List gets a list of peering group resource attachments.
class
PeeringGroups:
5592class PeeringGroups: 5593 ''' 5594 PeeringGroups provides the building blocks necessary to obtain explicit network topology and routing. 5595 See `strongdm.models.PeeringGroup`. 5596 ''' 5597 def __init__(self, channel, client): 5598 self.parent = client 5599 self.stub = PeeringGroupsStub(channel) 5600 5601 def create(self, peering_group, timeout=None): 5602 ''' 5603 Create registers a new PeeringGroup. 5604 ''' 5605 deadline = None if timeout is None else time.time() + timeout 5606 req = PeeringGroupCreateRequest() 5607 5608 if peering_group is not None: 5609 req.peering_group.CopyFrom( 5610 plumbing.convert_peering_group_to_plumbing(peering_group)) 5611 tries = 0 5612 plumbing_response = None 5613 while True: 5614 t = None if deadline is None else deadline - time.time() 5615 try: 5616 plumbing_response = self.stub.Create( 5617 req, 5618 metadata=self.parent.get_metadata('PeeringGroups.Create', 5619 req), 5620 timeout=t) 5621 except Exception as e: 5622 if self.parent.shouldRetry(tries, e, deadline): 5623 tries += 1 5624 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5625 continue 5626 raise plumbing.convert_error_to_porcelain(e) from e 5627 break 5628 5629 resp = models.PeeringGroupCreateResponse() 5630 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5631 plumbing_response.meta) 5632 resp.peering_group = plumbing.convert_peering_group_to_porcelain( 5633 plumbing_response.peering_group) 5634 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5635 plumbing_response.rate_limit) 5636 return resp 5637 5638 def delete(self, id, timeout=None): 5639 ''' 5640 Delete removes a PeeringGroup by ID. 5641 ''' 5642 deadline = None if timeout is None else time.time() + timeout 5643 req = PeeringGroupDeleteRequest() 5644 5645 req.id = (id) 5646 tries = 0 5647 plumbing_response = None 5648 while True: 5649 t = None if deadline is None else deadline - time.time() 5650 try: 5651 plumbing_response = self.stub.Delete( 5652 req, 5653 metadata=self.parent.get_metadata('PeeringGroups.Delete', 5654 req), 5655 timeout=t) 5656 except Exception as e: 5657 if self.parent.shouldRetry(tries, e, deadline): 5658 tries += 1 5659 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5660 continue 5661 raise plumbing.convert_error_to_porcelain(e) from e 5662 break 5663 5664 resp = models.PeeringGroupDeleteResponse() 5665 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 5666 plumbing_response.meta) 5667 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5668 plumbing_response.rate_limit) 5669 return resp 5670 5671 def get(self, id, timeout=None): 5672 ''' 5673 Get reads one PeeringGroup by ID. It will load all its dependencies. 5674 ''' 5675 deadline = None if timeout is None else time.time() + timeout 5676 req = PeeringGroupGetRequest() 5677 if self.parent.snapshot_datetime is not None: 5678 req.meta.CopyFrom(GetRequestMetadata()) 5679 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5680 5681 req.id = (id) 5682 tries = 0 5683 plumbing_response = None 5684 while True: 5685 t = None if deadline is None else deadline - time.time() 5686 try: 5687 plumbing_response = self.stub.Get( 5688 req, 5689 metadata=self.parent.get_metadata('PeeringGroups.Get', 5690 req), 5691 timeout=t) 5692 except Exception as e: 5693 if self.parent.shouldRetry(tries, e, deadline): 5694 tries += 1 5695 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5696 continue 5697 raise plumbing.convert_error_to_porcelain(e) from e 5698 break 5699 5700 resp = models.PeeringGroupGetResponse() 5701 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5702 plumbing_response.meta) 5703 resp.peering_group = plumbing.convert_peering_group_to_porcelain( 5704 plumbing_response.peering_group) 5705 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5706 plumbing_response.rate_limit) 5707 return resp 5708 5709 def list(self, filter, *args, timeout=None): 5710 ''' 5711 List gets a list of Peering Groups. 5712 ''' 5713 deadline = None if timeout is None else time.time() + timeout 5714 req = PeeringGroupListRequest() 5715 req.meta.CopyFrom(ListRequestMetadata()) 5716 if self.parent.page_limit > 0: 5717 req.meta.limit = self.parent.page_limit 5718 if self.parent.snapshot_datetime is not None: 5719 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5720 5721 req.filter = plumbing.quote_filter_args(filter, *args) 5722 5723 def generator(svc, req): 5724 tries = 0 5725 while True: 5726 t = None if deadline is None else deadline - time.time() 5727 try: 5728 plumbing_response = svc.stub.List( 5729 req, 5730 metadata=svc.parent.get_metadata( 5731 'PeeringGroups.List', req), 5732 timeout=t) 5733 except Exception as e: 5734 if self.parent.shouldRetry(tries, e, deadline): 5735 tries += 1 5736 time.sleep( 5737 self.parent.exponentialBackoff(tries, deadline)) 5738 continue 5739 raise plumbing.convert_error_to_porcelain(e) from e 5740 tries = 0 5741 for plumbing_item in plumbing_response.peering_groups: 5742 yield plumbing.convert_peering_group_to_porcelain( 5743 plumbing_item) 5744 if plumbing_response.meta.next_cursor == '': 5745 break 5746 req.meta.cursor = plumbing_response.meta.next_cursor 5747 5748 return generator(self, req)
PeeringGroups provides the building blocks necessary to obtain explicit network topology and routing.
See strongdm.models.PeeringGroup.
def
create(self, peering_group, timeout=None)
5601 def create(self, peering_group, timeout=None): 5602 ''' 5603 Create registers a new PeeringGroup. 5604 ''' 5605 deadline = None if timeout is None else time.time() + timeout 5606 req = PeeringGroupCreateRequest() 5607 5608 if peering_group is not None: 5609 req.peering_group.CopyFrom( 5610 plumbing.convert_peering_group_to_plumbing(peering_group)) 5611 tries = 0 5612 plumbing_response = None 5613 while True: 5614 t = None if deadline is None else deadline - time.time() 5615 try: 5616 plumbing_response = self.stub.Create( 5617 req, 5618 metadata=self.parent.get_metadata('PeeringGroups.Create', 5619 req), 5620 timeout=t) 5621 except Exception as e: 5622 if self.parent.shouldRetry(tries, e, deadline): 5623 tries += 1 5624 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5625 continue 5626 raise plumbing.convert_error_to_porcelain(e) from e 5627 break 5628 5629 resp = models.PeeringGroupCreateResponse() 5630 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5631 plumbing_response.meta) 5632 resp.peering_group = plumbing.convert_peering_group_to_porcelain( 5633 plumbing_response.peering_group) 5634 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5635 plumbing_response.rate_limit) 5636 return resp
Create registers a new PeeringGroup.
def
delete(self, id, timeout=None)
5638 def delete(self, id, timeout=None): 5639 ''' 5640 Delete removes a PeeringGroup by ID. 5641 ''' 5642 deadline = None if timeout is None else time.time() + timeout 5643 req = PeeringGroupDeleteRequest() 5644 5645 req.id = (id) 5646 tries = 0 5647 plumbing_response = None 5648 while True: 5649 t = None if deadline is None else deadline - time.time() 5650 try: 5651 plumbing_response = self.stub.Delete( 5652 req, 5653 metadata=self.parent.get_metadata('PeeringGroups.Delete', 5654 req), 5655 timeout=t) 5656 except Exception as e: 5657 if self.parent.shouldRetry(tries, e, deadline): 5658 tries += 1 5659 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5660 continue 5661 raise plumbing.convert_error_to_porcelain(e) from e 5662 break 5663 5664 resp = models.PeeringGroupDeleteResponse() 5665 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 5666 plumbing_response.meta) 5667 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5668 plumbing_response.rate_limit) 5669 return resp
Delete removes a PeeringGroup by ID.
def
get(self, id, timeout=None)
5671 def get(self, id, timeout=None): 5672 ''' 5673 Get reads one PeeringGroup by ID. It will load all its dependencies. 5674 ''' 5675 deadline = None if timeout is None else time.time() + timeout 5676 req = PeeringGroupGetRequest() 5677 if self.parent.snapshot_datetime is not None: 5678 req.meta.CopyFrom(GetRequestMetadata()) 5679 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5680 5681 req.id = (id) 5682 tries = 0 5683 plumbing_response = None 5684 while True: 5685 t = None if deadline is None else deadline - time.time() 5686 try: 5687 plumbing_response = self.stub.Get( 5688 req, 5689 metadata=self.parent.get_metadata('PeeringGroups.Get', 5690 req), 5691 timeout=t) 5692 except Exception as e: 5693 if self.parent.shouldRetry(tries, e, deadline): 5694 tries += 1 5695 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5696 continue 5697 raise plumbing.convert_error_to_porcelain(e) from e 5698 break 5699 5700 resp = models.PeeringGroupGetResponse() 5701 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5702 plumbing_response.meta) 5703 resp.peering_group = plumbing.convert_peering_group_to_porcelain( 5704 plumbing_response.peering_group) 5705 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5706 plumbing_response.rate_limit) 5707 return resp
Get reads one PeeringGroup by ID. It will load all its dependencies.
def
list(self, filter, *args, timeout=None)
5709 def list(self, filter, *args, timeout=None): 5710 ''' 5711 List gets a list of Peering Groups. 5712 ''' 5713 deadline = None if timeout is None else time.time() + timeout 5714 req = PeeringGroupListRequest() 5715 req.meta.CopyFrom(ListRequestMetadata()) 5716 if self.parent.page_limit > 0: 5717 req.meta.limit = self.parent.page_limit 5718 if self.parent.snapshot_datetime is not None: 5719 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5720 5721 req.filter = plumbing.quote_filter_args(filter, *args) 5722 5723 def generator(svc, req): 5724 tries = 0 5725 while True: 5726 t = None if deadline is None else deadline - time.time() 5727 try: 5728 plumbing_response = svc.stub.List( 5729 req, 5730 metadata=svc.parent.get_metadata( 5731 'PeeringGroups.List', req), 5732 timeout=t) 5733 except Exception as e: 5734 if self.parent.shouldRetry(tries, e, deadline): 5735 tries += 1 5736 time.sleep( 5737 self.parent.exponentialBackoff(tries, deadline)) 5738 continue 5739 raise plumbing.convert_error_to_porcelain(e) from e 5740 tries = 0 5741 for plumbing_item in plumbing_response.peering_groups: 5742 yield plumbing.convert_peering_group_to_porcelain( 5743 plumbing_item) 5744 if plumbing_response.meta.next_cursor == '': 5745 break 5746 req.meta.cursor = plumbing_response.meta.next_cursor 5747 5748 return generator(self, req)
List gets a list of Peering Groups.
class
Policies:
5751class Policies: 5752 ''' 5753 Policies are the collection of one or more statements that enforce fine-grained access 5754 control for the users of an organization. 5755 See `strongdm.models.Policy`. 5756 ''' 5757 def __init__(self, channel, client): 5758 self.parent = client 5759 self.stub = PoliciesStub(channel) 5760 5761 def create(self, policy, timeout=None): 5762 ''' 5763 Create creates a new Policy. 5764 ''' 5765 deadline = None if timeout is None else time.time() + timeout 5766 req = PolicyCreateRequest() 5767 5768 if policy is not None: 5769 req.policy.CopyFrom(plumbing.convert_policy_to_plumbing(policy)) 5770 tries = 0 5771 plumbing_response = None 5772 while True: 5773 t = None if deadline is None else deadline - time.time() 5774 try: 5775 plumbing_response = self.stub.Create( 5776 req, 5777 metadata=self.parent.get_metadata('Policies.Create', req), 5778 timeout=t) 5779 except Exception as e: 5780 if self.parent.shouldRetry(tries, e, deadline): 5781 tries += 1 5782 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5783 continue 5784 raise plumbing.convert_error_to_porcelain(e) from e 5785 break 5786 5787 resp = models.PolicyCreateResponse() 5788 resp.policy = plumbing.convert_policy_to_porcelain( 5789 plumbing_response.policy) 5790 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5791 plumbing_response.rate_limit) 5792 return resp 5793 5794 def delete(self, id, timeout=None): 5795 ''' 5796 Delete removes a Policy by ID. 5797 ''' 5798 deadline = None if timeout is None else time.time() + timeout 5799 req = PolicyDeleteRequest() 5800 5801 req.id = (id) 5802 tries = 0 5803 plumbing_response = None 5804 while True: 5805 t = None if deadline is None else deadline - time.time() 5806 try: 5807 plumbing_response = self.stub.Delete( 5808 req, 5809 metadata=self.parent.get_metadata('Policies.Delete', req), 5810 timeout=t) 5811 except Exception as e: 5812 if self.parent.shouldRetry(tries, e, deadline): 5813 tries += 1 5814 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5815 continue 5816 raise plumbing.convert_error_to_porcelain(e) from e 5817 break 5818 5819 resp = models.PolicyDeleteResponse() 5820 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5821 plumbing_response.rate_limit) 5822 return resp 5823 5824 def update(self, policy, timeout=None): 5825 ''' 5826 Update replaces all the fields of a Policy by ID. 5827 ''' 5828 deadline = None if timeout is None else time.time() + timeout 5829 req = PolicyUpdateRequest() 5830 5831 if policy is not None: 5832 req.policy.CopyFrom(plumbing.convert_policy_to_plumbing(policy)) 5833 tries = 0 5834 plumbing_response = None 5835 while True: 5836 t = None if deadline is None else deadline - time.time() 5837 try: 5838 plumbing_response = self.stub.Update( 5839 req, 5840 metadata=self.parent.get_metadata('Policies.Update', req), 5841 timeout=t) 5842 except Exception as e: 5843 if self.parent.shouldRetry(tries, e, deadline): 5844 tries += 1 5845 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5846 continue 5847 raise plumbing.convert_error_to_porcelain(e) from e 5848 break 5849 5850 resp = models.PolicyUpdateResponse() 5851 resp.policy = plumbing.convert_policy_to_porcelain( 5852 plumbing_response.policy) 5853 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5854 plumbing_response.rate_limit) 5855 return resp 5856 5857 def get(self, id, timeout=None): 5858 ''' 5859 Get reads one Policy by ID. 5860 ''' 5861 deadline = None if timeout is None else time.time() + timeout 5862 req = PolicyGetRequest() 5863 if self.parent.snapshot_datetime is not None: 5864 req.meta.CopyFrom(GetRequestMetadata()) 5865 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5866 5867 req.id = (id) 5868 tries = 0 5869 plumbing_response = None 5870 while True: 5871 t = None if deadline is None else deadline - time.time() 5872 try: 5873 plumbing_response = self.stub.Get( 5874 req, 5875 metadata=self.parent.get_metadata('Policies.Get', req), 5876 timeout=t) 5877 except Exception as e: 5878 if self.parent.shouldRetry(tries, e, deadline): 5879 tries += 1 5880 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5881 continue 5882 raise plumbing.convert_error_to_porcelain(e) from e 5883 break 5884 5885 resp = models.PolicyGetResponse() 5886 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5887 plumbing_response.meta) 5888 resp.policy = plumbing.convert_policy_to_porcelain( 5889 plumbing_response.policy) 5890 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5891 plumbing_response.rate_limit) 5892 return resp 5893 5894 def list(self, filter, *args, timeout=None): 5895 ''' 5896 List gets a list of Policy matching a given set of criteria 5897 ''' 5898 deadline = None if timeout is None else time.time() + timeout 5899 req = PolicyListRequest() 5900 req.meta.CopyFrom(ListRequestMetadata()) 5901 if self.parent.page_limit > 0: 5902 req.meta.limit = self.parent.page_limit 5903 if self.parent.snapshot_datetime is not None: 5904 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5905 5906 req.filter = plumbing.quote_filter_args(filter, *args) 5907 5908 def generator(svc, req): 5909 tries = 0 5910 while True: 5911 t = None if deadline is None else deadline - time.time() 5912 try: 5913 plumbing_response = svc.stub.List( 5914 req, 5915 metadata=svc.parent.get_metadata('Policies.List', req), 5916 timeout=t) 5917 except Exception as e: 5918 if self.parent.shouldRetry(tries, e, deadline): 5919 tries += 1 5920 time.sleep( 5921 self.parent.exponentialBackoff(tries, deadline)) 5922 continue 5923 raise plumbing.convert_error_to_porcelain(e) from e 5924 tries = 0 5925 for plumbing_item in plumbing_response.policies: 5926 yield plumbing.convert_policy_to_porcelain(plumbing_item) 5927 if plumbing_response.meta.next_cursor == '': 5928 break 5929 req.meta.cursor = plumbing_response.meta.next_cursor 5930 5931 return generator(self, req)
Policies are the collection of one or more statements that enforce fine-grained access
control for the users of an organization.
See strongdm.models.Policy.
def
create(self, policy, timeout=None)
5761 def create(self, policy, timeout=None): 5762 ''' 5763 Create creates a new Policy. 5764 ''' 5765 deadline = None if timeout is None else time.time() + timeout 5766 req = PolicyCreateRequest() 5767 5768 if policy is not None: 5769 req.policy.CopyFrom(plumbing.convert_policy_to_plumbing(policy)) 5770 tries = 0 5771 plumbing_response = None 5772 while True: 5773 t = None if deadline is None else deadline - time.time() 5774 try: 5775 plumbing_response = self.stub.Create( 5776 req, 5777 metadata=self.parent.get_metadata('Policies.Create', req), 5778 timeout=t) 5779 except Exception as e: 5780 if self.parent.shouldRetry(tries, e, deadline): 5781 tries += 1 5782 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5783 continue 5784 raise plumbing.convert_error_to_porcelain(e) from e 5785 break 5786 5787 resp = models.PolicyCreateResponse() 5788 resp.policy = plumbing.convert_policy_to_porcelain( 5789 plumbing_response.policy) 5790 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5791 plumbing_response.rate_limit) 5792 return resp
Create creates a new Policy.
def
delete(self, id, timeout=None)
5794 def delete(self, id, timeout=None): 5795 ''' 5796 Delete removes a Policy by ID. 5797 ''' 5798 deadline = None if timeout is None else time.time() + timeout 5799 req = PolicyDeleteRequest() 5800 5801 req.id = (id) 5802 tries = 0 5803 plumbing_response = None 5804 while True: 5805 t = None if deadline is None else deadline - time.time() 5806 try: 5807 plumbing_response = self.stub.Delete( 5808 req, 5809 metadata=self.parent.get_metadata('Policies.Delete', req), 5810 timeout=t) 5811 except Exception as e: 5812 if self.parent.shouldRetry(tries, e, deadline): 5813 tries += 1 5814 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5815 continue 5816 raise plumbing.convert_error_to_porcelain(e) from e 5817 break 5818 5819 resp = models.PolicyDeleteResponse() 5820 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5821 plumbing_response.rate_limit) 5822 return resp
Delete removes a Policy by ID.
def
update(self, policy, timeout=None)
5824 def update(self, policy, timeout=None): 5825 ''' 5826 Update replaces all the fields of a Policy by ID. 5827 ''' 5828 deadline = None if timeout is None else time.time() + timeout 5829 req = PolicyUpdateRequest() 5830 5831 if policy is not None: 5832 req.policy.CopyFrom(plumbing.convert_policy_to_plumbing(policy)) 5833 tries = 0 5834 plumbing_response = None 5835 while True: 5836 t = None if deadline is None else deadline - time.time() 5837 try: 5838 plumbing_response = self.stub.Update( 5839 req, 5840 metadata=self.parent.get_metadata('Policies.Update', req), 5841 timeout=t) 5842 except Exception as e: 5843 if self.parent.shouldRetry(tries, e, deadline): 5844 tries += 1 5845 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5846 continue 5847 raise plumbing.convert_error_to_porcelain(e) from e 5848 break 5849 5850 resp = models.PolicyUpdateResponse() 5851 resp.policy = plumbing.convert_policy_to_porcelain( 5852 plumbing_response.policy) 5853 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5854 plumbing_response.rate_limit) 5855 return resp
Update replaces all the fields of a Policy by ID.
def
get(self, id, timeout=None)
5857 def get(self, id, timeout=None): 5858 ''' 5859 Get reads one Policy by ID. 5860 ''' 5861 deadline = None if timeout is None else time.time() + timeout 5862 req = PolicyGetRequest() 5863 if self.parent.snapshot_datetime is not None: 5864 req.meta.CopyFrom(GetRequestMetadata()) 5865 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5866 5867 req.id = (id) 5868 tries = 0 5869 plumbing_response = None 5870 while True: 5871 t = None if deadline is None else deadline - time.time() 5872 try: 5873 plumbing_response = self.stub.Get( 5874 req, 5875 metadata=self.parent.get_metadata('Policies.Get', req), 5876 timeout=t) 5877 except Exception as e: 5878 if self.parent.shouldRetry(tries, e, deadline): 5879 tries += 1 5880 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5881 continue 5882 raise plumbing.convert_error_to_porcelain(e) from e 5883 break 5884 5885 resp = models.PolicyGetResponse() 5886 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5887 plumbing_response.meta) 5888 resp.policy = plumbing.convert_policy_to_porcelain( 5889 plumbing_response.policy) 5890 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5891 plumbing_response.rate_limit) 5892 return resp
Get reads one Policy by ID.
def
list(self, filter, *args, timeout=None)
5894 def list(self, filter, *args, timeout=None): 5895 ''' 5896 List gets a list of Policy matching a given set of criteria 5897 ''' 5898 deadline = None if timeout is None else time.time() + timeout 5899 req = PolicyListRequest() 5900 req.meta.CopyFrom(ListRequestMetadata()) 5901 if self.parent.page_limit > 0: 5902 req.meta.limit = self.parent.page_limit 5903 if self.parent.snapshot_datetime is not None: 5904 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5905 5906 req.filter = plumbing.quote_filter_args(filter, *args) 5907 5908 def generator(svc, req): 5909 tries = 0 5910 while True: 5911 t = None if deadline is None else deadline - time.time() 5912 try: 5913 plumbing_response = svc.stub.List( 5914 req, 5915 metadata=svc.parent.get_metadata('Policies.List', req), 5916 timeout=t) 5917 except Exception as e: 5918 if self.parent.shouldRetry(tries, e, deadline): 5919 tries += 1 5920 time.sleep( 5921 self.parent.exponentialBackoff(tries, deadline)) 5922 continue 5923 raise plumbing.convert_error_to_porcelain(e) from e 5924 tries = 0 5925 for plumbing_item in plumbing_response.policies: 5926 yield plumbing.convert_policy_to_porcelain(plumbing_item) 5927 if plumbing_response.meta.next_cursor == '': 5928 break 5929 req.meta.cursor = plumbing_response.meta.next_cursor 5930 5931 return generator(self, req)
List gets a list of Policy matching a given set of criteria
class
SnapshotPolicies:
5934class SnapshotPolicies: 5935 ''' 5936 SnapshotPolicies exposes the read only methods of the Policies 5937 service for historical queries. 5938 ''' 5939 def __init__(self, policies): 5940 self.policies = policies 5941 5942 def get(self, id, timeout=None): 5943 ''' 5944 Get reads one Policy by ID. 5945 ''' 5946 return self.policies.get(id, timeout=timeout) 5947 5948 def list(self, filter, *args, timeout=None): 5949 ''' 5950 List gets a list of Policy matching a given set of criteria 5951 ''' 5952 return self.policies.list(filter, *args, timeout=timeout)
SnapshotPolicies exposes the read only methods of the Policies service for historical queries.
class
PoliciesHistory:
5955class PoliciesHistory: 5956 ''' 5957 PoliciesHistory records all changes to the state of a Policy. 5958 See `strongdm.models.PolicyHistory`. 5959 ''' 5960 def __init__(self, channel, client): 5961 self.parent = client 5962 self.stub = PoliciesHistoryStub(channel) 5963 5964 def list(self, filter, *args, timeout=None): 5965 ''' 5966 List gets a list of PolicyHistory records matching a given set of criteria. 5967 ''' 5968 deadline = None if timeout is None else time.time() + timeout 5969 req = PoliciesHistoryListRequest() 5970 req.meta.CopyFrom(ListRequestMetadata()) 5971 if self.parent.page_limit > 0: 5972 req.meta.limit = self.parent.page_limit 5973 if self.parent.snapshot_datetime is not None: 5974 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5975 5976 req.filter = plumbing.quote_filter_args(filter, *args) 5977 5978 def generator(svc, req): 5979 tries = 0 5980 while True: 5981 t = None if deadline is None else deadline - time.time() 5982 try: 5983 plumbing_response = svc.stub.List( 5984 req, 5985 metadata=svc.parent.get_metadata( 5986 'PoliciesHistory.List', req), 5987 timeout=t) 5988 except Exception as e: 5989 if self.parent.shouldRetry(tries, e, deadline): 5990 tries += 1 5991 time.sleep( 5992 self.parent.exponentialBackoff(tries, deadline)) 5993 continue 5994 raise plumbing.convert_error_to_porcelain(e) from e 5995 tries = 0 5996 for plumbing_item in plumbing_response.history: 5997 yield plumbing.convert_policy_history_to_porcelain( 5998 plumbing_item) 5999 if plumbing_response.meta.next_cursor == '': 6000 break 6001 req.meta.cursor = plumbing_response.meta.next_cursor 6002 6003 return generator(self, req)
PoliciesHistory records all changes to the state of a Policy.
See strongdm.models.PolicyHistory.
def
list(self, filter, *args, timeout=None)
5964 def list(self, filter, *args, timeout=None): 5965 ''' 5966 List gets a list of PolicyHistory records matching a given set of criteria. 5967 ''' 5968 deadline = None if timeout is None else time.time() + timeout 5969 req = PoliciesHistoryListRequest() 5970 req.meta.CopyFrom(ListRequestMetadata()) 5971 if self.parent.page_limit > 0: 5972 req.meta.limit = self.parent.page_limit 5973 if self.parent.snapshot_datetime is not None: 5974 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5975 5976 req.filter = plumbing.quote_filter_args(filter, *args) 5977 5978 def generator(svc, req): 5979 tries = 0 5980 while True: 5981 t = None if deadline is None else deadline - time.time() 5982 try: 5983 plumbing_response = svc.stub.List( 5984 req, 5985 metadata=svc.parent.get_metadata( 5986 'PoliciesHistory.List', req), 5987 timeout=t) 5988 except Exception as e: 5989 if self.parent.shouldRetry(tries, e, deadline): 5990 tries += 1 5991 time.sleep( 5992 self.parent.exponentialBackoff(tries, deadline)) 5993 continue 5994 raise plumbing.convert_error_to_porcelain(e) from e 5995 tries = 0 5996 for plumbing_item in plumbing_response.history: 5997 yield plumbing.convert_policy_history_to_porcelain( 5998 plumbing_item) 5999 if plumbing_response.meta.next_cursor == '': 6000 break 6001 req.meta.cursor = plumbing_response.meta.next_cursor 6002 6003 return generator(self, req)
List gets a list of PolicyHistory records matching a given set of criteria.
class
ProxyClusterKeys:
6006class ProxyClusterKeys: 6007 ''' 6008 Proxy Cluster Keys are authentication keys for all proxies within a cluster. 6009 The proxies within a cluster share the same key. One cluster can have 6010 multiple keys in order to facilitate key rotation. 6011 See `strongdm.models.ProxyClusterKey`. 6012 ''' 6013 def __init__(self, channel, client): 6014 self.parent = client 6015 self.stub = ProxyClusterKeysStub(channel) 6016 6017 def create(self, proxy_cluster_key, timeout=None): 6018 ''' 6019 Create registers a new ProxyClusterKey. 6020 ''' 6021 deadline = None if timeout is None else time.time() + timeout 6022 req = ProxyClusterKeyCreateRequest() 6023 6024 if proxy_cluster_key is not None: 6025 req.proxy_cluster_key.CopyFrom( 6026 plumbing.convert_proxy_cluster_key_to_plumbing( 6027 proxy_cluster_key)) 6028 tries = 0 6029 plumbing_response = None 6030 while True: 6031 t = None if deadline is None else deadline - time.time() 6032 try: 6033 plumbing_response = self.stub.Create( 6034 req, 6035 metadata=self.parent.get_metadata( 6036 'ProxyClusterKeys.Create', req), 6037 timeout=t) 6038 except Exception as e: 6039 if self.parent.shouldRetry(tries, e, deadline): 6040 tries += 1 6041 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6042 continue 6043 raise plumbing.convert_error_to_porcelain(e) from e 6044 break 6045 6046 resp = models.ProxyClusterKeyCreateResponse() 6047 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 6048 plumbing_response.meta) 6049 resp.proxy_cluster_key = plumbing.convert_proxy_cluster_key_to_porcelain( 6050 plumbing_response.proxy_cluster_key) 6051 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6052 plumbing_response.rate_limit) 6053 resp.secret_key = (plumbing_response.secret_key) 6054 return resp 6055 6056 def get(self, id, timeout=None): 6057 ''' 6058 Get reads one ProxyClusterKey by ID. 6059 ''' 6060 deadline = None if timeout is None else time.time() + timeout 6061 req = ProxyClusterKeyGetRequest() 6062 if self.parent.snapshot_datetime is not None: 6063 req.meta.CopyFrom(GetRequestMetadata()) 6064 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6065 6066 req.id = (id) 6067 tries = 0 6068 plumbing_response = None 6069 while True: 6070 t = None if deadline is None else deadline - time.time() 6071 try: 6072 plumbing_response = self.stub.Get( 6073 req, 6074 metadata=self.parent.get_metadata('ProxyClusterKeys.Get', 6075 req), 6076 timeout=t) 6077 except Exception as e: 6078 if self.parent.shouldRetry(tries, e, deadline): 6079 tries += 1 6080 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6081 continue 6082 raise plumbing.convert_error_to_porcelain(e) from e 6083 break 6084 6085 resp = models.ProxyClusterKeyGetResponse() 6086 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 6087 plumbing_response.meta) 6088 resp.proxy_cluster_key = plumbing.convert_proxy_cluster_key_to_porcelain( 6089 plumbing_response.proxy_cluster_key) 6090 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6091 plumbing_response.rate_limit) 6092 return resp 6093 6094 def delete(self, id, timeout=None): 6095 ''' 6096 Delete removes a ProxyClusterKey by ID. 6097 ''' 6098 deadline = None if timeout is None else time.time() + timeout 6099 req = ProxyClusterKeyDeleteRequest() 6100 6101 req.id = (id) 6102 tries = 0 6103 plumbing_response = None 6104 while True: 6105 t = None if deadline is None else deadline - time.time() 6106 try: 6107 plumbing_response = self.stub.Delete( 6108 req, 6109 metadata=self.parent.get_metadata( 6110 'ProxyClusterKeys.Delete', req), 6111 timeout=t) 6112 except Exception as e: 6113 if self.parent.shouldRetry(tries, e, deadline): 6114 tries += 1 6115 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6116 continue 6117 raise plumbing.convert_error_to_porcelain(e) from e 6118 break 6119 6120 resp = models.ProxyClusterKeyDeleteResponse() 6121 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 6122 plumbing_response.meta) 6123 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6124 plumbing_response.rate_limit) 6125 return resp 6126 6127 def list(self, filter, *args, timeout=None): 6128 ''' 6129 List gets a list of ProxyClusterKeys matching a given set of criteria. 6130 ''' 6131 deadline = None if timeout is None else time.time() + timeout 6132 req = ProxyClusterKeyListRequest() 6133 req.meta.CopyFrom(ListRequestMetadata()) 6134 if self.parent.page_limit > 0: 6135 req.meta.limit = self.parent.page_limit 6136 if self.parent.snapshot_datetime is not None: 6137 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6138 6139 req.filter = plumbing.quote_filter_args(filter, *args) 6140 6141 def generator(svc, req): 6142 tries = 0 6143 while True: 6144 t = None if deadline is None else deadline - time.time() 6145 try: 6146 plumbing_response = svc.stub.List( 6147 req, 6148 metadata=svc.parent.get_metadata( 6149 'ProxyClusterKeys.List', req), 6150 timeout=t) 6151 except Exception as e: 6152 if self.parent.shouldRetry(tries, e, deadline): 6153 tries += 1 6154 time.sleep( 6155 self.parent.exponentialBackoff(tries, deadline)) 6156 continue 6157 raise plumbing.convert_error_to_porcelain(e) from e 6158 tries = 0 6159 for plumbing_item in plumbing_response.proxy_cluster_keys: 6160 yield plumbing.convert_proxy_cluster_key_to_porcelain( 6161 plumbing_item) 6162 if plumbing_response.meta.next_cursor == '': 6163 break 6164 req.meta.cursor = plumbing_response.meta.next_cursor 6165 6166 return generator(self, req)
Proxy Cluster Keys are authentication keys for all proxies within a cluster.
The proxies within a cluster share the same key. One cluster can have
multiple keys in order to facilitate key rotation.
See strongdm.models.ProxyClusterKey.
def
create(self, proxy_cluster_key, timeout=None)
6017 def create(self, proxy_cluster_key, timeout=None): 6018 ''' 6019 Create registers a new ProxyClusterKey. 6020 ''' 6021 deadline = None if timeout is None else time.time() + timeout 6022 req = ProxyClusterKeyCreateRequest() 6023 6024 if proxy_cluster_key is not None: 6025 req.proxy_cluster_key.CopyFrom( 6026 plumbing.convert_proxy_cluster_key_to_plumbing( 6027 proxy_cluster_key)) 6028 tries = 0 6029 plumbing_response = None 6030 while True: 6031 t = None if deadline is None else deadline - time.time() 6032 try: 6033 plumbing_response = self.stub.Create( 6034 req, 6035 metadata=self.parent.get_metadata( 6036 'ProxyClusterKeys.Create', req), 6037 timeout=t) 6038 except Exception as e: 6039 if self.parent.shouldRetry(tries, e, deadline): 6040 tries += 1 6041 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6042 continue 6043 raise plumbing.convert_error_to_porcelain(e) from e 6044 break 6045 6046 resp = models.ProxyClusterKeyCreateResponse() 6047 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 6048 plumbing_response.meta) 6049 resp.proxy_cluster_key = plumbing.convert_proxy_cluster_key_to_porcelain( 6050 plumbing_response.proxy_cluster_key) 6051 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6052 plumbing_response.rate_limit) 6053 resp.secret_key = (plumbing_response.secret_key) 6054 return resp
Create registers a new ProxyClusterKey.
def
get(self, id, timeout=None)
6056 def get(self, id, timeout=None): 6057 ''' 6058 Get reads one ProxyClusterKey by ID. 6059 ''' 6060 deadline = None if timeout is None else time.time() + timeout 6061 req = ProxyClusterKeyGetRequest() 6062 if self.parent.snapshot_datetime is not None: 6063 req.meta.CopyFrom(GetRequestMetadata()) 6064 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6065 6066 req.id = (id) 6067 tries = 0 6068 plumbing_response = None 6069 while True: 6070 t = None if deadline is None else deadline - time.time() 6071 try: 6072 plumbing_response = self.stub.Get( 6073 req, 6074 metadata=self.parent.get_metadata('ProxyClusterKeys.Get', 6075 req), 6076 timeout=t) 6077 except Exception as e: 6078 if self.parent.shouldRetry(tries, e, deadline): 6079 tries += 1 6080 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6081 continue 6082 raise plumbing.convert_error_to_porcelain(e) from e 6083 break 6084 6085 resp = models.ProxyClusterKeyGetResponse() 6086 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 6087 plumbing_response.meta) 6088 resp.proxy_cluster_key = plumbing.convert_proxy_cluster_key_to_porcelain( 6089 plumbing_response.proxy_cluster_key) 6090 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6091 plumbing_response.rate_limit) 6092 return resp
Get reads one ProxyClusterKey by ID.
def
delete(self, id, timeout=None)
6094 def delete(self, id, timeout=None): 6095 ''' 6096 Delete removes a ProxyClusterKey by ID. 6097 ''' 6098 deadline = None if timeout is None else time.time() + timeout 6099 req = ProxyClusterKeyDeleteRequest() 6100 6101 req.id = (id) 6102 tries = 0 6103 plumbing_response = None 6104 while True: 6105 t = None if deadline is None else deadline - time.time() 6106 try: 6107 plumbing_response = self.stub.Delete( 6108 req, 6109 metadata=self.parent.get_metadata( 6110 'ProxyClusterKeys.Delete', req), 6111 timeout=t) 6112 except Exception as e: 6113 if self.parent.shouldRetry(tries, e, deadline): 6114 tries += 1 6115 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6116 continue 6117 raise plumbing.convert_error_to_porcelain(e) from e 6118 break 6119 6120 resp = models.ProxyClusterKeyDeleteResponse() 6121 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 6122 plumbing_response.meta) 6123 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6124 plumbing_response.rate_limit) 6125 return resp
Delete removes a ProxyClusterKey by ID.
def
list(self, filter, *args, timeout=None)
6127 def list(self, filter, *args, timeout=None): 6128 ''' 6129 List gets a list of ProxyClusterKeys matching a given set of criteria. 6130 ''' 6131 deadline = None if timeout is None else time.time() + timeout 6132 req = ProxyClusterKeyListRequest() 6133 req.meta.CopyFrom(ListRequestMetadata()) 6134 if self.parent.page_limit > 0: 6135 req.meta.limit = self.parent.page_limit 6136 if self.parent.snapshot_datetime is not None: 6137 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6138 6139 req.filter = plumbing.quote_filter_args(filter, *args) 6140 6141 def generator(svc, req): 6142 tries = 0 6143 while True: 6144 t = None if deadline is None else deadline - time.time() 6145 try: 6146 plumbing_response = svc.stub.List( 6147 req, 6148 metadata=svc.parent.get_metadata( 6149 'ProxyClusterKeys.List', req), 6150 timeout=t) 6151 except Exception as e: 6152 if self.parent.shouldRetry(tries, e, deadline): 6153 tries += 1 6154 time.sleep( 6155 self.parent.exponentialBackoff(tries, deadline)) 6156 continue 6157 raise plumbing.convert_error_to_porcelain(e) from e 6158 tries = 0 6159 for plumbing_item in plumbing_response.proxy_cluster_keys: 6160 yield plumbing.convert_proxy_cluster_key_to_porcelain( 6161 plumbing_item) 6162 if plumbing_response.meta.next_cursor == '': 6163 break 6164 req.meta.cursor = plumbing_response.meta.next_cursor 6165 6166 return generator(self, req)
List gets a list of ProxyClusterKeys matching a given set of criteria.
class
SnapshotProxyClusterKeys:
6169class SnapshotProxyClusterKeys: 6170 ''' 6171 SnapshotProxyClusterKeys exposes the read only methods of the ProxyClusterKeys 6172 service for historical queries. 6173 ''' 6174 def __init__(self, proxy_cluster_keys): 6175 self.proxy_cluster_keys = proxy_cluster_keys 6176 6177 def get(self, id, timeout=None): 6178 ''' 6179 Get reads one ProxyClusterKey by ID. 6180 ''' 6181 return self.proxy_cluster_keys.get(id, timeout=timeout) 6182 6183 def list(self, filter, *args, timeout=None): 6184 ''' 6185 List gets a list of ProxyClusterKeys matching a given set of criteria. 6186 ''' 6187 return self.proxy_cluster_keys.list(filter, *args, timeout=timeout)
SnapshotProxyClusterKeys exposes the read only methods of the ProxyClusterKeys service for historical queries.
def
get(self, id, timeout=None)
6177 def get(self, id, timeout=None): 6178 ''' 6179 Get reads one ProxyClusterKey by ID. 6180 ''' 6181 return self.proxy_cluster_keys.get(id, timeout=timeout)
Get reads one ProxyClusterKey by ID.
def
list(self, filter, *args, timeout=None)
6183 def list(self, filter, *args, timeout=None): 6184 ''' 6185 List gets a list of ProxyClusterKeys matching a given set of criteria. 6186 ''' 6187 return self.proxy_cluster_keys.list(filter, *args, timeout=timeout)
List gets a list of ProxyClusterKeys matching a given set of criteria.
class
Queries:
6190class Queries: 6191 ''' 6192 A Query is a record of a single client request to a resource, such as a SQL query. 6193 Long-running SSH, RDP, or Kubernetes interactive sessions also count as queries. 6194 The Queries service is read-only. 6195 See `strongdm.models.Query`. 6196 ''' 6197 def __init__(self, channel, client): 6198 self.parent = client 6199 self.stub = QueriesStub(channel) 6200 6201 def list(self, filter, *args, timeout=None): 6202 ''' 6203 List gets a list of Queries matching a given set of criteria. 6204 ''' 6205 deadline = None if timeout is None else time.time() + timeout 6206 req = QueryListRequest() 6207 req.meta.CopyFrom(ListRequestMetadata()) 6208 if self.parent.page_limit > 0: 6209 req.meta.limit = self.parent.page_limit 6210 if self.parent.snapshot_datetime is not None: 6211 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6212 6213 req.filter = plumbing.quote_filter_args(filter, *args) 6214 6215 def generator(svc, req): 6216 tries = 0 6217 while True: 6218 t = None if deadline is None else deadline - time.time() 6219 try: 6220 plumbing_response = svc.stub.List( 6221 req, 6222 metadata=svc.parent.get_metadata('Queries.List', req), 6223 timeout=t) 6224 except Exception as e: 6225 if self.parent.shouldRetry(tries, e, deadline): 6226 tries += 1 6227 time.sleep( 6228 self.parent.exponentialBackoff(tries, deadline)) 6229 continue 6230 raise plumbing.convert_error_to_porcelain(e) from e 6231 tries = 0 6232 for plumbing_item in plumbing_response.queries: 6233 yield plumbing.convert_query_to_porcelain(plumbing_item) 6234 if plumbing_response.meta.next_cursor == '': 6235 break 6236 req.meta.cursor = plumbing_response.meta.next_cursor 6237 6238 return generator(self, req)
A Query is a record of a single client request to a resource, such as a SQL query.
Long-running SSH, RDP, or Kubernetes interactive sessions also count as queries.
The Queries service is read-only.
See strongdm.models.Query.
def
list(self, filter, *args, timeout=None)
6201 def list(self, filter, *args, timeout=None): 6202 ''' 6203 List gets a list of Queries matching a given set of criteria. 6204 ''' 6205 deadline = None if timeout is None else time.time() + timeout 6206 req = QueryListRequest() 6207 req.meta.CopyFrom(ListRequestMetadata()) 6208 if self.parent.page_limit > 0: 6209 req.meta.limit = self.parent.page_limit 6210 if self.parent.snapshot_datetime is not None: 6211 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6212 6213 req.filter = plumbing.quote_filter_args(filter, *args) 6214 6215 def generator(svc, req): 6216 tries = 0 6217 while True: 6218 t = None if deadline is None else deadline - time.time() 6219 try: 6220 plumbing_response = svc.stub.List( 6221 req, 6222 metadata=svc.parent.get_metadata('Queries.List', req), 6223 timeout=t) 6224 except Exception as e: 6225 if self.parent.shouldRetry(tries, e, deadline): 6226 tries += 1 6227 time.sleep( 6228 self.parent.exponentialBackoff(tries, deadline)) 6229 continue 6230 raise plumbing.convert_error_to_porcelain(e) from e 6231 tries = 0 6232 for plumbing_item in plumbing_response.queries: 6233 yield plumbing.convert_query_to_porcelain(plumbing_item) 6234 if plumbing_response.meta.next_cursor == '': 6235 break 6236 req.meta.cursor = plumbing_response.meta.next_cursor 6237 6238 return generator(self, req)
List gets a list of Queries matching a given set of criteria.
class
RemoteIdentities:
6241class RemoteIdentities: 6242 ''' 6243 RemoteIdentities assign a resource directly to an account, giving the account the permission to connect to that resource. 6244 See `strongdm.models.RemoteIdentity`. 6245 ''' 6246 def __init__(self, channel, client): 6247 self.parent = client 6248 self.stub = RemoteIdentitiesStub(channel) 6249 6250 def create(self, remote_identity, timeout=None): 6251 ''' 6252 Create registers a new RemoteIdentity. 6253 ''' 6254 deadline = None if timeout is None else time.time() + timeout 6255 req = RemoteIdentityCreateRequest() 6256 6257 if remote_identity is not None: 6258 req.remote_identity.CopyFrom( 6259 plumbing.convert_remote_identity_to_plumbing(remote_identity)) 6260 tries = 0 6261 plumbing_response = None 6262 while True: 6263 t = None if deadline is None else deadline - time.time() 6264 try: 6265 plumbing_response = self.stub.Create( 6266 req, 6267 metadata=self.parent.get_metadata( 6268 'RemoteIdentities.Create', req), 6269 timeout=t) 6270 except Exception as e: 6271 if self.parent.shouldRetry(tries, e, deadline): 6272 tries += 1 6273 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6274 continue 6275 raise plumbing.convert_error_to_porcelain(e) from e 6276 break 6277 6278 resp = models.RemoteIdentityCreateResponse() 6279 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 6280 plumbing_response.meta) 6281 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6282 plumbing_response.rate_limit) 6283 resp.remote_identity = plumbing.convert_remote_identity_to_porcelain( 6284 plumbing_response.remote_identity) 6285 return resp 6286 6287 def get(self, id, timeout=None): 6288 ''' 6289 Get reads one RemoteIdentity by ID. 6290 ''' 6291 deadline = None if timeout is None else time.time() + timeout 6292 req = RemoteIdentityGetRequest() 6293 if self.parent.snapshot_datetime is not None: 6294 req.meta.CopyFrom(GetRequestMetadata()) 6295 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6296 6297 req.id = (id) 6298 tries = 0 6299 plumbing_response = None 6300 while True: 6301 t = None if deadline is None else deadline - time.time() 6302 try: 6303 plumbing_response = self.stub.Get( 6304 req, 6305 metadata=self.parent.get_metadata('RemoteIdentities.Get', 6306 req), 6307 timeout=t) 6308 except Exception as e: 6309 if self.parent.shouldRetry(tries, e, deadline): 6310 tries += 1 6311 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6312 continue 6313 raise plumbing.convert_error_to_porcelain(e) from e 6314 break 6315 6316 resp = models.RemoteIdentityGetResponse() 6317 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 6318 plumbing_response.meta) 6319 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6320 plumbing_response.rate_limit) 6321 resp.remote_identity = plumbing.convert_remote_identity_to_porcelain( 6322 plumbing_response.remote_identity) 6323 return resp 6324 6325 def update(self, remote_identity, timeout=None): 6326 ''' 6327 Update replaces all the fields of a RemoteIdentity by ID. 6328 ''' 6329 deadline = None if timeout is None else time.time() + timeout 6330 req = RemoteIdentityUpdateRequest() 6331 6332 if remote_identity is not None: 6333 req.remote_identity.CopyFrom( 6334 plumbing.convert_remote_identity_to_plumbing(remote_identity)) 6335 tries = 0 6336 plumbing_response = None 6337 while True: 6338 t = None if deadline is None else deadline - time.time() 6339 try: 6340 plumbing_response = self.stub.Update( 6341 req, 6342 metadata=self.parent.get_metadata( 6343 'RemoteIdentities.Update', req), 6344 timeout=t) 6345 except Exception as e: 6346 if self.parent.shouldRetry(tries, e, deadline): 6347 tries += 1 6348 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6349 continue 6350 raise plumbing.convert_error_to_porcelain(e) from e 6351 break 6352 6353 resp = models.RemoteIdentityUpdateResponse() 6354 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 6355 plumbing_response.meta) 6356 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6357 plumbing_response.rate_limit) 6358 resp.remote_identity = plumbing.convert_remote_identity_to_porcelain( 6359 plumbing_response.remote_identity) 6360 return resp 6361 6362 def delete(self, id, timeout=None): 6363 ''' 6364 Delete removes a RemoteIdentity by ID. 6365 ''' 6366 deadline = None if timeout is None else time.time() + timeout 6367 req = RemoteIdentityDeleteRequest() 6368 6369 req.id = (id) 6370 tries = 0 6371 plumbing_response = None 6372 while True: 6373 t = None if deadline is None else deadline - time.time() 6374 try: 6375 plumbing_response = self.stub.Delete( 6376 req, 6377 metadata=self.parent.get_metadata( 6378 'RemoteIdentities.Delete', req), 6379 timeout=t) 6380 except Exception as e: 6381 if self.parent.shouldRetry(tries, e, deadline): 6382 tries += 1 6383 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6384 continue 6385 raise plumbing.convert_error_to_porcelain(e) from e 6386 break 6387 6388 resp = models.RemoteIdentityDeleteResponse() 6389 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 6390 plumbing_response.meta) 6391 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6392 plumbing_response.rate_limit) 6393 return resp 6394 6395 def list(self, filter, *args, timeout=None): 6396 ''' 6397 List gets a list of RemoteIdentities matching a given set of criteria. 6398 ''' 6399 deadline = None if timeout is None else time.time() + timeout 6400 req = RemoteIdentityListRequest() 6401 req.meta.CopyFrom(ListRequestMetadata()) 6402 if self.parent.page_limit > 0: 6403 req.meta.limit = self.parent.page_limit 6404 if self.parent.snapshot_datetime is not None: 6405 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6406 6407 req.filter = plumbing.quote_filter_args(filter, *args) 6408 6409 def generator(svc, req): 6410 tries = 0 6411 while True: 6412 t = None if deadline is None else deadline - time.time() 6413 try: 6414 plumbing_response = svc.stub.List( 6415 req, 6416 metadata=svc.parent.get_metadata( 6417 'RemoteIdentities.List', req), 6418 timeout=t) 6419 except Exception as e: 6420 if self.parent.shouldRetry(tries, e, deadline): 6421 tries += 1 6422 time.sleep( 6423 self.parent.exponentialBackoff(tries, deadline)) 6424 continue 6425 raise plumbing.convert_error_to_porcelain(e) from e 6426 tries = 0 6427 for plumbing_item in plumbing_response.remote_identities: 6428 yield plumbing.convert_remote_identity_to_porcelain( 6429 plumbing_item) 6430 if plumbing_response.meta.next_cursor == '': 6431 break 6432 req.meta.cursor = plumbing_response.meta.next_cursor 6433 6434 return generator(self, req)
RemoteIdentities assign a resource directly to an account, giving the account the permission to connect to that resource.
See strongdm.models.RemoteIdentity.
def
create(self, remote_identity, timeout=None)
6250 def create(self, remote_identity, timeout=None): 6251 ''' 6252 Create registers a new RemoteIdentity. 6253 ''' 6254 deadline = None if timeout is None else time.time() + timeout 6255 req = RemoteIdentityCreateRequest() 6256 6257 if remote_identity is not None: 6258 req.remote_identity.CopyFrom( 6259 plumbing.convert_remote_identity_to_plumbing(remote_identity)) 6260 tries = 0 6261 plumbing_response = None 6262 while True: 6263 t = None if deadline is None else deadline - time.time() 6264 try: 6265 plumbing_response = self.stub.Create( 6266 req, 6267 metadata=self.parent.get_metadata( 6268 'RemoteIdentities.Create', req), 6269 timeout=t) 6270 except Exception as e: 6271 if self.parent.shouldRetry(tries, e, deadline): 6272 tries += 1 6273 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6274 continue 6275 raise plumbing.convert_error_to_porcelain(e) from e 6276 break 6277 6278 resp = models.RemoteIdentityCreateResponse() 6279 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 6280 plumbing_response.meta) 6281 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6282 plumbing_response.rate_limit) 6283 resp.remote_identity = plumbing.convert_remote_identity_to_porcelain( 6284 plumbing_response.remote_identity) 6285 return resp
Create registers a new RemoteIdentity.
def
get(self, id, timeout=None)
6287 def get(self, id, timeout=None): 6288 ''' 6289 Get reads one RemoteIdentity by ID. 6290 ''' 6291 deadline = None if timeout is None else time.time() + timeout 6292 req = RemoteIdentityGetRequest() 6293 if self.parent.snapshot_datetime is not None: 6294 req.meta.CopyFrom(GetRequestMetadata()) 6295 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6296 6297 req.id = (id) 6298 tries = 0 6299 plumbing_response = None 6300 while True: 6301 t = None if deadline is None else deadline - time.time() 6302 try: 6303 plumbing_response = self.stub.Get( 6304 req, 6305 metadata=self.parent.get_metadata('RemoteIdentities.Get', 6306 req), 6307 timeout=t) 6308 except Exception as e: 6309 if self.parent.shouldRetry(tries, e, deadline): 6310 tries += 1 6311 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6312 continue 6313 raise plumbing.convert_error_to_porcelain(e) from e 6314 break 6315 6316 resp = models.RemoteIdentityGetResponse() 6317 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 6318 plumbing_response.meta) 6319 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6320 plumbing_response.rate_limit) 6321 resp.remote_identity = plumbing.convert_remote_identity_to_porcelain( 6322 plumbing_response.remote_identity) 6323 return resp
Get reads one RemoteIdentity by ID.
def
update(self, remote_identity, timeout=None)
6325 def update(self, remote_identity, timeout=None): 6326 ''' 6327 Update replaces all the fields of a RemoteIdentity by ID. 6328 ''' 6329 deadline = None if timeout is None else time.time() + timeout 6330 req = RemoteIdentityUpdateRequest() 6331 6332 if remote_identity is not None: 6333 req.remote_identity.CopyFrom( 6334 plumbing.convert_remote_identity_to_plumbing(remote_identity)) 6335 tries = 0 6336 plumbing_response = None 6337 while True: 6338 t = None if deadline is None else deadline - time.time() 6339 try: 6340 plumbing_response = self.stub.Update( 6341 req, 6342 metadata=self.parent.get_metadata( 6343 'RemoteIdentities.Update', req), 6344 timeout=t) 6345 except Exception as e: 6346 if self.parent.shouldRetry(tries, e, deadline): 6347 tries += 1 6348 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6349 continue 6350 raise plumbing.convert_error_to_porcelain(e) from e 6351 break 6352 6353 resp = models.RemoteIdentityUpdateResponse() 6354 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 6355 plumbing_response.meta) 6356 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6357 plumbing_response.rate_limit) 6358 resp.remote_identity = plumbing.convert_remote_identity_to_porcelain( 6359 plumbing_response.remote_identity) 6360 return resp
Update replaces all the fields of a RemoteIdentity by ID.
def
delete(self, id, timeout=None)
6362 def delete(self, id, timeout=None): 6363 ''' 6364 Delete removes a RemoteIdentity by ID. 6365 ''' 6366 deadline = None if timeout is None else time.time() + timeout 6367 req = RemoteIdentityDeleteRequest() 6368 6369 req.id = (id) 6370 tries = 0 6371 plumbing_response = None 6372 while True: 6373 t = None if deadline is None else deadline - time.time() 6374 try: 6375 plumbing_response = self.stub.Delete( 6376 req, 6377 metadata=self.parent.get_metadata( 6378 'RemoteIdentities.Delete', req), 6379 timeout=t) 6380 except Exception as e: 6381 if self.parent.shouldRetry(tries, e, deadline): 6382 tries += 1 6383 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6384 continue 6385 raise plumbing.convert_error_to_porcelain(e) from e 6386 break 6387 6388 resp = models.RemoteIdentityDeleteResponse() 6389 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 6390 plumbing_response.meta) 6391 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6392 plumbing_response.rate_limit) 6393 return resp
Delete removes a RemoteIdentity by ID.
def
list(self, filter, *args, timeout=None)
6395 def list(self, filter, *args, timeout=None): 6396 ''' 6397 List gets a list of RemoteIdentities matching a given set of criteria. 6398 ''' 6399 deadline = None if timeout is None else time.time() + timeout 6400 req = RemoteIdentityListRequest() 6401 req.meta.CopyFrom(ListRequestMetadata()) 6402 if self.parent.page_limit > 0: 6403 req.meta.limit = self.parent.page_limit 6404 if self.parent.snapshot_datetime is not None: 6405 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6406 6407 req.filter = plumbing.quote_filter_args(filter, *args) 6408 6409 def generator(svc, req): 6410 tries = 0 6411 while True: 6412 t = None if deadline is None else deadline - time.time() 6413 try: 6414 plumbing_response = svc.stub.List( 6415 req, 6416 metadata=svc.parent.get_metadata( 6417 'RemoteIdentities.List', req), 6418 timeout=t) 6419 except Exception as e: 6420 if self.parent.shouldRetry(tries, e, deadline): 6421 tries += 1 6422 time.sleep( 6423 self.parent.exponentialBackoff(tries, deadline)) 6424 continue 6425 raise plumbing.convert_error_to_porcelain(e) from e 6426 tries = 0 6427 for plumbing_item in plumbing_response.remote_identities: 6428 yield plumbing.convert_remote_identity_to_porcelain( 6429 plumbing_item) 6430 if plumbing_response.meta.next_cursor == '': 6431 break 6432 req.meta.cursor = plumbing_response.meta.next_cursor 6433 6434 return generator(self, req)
List gets a list of RemoteIdentities matching a given set of criteria.
class
SnapshotRemoteIdentities:
6437class SnapshotRemoteIdentities: 6438 ''' 6439 SnapshotRemoteIdentities exposes the read only methods of the RemoteIdentities 6440 service for historical queries. 6441 ''' 6442 def __init__(self, remote_identities): 6443 self.remote_identities = remote_identities 6444 6445 def get(self, id, timeout=None): 6446 ''' 6447 Get reads one RemoteIdentity by ID. 6448 ''' 6449 return self.remote_identities.get(id, timeout=timeout) 6450 6451 def list(self, filter, *args, timeout=None): 6452 ''' 6453 List gets a list of RemoteIdentities matching a given set of criteria. 6454 ''' 6455 return self.remote_identities.list(filter, *args, timeout=timeout)
SnapshotRemoteIdentities exposes the read only methods of the RemoteIdentities service for historical queries.
def
get(self, id, timeout=None)
6445 def get(self, id, timeout=None): 6446 ''' 6447 Get reads one RemoteIdentity by ID. 6448 ''' 6449 return self.remote_identities.get(id, timeout=timeout)
Get reads one RemoteIdentity by ID.
def
list(self, filter, *args, timeout=None)
6451 def list(self, filter, *args, timeout=None): 6452 ''' 6453 List gets a list of RemoteIdentities matching a given set of criteria. 6454 ''' 6455 return self.remote_identities.list(filter, *args, timeout=timeout)
List gets a list of RemoteIdentities matching a given set of criteria.
class
RemoteIdentitiesHistory:
6458class RemoteIdentitiesHistory: 6459 ''' 6460 RemoteIdentitiesHistory records all changes to the state of a RemoteIdentity. 6461 See `strongdm.models.RemoteIdentityHistory`. 6462 ''' 6463 def __init__(self, channel, client): 6464 self.parent = client 6465 self.stub = RemoteIdentitiesHistoryStub(channel) 6466 6467 def list(self, filter, *args, timeout=None): 6468 ''' 6469 List gets a list of RemoteIdentityHistory records matching a given set of criteria. 6470 ''' 6471 deadline = None if timeout is None else time.time() + timeout 6472 req = RemoteIdentityHistoryListRequest() 6473 req.meta.CopyFrom(ListRequestMetadata()) 6474 if self.parent.page_limit > 0: 6475 req.meta.limit = self.parent.page_limit 6476 if self.parent.snapshot_datetime is not None: 6477 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6478 6479 req.filter = plumbing.quote_filter_args(filter, *args) 6480 6481 def generator(svc, req): 6482 tries = 0 6483 while True: 6484 t = None if deadline is None else deadline - time.time() 6485 try: 6486 plumbing_response = svc.stub.List( 6487 req, 6488 metadata=svc.parent.get_metadata( 6489 'RemoteIdentitiesHistory.List', req), 6490 timeout=t) 6491 except Exception as e: 6492 if self.parent.shouldRetry(tries, e, deadline): 6493 tries += 1 6494 time.sleep( 6495 self.parent.exponentialBackoff(tries, deadline)) 6496 continue 6497 raise plumbing.convert_error_to_porcelain(e) from e 6498 tries = 0 6499 for plumbing_item in plumbing_response.history: 6500 yield plumbing.convert_remote_identity_history_to_porcelain( 6501 plumbing_item) 6502 if plumbing_response.meta.next_cursor == '': 6503 break 6504 req.meta.cursor = plumbing_response.meta.next_cursor 6505 6506 return generator(self, req)
RemoteIdentitiesHistory records all changes to the state of a RemoteIdentity.
See strongdm.models.RemoteIdentityHistory.
def
list(self, filter, *args, timeout=None)
6467 def list(self, filter, *args, timeout=None): 6468 ''' 6469 List gets a list of RemoteIdentityHistory records matching a given set of criteria. 6470 ''' 6471 deadline = None if timeout is None else time.time() + timeout 6472 req = RemoteIdentityHistoryListRequest() 6473 req.meta.CopyFrom(ListRequestMetadata()) 6474 if self.parent.page_limit > 0: 6475 req.meta.limit = self.parent.page_limit 6476 if self.parent.snapshot_datetime is not None: 6477 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6478 6479 req.filter = plumbing.quote_filter_args(filter, *args) 6480 6481 def generator(svc, req): 6482 tries = 0 6483 while True: 6484 t = None if deadline is None else deadline - time.time() 6485 try: 6486 plumbing_response = svc.stub.List( 6487 req, 6488 metadata=svc.parent.get_metadata( 6489 'RemoteIdentitiesHistory.List', req), 6490 timeout=t) 6491 except Exception as e: 6492 if self.parent.shouldRetry(tries, e, deadline): 6493 tries += 1 6494 time.sleep( 6495 self.parent.exponentialBackoff(tries, deadline)) 6496 continue 6497 raise plumbing.convert_error_to_porcelain(e) from e 6498 tries = 0 6499 for plumbing_item in plumbing_response.history: 6500 yield plumbing.convert_remote_identity_history_to_porcelain( 6501 plumbing_item) 6502 if plumbing_response.meta.next_cursor == '': 6503 break 6504 req.meta.cursor = plumbing_response.meta.next_cursor 6505 6506 return generator(self, req)
List gets a list of RemoteIdentityHistory records matching a given set of criteria.
class
RemoteIdentityGroups:
6509class RemoteIdentityGroups: 6510 ''' 6511 A RemoteIdentityGroup is a named grouping of Remote Identities for Accounts. 6512 An Account's relationship to a RemoteIdentityGroup is defined via RemoteIdentity objects. 6513 See `strongdm.models.RemoteIdentityGroup`. 6514 ''' 6515 def __init__(self, channel, client): 6516 self.parent = client 6517 self.stub = RemoteIdentityGroupsStub(channel) 6518 6519 def get(self, id, timeout=None): 6520 ''' 6521 Get reads one RemoteIdentityGroup by ID. 6522 ''' 6523 deadline = None if timeout is None else time.time() + timeout 6524 req = RemoteIdentityGroupGetRequest() 6525 if self.parent.snapshot_datetime is not None: 6526 req.meta.CopyFrom(GetRequestMetadata()) 6527 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6528 6529 req.id = (id) 6530 tries = 0 6531 plumbing_response = None 6532 while True: 6533 t = None if deadline is None else deadline - time.time() 6534 try: 6535 plumbing_response = self.stub.Get( 6536 req, 6537 metadata=self.parent.get_metadata( 6538 'RemoteIdentityGroups.Get', req), 6539 timeout=t) 6540 except Exception as e: 6541 if self.parent.shouldRetry(tries, e, deadline): 6542 tries += 1 6543 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6544 continue 6545 raise plumbing.convert_error_to_porcelain(e) from e 6546 break 6547 6548 resp = models.RemoteIdentityGroupGetResponse() 6549 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 6550 plumbing_response.meta) 6551 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6552 plumbing_response.rate_limit) 6553 resp.remote_identity_group = plumbing.convert_remote_identity_group_to_porcelain( 6554 plumbing_response.remote_identity_group) 6555 return resp 6556 6557 def list(self, filter, *args, timeout=None): 6558 ''' 6559 List gets a list of RemoteIdentityGroups matching a given set of criteria. 6560 ''' 6561 deadline = None if timeout is None else time.time() + timeout 6562 req = RemoteIdentityGroupListRequest() 6563 req.meta.CopyFrom(ListRequestMetadata()) 6564 if self.parent.page_limit > 0: 6565 req.meta.limit = self.parent.page_limit 6566 if self.parent.snapshot_datetime is not None: 6567 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6568 6569 req.filter = plumbing.quote_filter_args(filter, *args) 6570 6571 def generator(svc, req): 6572 tries = 0 6573 while True: 6574 t = None if deadline is None else deadline - time.time() 6575 try: 6576 plumbing_response = svc.stub.List( 6577 req, 6578 metadata=svc.parent.get_metadata( 6579 'RemoteIdentityGroups.List', req), 6580 timeout=t) 6581 except Exception as e: 6582 if self.parent.shouldRetry(tries, e, deadline): 6583 tries += 1 6584 time.sleep( 6585 self.parent.exponentialBackoff(tries, deadline)) 6586 continue 6587 raise plumbing.convert_error_to_porcelain(e) from e 6588 tries = 0 6589 for plumbing_item in plumbing_response.remote_identity_groups: 6590 yield plumbing.convert_remote_identity_group_to_porcelain( 6591 plumbing_item) 6592 if plumbing_response.meta.next_cursor == '': 6593 break 6594 req.meta.cursor = plumbing_response.meta.next_cursor 6595 6596 return generator(self, req)
A RemoteIdentityGroup is a named grouping of Remote Identities for Accounts.
An Account's relationship to a RemoteIdentityGroup is defined via RemoteIdentity objects.
See strongdm.models.RemoteIdentityGroup.
def
get(self, id, timeout=None)
6519 def get(self, id, timeout=None): 6520 ''' 6521 Get reads one RemoteIdentityGroup by ID. 6522 ''' 6523 deadline = None if timeout is None else time.time() + timeout 6524 req = RemoteIdentityGroupGetRequest() 6525 if self.parent.snapshot_datetime is not None: 6526 req.meta.CopyFrom(GetRequestMetadata()) 6527 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6528 6529 req.id = (id) 6530 tries = 0 6531 plumbing_response = None 6532 while True: 6533 t = None if deadline is None else deadline - time.time() 6534 try: 6535 plumbing_response = self.stub.Get( 6536 req, 6537 metadata=self.parent.get_metadata( 6538 'RemoteIdentityGroups.Get', req), 6539 timeout=t) 6540 except Exception as e: 6541 if self.parent.shouldRetry(tries, e, deadline): 6542 tries += 1 6543 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6544 continue 6545 raise plumbing.convert_error_to_porcelain(e) from e 6546 break 6547 6548 resp = models.RemoteIdentityGroupGetResponse() 6549 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 6550 plumbing_response.meta) 6551 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6552 plumbing_response.rate_limit) 6553 resp.remote_identity_group = plumbing.convert_remote_identity_group_to_porcelain( 6554 plumbing_response.remote_identity_group) 6555 return resp
Get reads one RemoteIdentityGroup by ID.
def
list(self, filter, *args, timeout=None)
6557 def list(self, filter, *args, timeout=None): 6558 ''' 6559 List gets a list of RemoteIdentityGroups matching a given set of criteria. 6560 ''' 6561 deadline = None if timeout is None else time.time() + timeout 6562 req = RemoteIdentityGroupListRequest() 6563 req.meta.CopyFrom(ListRequestMetadata()) 6564 if self.parent.page_limit > 0: 6565 req.meta.limit = self.parent.page_limit 6566 if self.parent.snapshot_datetime is not None: 6567 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6568 6569 req.filter = plumbing.quote_filter_args(filter, *args) 6570 6571 def generator(svc, req): 6572 tries = 0 6573 while True: 6574 t = None if deadline is None else deadline - time.time() 6575 try: 6576 plumbing_response = svc.stub.List( 6577 req, 6578 metadata=svc.parent.get_metadata( 6579 'RemoteIdentityGroups.List', req), 6580 timeout=t) 6581 except Exception as e: 6582 if self.parent.shouldRetry(tries, e, deadline): 6583 tries += 1 6584 time.sleep( 6585 self.parent.exponentialBackoff(tries, deadline)) 6586 continue 6587 raise plumbing.convert_error_to_porcelain(e) from e 6588 tries = 0 6589 for plumbing_item in plumbing_response.remote_identity_groups: 6590 yield plumbing.convert_remote_identity_group_to_porcelain( 6591 plumbing_item) 6592 if plumbing_response.meta.next_cursor == '': 6593 break 6594 req.meta.cursor = plumbing_response.meta.next_cursor 6595 6596 return generator(self, req)
List gets a list of RemoteIdentityGroups matching a given set of criteria.
class
SnapshotRemoteIdentityGroups:
6599class SnapshotRemoteIdentityGroups: 6600 ''' 6601 SnapshotRemoteIdentityGroups exposes the read only methods of the RemoteIdentityGroups 6602 service for historical queries. 6603 ''' 6604 def __init__(self, remote_identity_groups): 6605 self.remote_identity_groups = remote_identity_groups 6606 6607 def get(self, id, timeout=None): 6608 ''' 6609 Get reads one RemoteIdentityGroup by ID. 6610 ''' 6611 return self.remote_identity_groups.get(id, timeout=timeout) 6612 6613 def list(self, filter, *args, timeout=None): 6614 ''' 6615 List gets a list of RemoteIdentityGroups matching a given set of criteria. 6616 ''' 6617 return self.remote_identity_groups.list(filter, *args, timeout=timeout)
SnapshotRemoteIdentityGroups exposes the read only methods of the RemoteIdentityGroups service for historical queries.
def
get(self, id, timeout=None)
6607 def get(self, id, timeout=None): 6608 ''' 6609 Get reads one RemoteIdentityGroup by ID. 6610 ''' 6611 return self.remote_identity_groups.get(id, timeout=timeout)
Get reads one RemoteIdentityGroup by ID.
def
list(self, filter, *args, timeout=None)
6613 def list(self, filter, *args, timeout=None): 6614 ''' 6615 List gets a list of RemoteIdentityGroups matching a given set of criteria. 6616 ''' 6617 return self.remote_identity_groups.list(filter, *args, timeout=timeout)
List gets a list of RemoteIdentityGroups matching a given set of criteria.
class
RemoteIdentityGroupsHistory:
6620class RemoteIdentityGroupsHistory: 6621 ''' 6622 RemoteIdentityGroupsHistory records all changes to the state of a RemoteIdentityGroup. 6623 See `strongdm.models.RemoteIdentityGroupHistory`. 6624 ''' 6625 def __init__(self, channel, client): 6626 self.parent = client 6627 self.stub = RemoteIdentityGroupsHistoryStub(channel) 6628 6629 def list(self, filter, *args, timeout=None): 6630 ''' 6631 List gets a list of RemoteIdentityGroupHistory records matching a given set of criteria. 6632 ''' 6633 deadline = None if timeout is None else time.time() + timeout 6634 req = RemoteIdentityGroupHistoryListRequest() 6635 req.meta.CopyFrom(ListRequestMetadata()) 6636 if self.parent.page_limit > 0: 6637 req.meta.limit = self.parent.page_limit 6638 if self.parent.snapshot_datetime is not None: 6639 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6640 6641 req.filter = plumbing.quote_filter_args(filter, *args) 6642 6643 def generator(svc, req): 6644 tries = 0 6645 while True: 6646 t = None if deadline is None else deadline - time.time() 6647 try: 6648 plumbing_response = svc.stub.List( 6649 req, 6650 metadata=svc.parent.get_metadata( 6651 'RemoteIdentityGroupsHistory.List', req), 6652 timeout=t) 6653 except Exception as e: 6654 if self.parent.shouldRetry(tries, e, deadline): 6655 tries += 1 6656 time.sleep( 6657 self.parent.exponentialBackoff(tries, deadline)) 6658 continue 6659 raise plumbing.convert_error_to_porcelain(e) from e 6660 tries = 0 6661 for plumbing_item in plumbing_response.history: 6662 yield plumbing.convert_remote_identity_group_history_to_porcelain( 6663 plumbing_item) 6664 if plumbing_response.meta.next_cursor == '': 6665 break 6666 req.meta.cursor = plumbing_response.meta.next_cursor 6667 6668 return generator(self, req)
RemoteIdentityGroupsHistory records all changes to the state of a RemoteIdentityGroup.
See strongdm.models.RemoteIdentityGroupHistory.
def
list(self, filter, *args, timeout=None)
6629 def list(self, filter, *args, timeout=None): 6630 ''' 6631 List gets a list of RemoteIdentityGroupHistory records matching a given set of criteria. 6632 ''' 6633 deadline = None if timeout is None else time.time() + timeout 6634 req = RemoteIdentityGroupHistoryListRequest() 6635 req.meta.CopyFrom(ListRequestMetadata()) 6636 if self.parent.page_limit > 0: 6637 req.meta.limit = self.parent.page_limit 6638 if self.parent.snapshot_datetime is not None: 6639 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6640 6641 req.filter = plumbing.quote_filter_args(filter, *args) 6642 6643 def generator(svc, req): 6644 tries = 0 6645 while True: 6646 t = None if deadline is None else deadline - time.time() 6647 try: 6648 plumbing_response = svc.stub.List( 6649 req, 6650 metadata=svc.parent.get_metadata( 6651 'RemoteIdentityGroupsHistory.List', req), 6652 timeout=t) 6653 except Exception as e: 6654 if self.parent.shouldRetry(tries, e, deadline): 6655 tries += 1 6656 time.sleep( 6657 self.parent.exponentialBackoff(tries, deadline)) 6658 continue 6659 raise plumbing.convert_error_to_porcelain(e) from e 6660 tries = 0 6661 for plumbing_item in plumbing_response.history: 6662 yield plumbing.convert_remote_identity_group_history_to_porcelain( 6663 plumbing_item) 6664 if plumbing_response.meta.next_cursor == '': 6665 break 6666 req.meta.cursor = plumbing_response.meta.next_cursor 6667 6668 return generator(self, req)
List gets a list of RemoteIdentityGroupHistory records matching a given set of criteria.
class
Replays:
6671class Replays: 6672 ''' 6673 A Replay captures the data transferred over a long-running SSH, RDP, or Kubernetes interactive session 6674 (otherwise referred to as a query). The Replays service is read-only. 6675 See `strongdm.models.ReplayChunk`. 6676 ''' 6677 def __init__(self, channel, client): 6678 self.parent = client 6679 self.stub = ReplaysStub(channel) 6680 6681 def list(self, filter, *args, timeout=None): 6682 ''' 6683 List gets a list of ReplayChunks for the Query ID specified by the filter criteria. 6684 ''' 6685 deadline = None if timeout is None else time.time() + timeout 6686 req = ReplayListRequest() 6687 req.meta.CopyFrom(ListRequestMetadata()) 6688 if self.parent.page_limit > 0: 6689 req.meta.limit = self.parent.page_limit 6690 if self.parent.snapshot_datetime is not None: 6691 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6692 6693 req.filter = plumbing.quote_filter_args(filter, *args) 6694 6695 def generator(svc, req): 6696 tries = 0 6697 while True: 6698 t = None if deadline is None else deadline - time.time() 6699 try: 6700 plumbing_response = svc.stub.List( 6701 req, 6702 metadata=svc.parent.get_metadata('Replays.List', req), 6703 timeout=t) 6704 except Exception as e: 6705 if self.parent.shouldRetry(tries, e, deadline): 6706 tries += 1 6707 time.sleep( 6708 self.parent.exponentialBackoff(tries, deadline)) 6709 continue 6710 raise plumbing.convert_error_to_porcelain(e) from e 6711 tries = 0 6712 for plumbing_item in plumbing_response.chunks: 6713 yield plumbing.convert_replay_chunk_to_porcelain( 6714 plumbing_item) 6715 if plumbing_response.meta.next_cursor == '': 6716 break 6717 req.meta.cursor = plumbing_response.meta.next_cursor 6718 6719 return generator(self, req)
A Replay captures the data transferred over a long-running SSH, RDP, or Kubernetes interactive session
(otherwise referred to as a query). The Replays service is read-only.
See strongdm.models.ReplayChunk.
def
list(self, filter, *args, timeout=None)
6681 def list(self, filter, *args, timeout=None): 6682 ''' 6683 List gets a list of ReplayChunks for the Query ID specified by the filter criteria. 6684 ''' 6685 deadline = None if timeout is None else time.time() + timeout 6686 req = ReplayListRequest() 6687 req.meta.CopyFrom(ListRequestMetadata()) 6688 if self.parent.page_limit > 0: 6689 req.meta.limit = self.parent.page_limit 6690 if self.parent.snapshot_datetime is not None: 6691 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6692 6693 req.filter = plumbing.quote_filter_args(filter, *args) 6694 6695 def generator(svc, req): 6696 tries = 0 6697 while True: 6698 t = None if deadline is None else deadline - time.time() 6699 try: 6700 plumbing_response = svc.stub.List( 6701 req, 6702 metadata=svc.parent.get_metadata('Replays.List', req), 6703 timeout=t) 6704 except Exception as e: 6705 if self.parent.shouldRetry(tries, e, deadline): 6706 tries += 1 6707 time.sleep( 6708 self.parent.exponentialBackoff(tries, deadline)) 6709 continue 6710 raise plumbing.convert_error_to_porcelain(e) from e 6711 tries = 0 6712 for plumbing_item in plumbing_response.chunks: 6713 yield plumbing.convert_replay_chunk_to_porcelain( 6714 plumbing_item) 6715 if plumbing_response.meta.next_cursor == '': 6716 break 6717 req.meta.cursor = plumbing_response.meta.next_cursor 6718 6719 return generator(self, req)
List gets a list of ReplayChunks for the Query ID specified by the filter criteria.
class
RequestableAccountEntitlements:
6722class RequestableAccountEntitlements: 6723 ''' 6724 RequestableAccountEntitlements enumerates the resources that an account is permitted to request access to. 6725 The RequestableAccountEntitlements service is read-only. 6726 See `strongdm.models.RequestableAccountEntitlement`. 6727 ''' 6728 def __init__(self, channel, client): 6729 self.parent = client 6730 self.stub = RequestableAccountEntitlementsStub(channel) 6731 6732 def list(self, account_id, filter, *args, timeout=None): 6733 ''' 6734 List gets a list of RequestableAccountEntitlement records matching a given set of criteria. 6735 ''' 6736 deadline = None if timeout is None else time.time() + timeout 6737 req = RequestableAccountEntitlementListRequest() 6738 req.meta.CopyFrom(ListRequestMetadata()) 6739 if self.parent.page_limit > 0: 6740 req.meta.limit = self.parent.page_limit 6741 if self.parent.snapshot_datetime is not None: 6742 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6743 6744 req.account_id = (account_id) 6745 req.filter = plumbing.quote_filter_args(filter, *args) 6746 6747 def generator(svc, req): 6748 tries = 0 6749 while True: 6750 t = None if deadline is None else deadline - time.time() 6751 try: 6752 plumbing_response = svc.stub.List( 6753 req, 6754 metadata=svc.parent.get_metadata( 6755 'RequestableAccountEntitlements.List', req), 6756 timeout=t) 6757 except Exception as e: 6758 if self.parent.shouldRetry(tries, e, deadline): 6759 tries += 1 6760 time.sleep( 6761 self.parent.exponentialBackoff(tries, deadline)) 6762 continue 6763 raise plumbing.convert_error_to_porcelain(e) from e 6764 tries = 0 6765 for plumbing_item in plumbing_response.requestable_account_entitlements: 6766 yield plumbing.convert_requestable_account_entitlement_to_porcelain( 6767 plumbing_item) 6768 if plumbing_response.meta.next_cursor == '': 6769 break 6770 req.meta.cursor = plumbing_response.meta.next_cursor 6771 6772 return generator(self, req)
RequestableAccountEntitlements enumerates the resources that an account is permitted to request access to.
The RequestableAccountEntitlements service is read-only.
See strongdm.models.RequestableAccountEntitlement.
def
list(self, account_id, filter, *args, timeout=None)
6732 def list(self, account_id, filter, *args, timeout=None): 6733 ''' 6734 List gets a list of RequestableAccountEntitlement records matching a given set of criteria. 6735 ''' 6736 deadline = None if timeout is None else time.time() + timeout 6737 req = RequestableAccountEntitlementListRequest() 6738 req.meta.CopyFrom(ListRequestMetadata()) 6739 if self.parent.page_limit > 0: 6740 req.meta.limit = self.parent.page_limit 6741 if self.parent.snapshot_datetime is not None: 6742 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6743 6744 req.account_id = (account_id) 6745 req.filter = plumbing.quote_filter_args(filter, *args) 6746 6747 def generator(svc, req): 6748 tries = 0 6749 while True: 6750 t = None if deadline is None else deadline - time.time() 6751 try: 6752 plumbing_response = svc.stub.List( 6753 req, 6754 metadata=svc.parent.get_metadata( 6755 'RequestableAccountEntitlements.List', req), 6756 timeout=t) 6757 except Exception as e: 6758 if self.parent.shouldRetry(tries, e, deadline): 6759 tries += 1 6760 time.sleep( 6761 self.parent.exponentialBackoff(tries, deadline)) 6762 continue 6763 raise plumbing.convert_error_to_porcelain(e) from e 6764 tries = 0 6765 for plumbing_item in plumbing_response.requestable_account_entitlements: 6766 yield plumbing.convert_requestable_account_entitlement_to_porcelain( 6767 plumbing_item) 6768 if plumbing_response.meta.next_cursor == '': 6769 break 6770 req.meta.cursor = plumbing_response.meta.next_cursor 6771 6772 return generator(self, req)
List gets a list of RequestableAccountEntitlement records matching a given set of criteria.
class
SnapshotRequestableAccountEntitlements:
6775class SnapshotRequestableAccountEntitlements: 6776 ''' 6777 SnapshotRequestableAccountEntitlements exposes the read only methods of the RequestableAccountEntitlements 6778 service for historical queries. 6779 ''' 6780 def __init__(self, requestable_account_entitlements): 6781 self.requestable_account_entitlements = requestable_account_entitlements 6782 6783 def list(self, account_id, filter, *args, timeout=None): 6784 ''' 6785 List gets a list of RequestableAccountEntitlement records matching a given set of criteria. 6786 ''' 6787 return self.requestable_account_entitlements.list(account_id, 6788 filter, 6789 *args, 6790 timeout=timeout)
SnapshotRequestableAccountEntitlements exposes the read only methods of the RequestableAccountEntitlements service for historical queries.
def
list(self, account_id, filter, *args, timeout=None)
6783 def list(self, account_id, filter, *args, timeout=None): 6784 ''' 6785 List gets a list of RequestableAccountEntitlement records matching a given set of criteria. 6786 ''' 6787 return self.requestable_account_entitlements.list(account_id, 6788 filter, 6789 *args, 6790 timeout=timeout)
List gets a list of RequestableAccountEntitlement records matching a given set of criteria.
class
RequestableResourceEntitlements:
6793class RequestableResourceEntitlements: 6794 ''' 6795 RequestableResourceEntitlements enumerates the accounts that are permitted to request access to a given resource. 6796 The RequestableResourceEntitlements service is read-only. 6797 See `strongdm.models.RequestableResourceEntitlement`. 6798 ''' 6799 def __init__(self, channel, client): 6800 self.parent = client 6801 self.stub = RequestableResourceEntitlementsStub(channel) 6802 6803 def list(self, resource_id, filter, *args, timeout=None): 6804 ''' 6805 List gets a list of RequestableResourceEntitlement records matching a given set of criteria. 6806 ''' 6807 deadline = None if timeout is None else time.time() + timeout 6808 req = RequestableResourceEntitlementListRequest() 6809 req.meta.CopyFrom(ListRequestMetadata()) 6810 if self.parent.page_limit > 0: 6811 req.meta.limit = self.parent.page_limit 6812 if self.parent.snapshot_datetime is not None: 6813 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6814 6815 req.resource_id = (resource_id) 6816 req.filter = plumbing.quote_filter_args(filter, *args) 6817 6818 def generator(svc, req): 6819 tries = 0 6820 while True: 6821 t = None if deadline is None else deadline - time.time() 6822 try: 6823 plumbing_response = svc.stub.List( 6824 req, 6825 metadata=svc.parent.get_metadata( 6826 'RequestableResourceEntitlements.List', req), 6827 timeout=t) 6828 except Exception as e: 6829 if self.parent.shouldRetry(tries, e, deadline): 6830 tries += 1 6831 time.sleep( 6832 self.parent.exponentialBackoff(tries, deadline)) 6833 continue 6834 raise plumbing.convert_error_to_porcelain(e) from e 6835 tries = 0 6836 for plumbing_item in plumbing_response.requestable_resource_entitlements: 6837 yield plumbing.convert_requestable_resource_entitlement_to_porcelain( 6838 plumbing_item) 6839 if plumbing_response.meta.next_cursor == '': 6840 break 6841 req.meta.cursor = plumbing_response.meta.next_cursor 6842 6843 return generator(self, req)
RequestableResourceEntitlements enumerates the accounts that are permitted to request access to a given resource.
The RequestableResourceEntitlements service is read-only.
See strongdm.models.RequestableResourceEntitlement.
def
list(self, resource_id, filter, *args, timeout=None)
6803 def list(self, resource_id, filter, *args, timeout=None): 6804 ''' 6805 List gets a list of RequestableResourceEntitlement records matching a given set of criteria. 6806 ''' 6807 deadline = None if timeout is None else time.time() + timeout 6808 req = RequestableResourceEntitlementListRequest() 6809 req.meta.CopyFrom(ListRequestMetadata()) 6810 if self.parent.page_limit > 0: 6811 req.meta.limit = self.parent.page_limit 6812 if self.parent.snapshot_datetime is not None: 6813 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6814 6815 req.resource_id = (resource_id) 6816 req.filter = plumbing.quote_filter_args(filter, *args) 6817 6818 def generator(svc, req): 6819 tries = 0 6820 while True: 6821 t = None if deadline is None else deadline - time.time() 6822 try: 6823 plumbing_response = svc.stub.List( 6824 req, 6825 metadata=svc.parent.get_metadata( 6826 'RequestableResourceEntitlements.List', req), 6827 timeout=t) 6828 except Exception as e: 6829 if self.parent.shouldRetry(tries, e, deadline): 6830 tries += 1 6831 time.sleep( 6832 self.parent.exponentialBackoff(tries, deadline)) 6833 continue 6834 raise plumbing.convert_error_to_porcelain(e) from e 6835 tries = 0 6836 for plumbing_item in plumbing_response.requestable_resource_entitlements: 6837 yield plumbing.convert_requestable_resource_entitlement_to_porcelain( 6838 plumbing_item) 6839 if plumbing_response.meta.next_cursor == '': 6840 break 6841 req.meta.cursor = plumbing_response.meta.next_cursor 6842 6843 return generator(self, req)
List gets a list of RequestableResourceEntitlement records matching a given set of criteria.
class
SnapshotRequestableResourceEntitlements:
6846class SnapshotRequestableResourceEntitlements: 6847 ''' 6848 SnapshotRequestableResourceEntitlements exposes the read only methods of the RequestableResourceEntitlements 6849 service for historical queries. 6850 ''' 6851 def __init__(self, requestable_resource_entitlements): 6852 self.requestable_resource_entitlements = requestable_resource_entitlements 6853 6854 def list(self, resource_id, filter, *args, timeout=None): 6855 ''' 6856 List gets a list of RequestableResourceEntitlement records matching a given set of criteria. 6857 ''' 6858 return self.requestable_resource_entitlements.list(resource_id, 6859 filter, 6860 *args, 6861 timeout=timeout)
SnapshotRequestableResourceEntitlements exposes the read only methods of the RequestableResourceEntitlements service for historical queries.
def
list(self, resource_id, filter, *args, timeout=None)
6854 def list(self, resource_id, filter, *args, timeout=None): 6855 ''' 6856 List gets a list of RequestableResourceEntitlement records matching a given set of criteria. 6857 ''' 6858 return self.requestable_resource_entitlements.list(resource_id, 6859 filter, 6860 *args, 6861 timeout=timeout)
List gets a list of RequestableResourceEntitlement records matching a given set of criteria.
class
RequestableRoleEntitlements:
6864class RequestableRoleEntitlements: 6865 ''' 6866 RequestableRoleEntitlements enumerates the resources that a role permits its members to request access to. 6867 The RequestableRoleEntitlements service is read-only. 6868 See `strongdm.models.RequestableRoleEntitlement`. 6869 ''' 6870 def __init__(self, channel, client): 6871 self.parent = client 6872 self.stub = RequestableRoleEntitlementsStub(channel) 6873 6874 def list(self, role_id, filter, *args, timeout=None): 6875 ''' 6876 List gets a list of RequestableRoleEntitlement records matching a given set of criteria. 6877 ''' 6878 deadline = None if timeout is None else time.time() + timeout 6879 req = RequestableRoleEntitlementListRequest() 6880 req.meta.CopyFrom(ListRequestMetadata()) 6881 if self.parent.page_limit > 0: 6882 req.meta.limit = self.parent.page_limit 6883 if self.parent.snapshot_datetime is not None: 6884 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6885 6886 req.role_id = (role_id) 6887 req.filter = plumbing.quote_filter_args(filter, *args) 6888 6889 def generator(svc, req): 6890 tries = 0 6891 while True: 6892 t = None if deadline is None else deadline - time.time() 6893 try: 6894 plumbing_response = svc.stub.List( 6895 req, 6896 metadata=svc.parent.get_metadata( 6897 'RequestableRoleEntitlements.List', req), 6898 timeout=t) 6899 except Exception as e: 6900 if self.parent.shouldRetry(tries, e, deadline): 6901 tries += 1 6902 time.sleep( 6903 self.parent.exponentialBackoff(tries, deadline)) 6904 continue 6905 raise plumbing.convert_error_to_porcelain(e) from e 6906 tries = 0 6907 for plumbing_item in plumbing_response.requestable_role_entitlements: 6908 yield plumbing.convert_requestable_role_entitlement_to_porcelain( 6909 plumbing_item) 6910 if plumbing_response.meta.next_cursor == '': 6911 break 6912 req.meta.cursor = plumbing_response.meta.next_cursor 6913 6914 return generator(self, req)
RequestableRoleEntitlements enumerates the resources that a role permits its members to request access to.
The RequestableRoleEntitlements service is read-only.
See strongdm.models.RequestableRoleEntitlement.
def
list(self, role_id, filter, *args, timeout=None)
6874 def list(self, role_id, filter, *args, timeout=None): 6875 ''' 6876 List gets a list of RequestableRoleEntitlement records matching a given set of criteria. 6877 ''' 6878 deadline = None if timeout is None else time.time() + timeout 6879 req = RequestableRoleEntitlementListRequest() 6880 req.meta.CopyFrom(ListRequestMetadata()) 6881 if self.parent.page_limit > 0: 6882 req.meta.limit = self.parent.page_limit 6883 if self.parent.snapshot_datetime is not None: 6884 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6885 6886 req.role_id = (role_id) 6887 req.filter = plumbing.quote_filter_args(filter, *args) 6888 6889 def generator(svc, req): 6890 tries = 0 6891 while True: 6892 t = None if deadline is None else deadline - time.time() 6893 try: 6894 plumbing_response = svc.stub.List( 6895 req, 6896 metadata=svc.parent.get_metadata( 6897 'RequestableRoleEntitlements.List', req), 6898 timeout=t) 6899 except Exception as e: 6900 if self.parent.shouldRetry(tries, e, deadline): 6901 tries += 1 6902 time.sleep( 6903 self.parent.exponentialBackoff(tries, deadline)) 6904 continue 6905 raise plumbing.convert_error_to_porcelain(e) from e 6906 tries = 0 6907 for plumbing_item in plumbing_response.requestable_role_entitlements: 6908 yield plumbing.convert_requestable_role_entitlement_to_porcelain( 6909 plumbing_item) 6910 if plumbing_response.meta.next_cursor == '': 6911 break 6912 req.meta.cursor = plumbing_response.meta.next_cursor 6913 6914 return generator(self, req)
List gets a list of RequestableRoleEntitlement records matching a given set of criteria.
class
SnapshotRequestableRoleEntitlements:
6917class SnapshotRequestableRoleEntitlements: 6918 ''' 6919 SnapshotRequestableRoleEntitlements exposes the read only methods of the RequestableRoleEntitlements 6920 service for historical queries. 6921 ''' 6922 def __init__(self, requestable_role_entitlements): 6923 self.requestable_role_entitlements = requestable_role_entitlements 6924 6925 def list(self, role_id, filter, *args, timeout=None): 6926 ''' 6927 List gets a list of RequestableRoleEntitlement records matching a given set of criteria. 6928 ''' 6929 return self.requestable_role_entitlements.list(role_id, 6930 filter, 6931 *args, 6932 timeout=timeout)
SnapshotRequestableRoleEntitlements exposes the read only methods of the RequestableRoleEntitlements service for historical queries.
def
list(self, role_id, filter, *args, timeout=None)
6925 def list(self, role_id, filter, *args, timeout=None): 6926 ''' 6927 List gets a list of RequestableRoleEntitlement records matching a given set of criteria. 6928 ''' 6929 return self.requestable_role_entitlements.list(role_id, 6930 filter, 6931 *args, 6932 timeout=timeout)
List gets a list of RequestableRoleEntitlement records matching a given set of criteria.
class
Resources:
6935class Resources: 6936 ''' 6937 Resources are databases, servers, clusters, websites, or clouds that strongDM 6938 delegates access to. 6939 See: 6940 `strongdm.models.Aerospike` 6941 `strongdm.models.AKS` 6942 `strongdm.models.AKSBasicAuth` 6943 `strongdm.models.AKSServiceAccount` 6944 `strongdm.models.AKSServiceAccountUserImpersonation` 6945 `strongdm.models.AKSUserImpersonation` 6946 `strongdm.models.AmazonEKS` 6947 `strongdm.models.AmazonEKSInstanceProfile` 6948 `strongdm.models.AmazonEKSInstanceProfileUserImpersonation` 6949 `strongdm.models.AmazonEKSUserImpersonation` 6950 `strongdm.models.AmazonES` 6951 `strongdm.models.AmazonESIAM` 6952 `strongdm.models.AmazonMQAMQP091` 6953 `strongdm.models.AMQP` 6954 `strongdm.models.Athena` 6955 `strongdm.models.AthenaIAM` 6956 `strongdm.models.AuroraMysql` 6957 `strongdm.models.AuroraMysqlIAM` 6958 `strongdm.models.AuroraPostgres` 6959 `strongdm.models.AuroraPostgresIAM` 6960 `strongdm.models.AWS` 6961 `strongdm.models.AWSConsole` 6962 `strongdm.models.AWSConsoleStaticKeyPair` 6963 `strongdm.models.AWSInstanceProfile` 6964 `strongdm.models.Azure` 6965 `strongdm.models.AzureCertificate` 6966 `strongdm.models.AzureMysql` 6967 `strongdm.models.AzureMysqlManagedIdentity` 6968 `strongdm.models.AzurePostgres` 6969 `strongdm.models.AzurePostgresManagedIdentity` 6970 `strongdm.models.BigQuery` 6971 `strongdm.models.Cassandra` 6972 `strongdm.models.Citus` 6973 `strongdm.models.ClickHouseHTTP` 6974 `strongdm.models.ClickHouseMySQL` 6975 `strongdm.models.ClickHouseTCP` 6976 `strongdm.models.Clustrix` 6977 `strongdm.models.Cockroach` 6978 `strongdm.models.CouchbaseDatabase` 6979 `strongdm.models.CouchbaseWebUI` 6980 `strongdm.models.Databricks` 6981 `strongdm.models.DB2I` 6982 `strongdm.models.DB2LUW` 6983 `strongdm.models.DocumentDBHost` 6984 `strongdm.models.DocumentDBHostIAM` 6985 `strongdm.models.DocumentDBReplicaSet` 6986 `strongdm.models.DocumentDBReplicaSetIAM` 6987 `strongdm.models.Druid` 6988 `strongdm.models.DynamoDB` 6989 `strongdm.models.DynamoDBIAM` 6990 `strongdm.models.Elastic` 6991 `strongdm.models.ElasticacheRedis` 6992 `strongdm.models.ElasticacheRedisIAM` 6993 `strongdm.models.EntraID` 6994 `strongdm.models.GCP` 6995 `strongdm.models.GCPConsole` 6996 `strongdm.models.GCPWIF` 6997 `strongdm.models.GoogleGKE` 6998 `strongdm.models.GoogleGKEUserImpersonation` 6999 `strongdm.models.GoogleGroups` 7000 `strongdm.models.GoogleSpanner` 7001 `strongdm.models.Greenplum` 7002 `strongdm.models.HTTPAuth` 7003 `strongdm.models.HTTPBasicAuth` 7004 `strongdm.models.HTTPNoAuth` 7005 `strongdm.models.Kubernetes` 7006 `strongdm.models.KubernetesBasicAuth` 7007 `strongdm.models.KubernetesPodIdentity` 7008 `strongdm.models.KubernetesServiceAccount` 7009 `strongdm.models.KubernetesServiceAccountUserImpersonation` 7010 `strongdm.models.KubernetesUserImpersonation` 7011 `strongdm.models.LLM` 7012 `strongdm.models.Maria` 7013 `strongdm.models.MCPGatewayNoAuth` 7014 `strongdm.models.MCPGatewayOAuth` 7015 `strongdm.models.MCPGatewayOAuthDCR` 7016 `strongdm.models.MCPGatewayPAT` 7017 `strongdm.models.Memcached` 7018 `strongdm.models.Memsql` 7019 `strongdm.models.MongoHost` 7020 `strongdm.models.MongoLegacyHost` 7021 `strongdm.models.MongoLegacyReplicaset` 7022 `strongdm.models.MongoReplicaSet` 7023 `strongdm.models.MongoShardedCluster` 7024 `strongdm.models.MTLSMysql` 7025 `strongdm.models.MTLSPostgres` 7026 `strongdm.models.Mysql` 7027 `strongdm.models.Neptune` 7028 `strongdm.models.NeptuneIAM` 7029 `strongdm.models.OktaGroups` 7030 `strongdm.models.Oracle` 7031 `strongdm.models.OracleNNE` 7032 `strongdm.models.Postgres` 7033 `strongdm.models.Presto` 7034 `strongdm.models.RabbitMQAMQP091` 7035 `strongdm.models.RawTCP` 7036 `strongdm.models.RDP` 7037 `strongdm.models.RDPCert` 7038 `strongdm.models.RDSPostgresIAM` 7039 `strongdm.models.Redis` 7040 `strongdm.models.RedisCluster` 7041 `strongdm.models.Redshift` 7042 `strongdm.models.RedshiftIAM` 7043 `strongdm.models.RedshiftServerlessIAM` 7044 `strongdm.models.SingleStore` 7045 `strongdm.models.Snowflake` 7046 `strongdm.models.Snowsight` 7047 `strongdm.models.SQLServer` 7048 `strongdm.models.SQLServerAzureAD` 7049 `strongdm.models.SQLServerKerberosAD` 7050 `strongdm.models.SSH` 7051 `strongdm.models.SSHCert` 7052 `strongdm.models.SSHCustomerKey` 7053 `strongdm.models.SSHPassword` 7054 `strongdm.models.Sybase` 7055 `strongdm.models.SybaseIQ` 7056 `strongdm.models.Teradata` 7057 `strongdm.models.Trino` 7058 `strongdm.models.Vertica` 7059 ''' 7060 def __init__(self, channel, client): 7061 self.parent = client 7062 self.stub = ResourcesStub(channel) 7063 7064 def enumerate_tags(self, filter, *args, timeout=None): 7065 ''' 7066 EnumerateTags gets a list of the filter matching tags. 7067 ''' 7068 deadline = None if timeout is None else time.time() + timeout 7069 req = EnumerateTagsRequest() 7070 req.meta.CopyFrom(ListRequestMetadata()) 7071 if self.parent.page_limit > 0: 7072 req.meta.limit = self.parent.page_limit 7073 if self.parent.snapshot_datetime is not None: 7074 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7075 7076 req.filter = plumbing.quote_filter_args(filter, *args) 7077 7078 def generator(svc, req): 7079 tries = 0 7080 while True: 7081 t = None if deadline is None else deadline - time.time() 7082 try: 7083 plumbing_response = svc.stub.EnumerateTags( 7084 req, 7085 metadata=svc.parent.get_metadata( 7086 'Resources.EnumerateTags', req), 7087 timeout=t) 7088 except Exception as e: 7089 if self.parent.shouldRetry(tries, e, deadline): 7090 tries += 1 7091 time.sleep( 7092 self.parent.exponentialBackoff(tries, deadline)) 7093 continue 7094 raise plumbing.convert_error_to_porcelain(e) from e 7095 tries = 0 7096 for plumbing_item in plumbing_response.matches: 7097 yield plumbing.convert_tag_to_porcelain(plumbing_item) 7098 if plumbing_response.meta.next_cursor == '': 7099 break 7100 req.meta.cursor = plumbing_response.meta.next_cursor 7101 7102 return generator(self, req) 7103 7104 def create(self, resource, timeout=None): 7105 ''' 7106 Create registers a new Resource. 7107 ''' 7108 deadline = None if timeout is None else time.time() + timeout 7109 req = ResourceCreateRequest() 7110 7111 if resource is not None: 7112 req.resource.CopyFrom( 7113 plumbing.convert_resource_to_plumbing(resource)) 7114 tries = 0 7115 plumbing_response = None 7116 while True: 7117 t = None if deadline is None else deadline - time.time() 7118 try: 7119 plumbing_response = self.stub.Create( 7120 req, 7121 metadata=self.parent.get_metadata('Resources.Create', req), 7122 timeout=t) 7123 except Exception as e: 7124 if self.parent.shouldRetry(tries, e, deadline): 7125 tries += 1 7126 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7127 continue 7128 raise plumbing.convert_error_to_porcelain(e) from e 7129 break 7130 7131 resp = models.ResourceCreateResponse() 7132 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 7133 plumbing_response.meta) 7134 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7135 plumbing_response.rate_limit) 7136 resp.resource = plumbing.convert_resource_to_porcelain( 7137 plumbing_response.resource) 7138 return resp 7139 7140 def get(self, id, timeout=None): 7141 ''' 7142 Get reads one Resource by ID. 7143 ''' 7144 deadline = None if timeout is None else time.time() + timeout 7145 req = ResourceGetRequest() 7146 if self.parent.snapshot_datetime is not None: 7147 req.meta.CopyFrom(GetRequestMetadata()) 7148 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7149 7150 req.id = (id) 7151 tries = 0 7152 plumbing_response = None 7153 while True: 7154 t = None if deadline is None else deadline - time.time() 7155 try: 7156 plumbing_response = self.stub.Get( 7157 req, 7158 metadata=self.parent.get_metadata('Resources.Get', req), 7159 timeout=t) 7160 except Exception as e: 7161 if self.parent.shouldRetry(tries, e, deadline): 7162 tries += 1 7163 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7164 continue 7165 raise plumbing.convert_error_to_porcelain(e) from e 7166 break 7167 7168 resp = models.ResourceGetResponse() 7169 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 7170 plumbing_response.meta) 7171 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7172 plumbing_response.rate_limit) 7173 resp.resource = plumbing.convert_resource_to_porcelain( 7174 plumbing_response.resource) 7175 return resp 7176 7177 def update(self, resource, timeout=None): 7178 ''' 7179 Update replaces all the fields of a Resource by ID. 7180 ''' 7181 deadline = None if timeout is None else time.time() + timeout 7182 req = ResourceUpdateRequest() 7183 7184 if resource is not None: 7185 req.resource.CopyFrom( 7186 plumbing.convert_resource_to_plumbing(resource)) 7187 tries = 0 7188 plumbing_response = None 7189 while True: 7190 t = None if deadline is None else deadline - time.time() 7191 try: 7192 plumbing_response = self.stub.Update( 7193 req, 7194 metadata=self.parent.get_metadata('Resources.Update', req), 7195 timeout=t) 7196 except Exception as e: 7197 if self.parent.shouldRetry(tries, e, deadline): 7198 tries += 1 7199 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7200 continue 7201 raise plumbing.convert_error_to_porcelain(e) from e 7202 break 7203 7204 resp = models.ResourceUpdateResponse() 7205 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 7206 plumbing_response.meta) 7207 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7208 plumbing_response.rate_limit) 7209 resp.resource = plumbing.convert_resource_to_porcelain( 7210 plumbing_response.resource) 7211 return resp 7212 7213 def delete(self, id, timeout=None): 7214 ''' 7215 Delete removes a Resource by ID. 7216 ''' 7217 deadline = None if timeout is None else time.time() + timeout 7218 req = ResourceDeleteRequest() 7219 7220 req.id = (id) 7221 tries = 0 7222 plumbing_response = None 7223 while True: 7224 t = None if deadline is None else deadline - time.time() 7225 try: 7226 plumbing_response = self.stub.Delete( 7227 req, 7228 metadata=self.parent.get_metadata('Resources.Delete', req), 7229 timeout=t) 7230 except Exception as e: 7231 if self.parent.shouldRetry(tries, e, deadline): 7232 tries += 1 7233 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7234 continue 7235 raise plumbing.convert_error_to_porcelain(e) from e 7236 break 7237 7238 resp = models.ResourceDeleteResponse() 7239 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 7240 plumbing_response.meta) 7241 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7242 plumbing_response.rate_limit) 7243 return resp 7244 7245 def list(self, filter, *args, timeout=None): 7246 ''' 7247 List gets a list of Resources matching a given set of criteria. 7248 ''' 7249 deadline = None if timeout is None else time.time() + timeout 7250 req = ResourceListRequest() 7251 req.meta.CopyFrom(ListRequestMetadata()) 7252 if self.parent.page_limit > 0: 7253 req.meta.limit = self.parent.page_limit 7254 if self.parent.snapshot_datetime is not None: 7255 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7256 7257 req.filter = plumbing.quote_filter_args(filter, *args) 7258 7259 def generator(svc, req): 7260 tries = 0 7261 while True: 7262 t = None if deadline is None else deadline - time.time() 7263 try: 7264 plumbing_response = svc.stub.List( 7265 req, 7266 metadata=svc.parent.get_metadata( 7267 'Resources.List', req), 7268 timeout=t) 7269 except Exception as e: 7270 if self.parent.shouldRetry(tries, e, deadline): 7271 tries += 1 7272 time.sleep( 7273 self.parent.exponentialBackoff(tries, deadline)) 7274 continue 7275 raise plumbing.convert_error_to_porcelain(e) from e 7276 tries = 0 7277 for plumbing_item in plumbing_response.resources: 7278 yield plumbing.convert_resource_to_porcelain(plumbing_item) 7279 if plumbing_response.meta.next_cursor == '': 7280 break 7281 req.meta.cursor = plumbing_response.meta.next_cursor 7282 7283 return generator(self, req) 7284 7285 def healthcheck(self, id, timeout=None): 7286 ''' 7287 Healthcheck triggers a remote healthcheck. It may take minutes to propagate across a 7288 large network of Nodes. The call will return immediately, and the updated health of the 7289 Resource can be retrieved via Get or List. 7290 ''' 7291 deadline = None if timeout is None else time.time() + timeout 7292 req = ResourceHealthcheckRequest() 7293 7294 req.id = (id) 7295 tries = 0 7296 plumbing_response = None 7297 while True: 7298 t = None if deadline is None else deadline - time.time() 7299 try: 7300 plumbing_response = self.stub.Healthcheck( 7301 req, 7302 metadata=self.parent.get_metadata('Resources.Healthcheck', 7303 req), 7304 timeout=t) 7305 except Exception as e: 7306 if self.parent.shouldRetry(tries, e, deadline): 7307 tries += 1 7308 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7309 continue 7310 raise plumbing.convert_error_to_porcelain(e) from e 7311 break 7312 7313 resp = models.ResourceHealthcheckResponse() 7314 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 7315 plumbing_response.meta) 7316 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7317 plumbing_response.rate_limit) 7318 return resp
Resources are databases, servers, clusters, websites, or clouds that strongDM
delegates access to.
See:
strongdm.models.Aerospike
strongdm.models.AKS
strongdm.models.AKSBasicAuth
strongdm.models.AKSServiceAccount
strongdm.models.AKSServiceAccountUserImpersonation
strongdm.models.AKSUserImpersonation
strongdm.models.AmazonEKS
strongdm.models.AmazonEKSInstanceProfile
strongdm.models.AmazonEKSInstanceProfileUserImpersonation
strongdm.models.AmazonEKSUserImpersonation
strongdm.models.AmazonES
strongdm.models.AmazonESIAM
strongdm.models.AmazonMQAMQP091
strongdm.models.AMQP
strongdm.models.Athena
strongdm.models.AthenaIAM
strongdm.models.AuroraMysql
strongdm.models.AuroraMysqlIAM
strongdm.models.AuroraPostgres
strongdm.models.AuroraPostgresIAM
strongdm.models.AWS
strongdm.models.AWSConsole
strongdm.models.AWSConsoleStaticKeyPair
strongdm.models.AWSInstanceProfile
strongdm.models.Azure
strongdm.models.AzureCertificate
strongdm.models.AzureMysql
strongdm.models.AzureMysqlManagedIdentity
strongdm.models.AzurePostgres
strongdm.models.AzurePostgresManagedIdentity
strongdm.models.BigQuery
strongdm.models.Cassandra
strongdm.models.Citus
strongdm.models.ClickHouseHTTP
strongdm.models.ClickHouseMySQL
strongdm.models.ClickHouseTCP
strongdm.models.Clustrix
strongdm.models.Cockroach
strongdm.models.CouchbaseDatabase
strongdm.models.CouchbaseWebUI
strongdm.models.Databricks
strongdm.models.DB2I
strongdm.models.DB2LUW
strongdm.models.DocumentDBHost
strongdm.models.DocumentDBHostIAM
strongdm.models.DocumentDBReplicaSet
strongdm.models.DocumentDBReplicaSetIAM
strongdm.models.Druid
strongdm.models.DynamoDB
strongdm.models.DynamoDBIAM
strongdm.models.Elastic
strongdm.models.ElasticacheRedis
strongdm.models.ElasticacheRedisIAM
strongdm.models.EntraID
strongdm.models.GCP
strongdm.models.GCPConsole
strongdm.models.GCPWIF
strongdm.models.GoogleGKE
strongdm.models.GoogleGKEUserImpersonation
strongdm.models.GoogleGroups
strongdm.models.GoogleSpanner
strongdm.models.Greenplum
strongdm.models.HTTPAuth
strongdm.models.HTTPBasicAuth
strongdm.models.HTTPNoAuth
strongdm.models.Kubernetes
strongdm.models.KubernetesBasicAuth
strongdm.models.KubernetesPodIdentity
strongdm.models.KubernetesServiceAccount
strongdm.models.KubernetesServiceAccountUserImpersonation
strongdm.models.KubernetesUserImpersonation
strongdm.models.LLM
strongdm.models.Maria
strongdm.models.MCPGatewayNoAuth
strongdm.models.MCPGatewayOAuth
strongdm.models.MCPGatewayOAuthDCR
strongdm.models.MCPGatewayPAT
strongdm.models.Memcached
strongdm.models.Memsql
strongdm.models.MongoHost
strongdm.models.MongoLegacyHost
strongdm.models.MongoLegacyReplicaset
strongdm.models.MongoReplicaSet
strongdm.models.MongoShardedCluster
strongdm.models.MTLSMysql
strongdm.models.MTLSPostgres
strongdm.models.Mysql
strongdm.models.Neptune
strongdm.models.NeptuneIAM
strongdm.models.OktaGroups
strongdm.models.Oracle
strongdm.models.OracleNNE
strongdm.models.Postgres
strongdm.models.Presto
strongdm.models.RabbitMQAMQP091
strongdm.models.RawTCP
strongdm.models.RDP
strongdm.models.RDPCert
strongdm.models.RDSPostgresIAM
strongdm.models.Redis
strongdm.models.RedisCluster
strongdm.models.Redshift
strongdm.models.RedshiftIAM
strongdm.models.RedshiftServerlessIAM
strongdm.models.SingleStore
strongdm.models.Snowflake
strongdm.models.Snowsight
strongdm.models.SQLServer
strongdm.models.SQLServerAzureAD
strongdm.models.SQLServerKerberosAD
strongdm.models.SSH
strongdm.models.SSHCert
strongdm.models.SSHCustomerKey
strongdm.models.SSHPassword
strongdm.models.Sybase
strongdm.models.SybaseIQ
strongdm.models.Teradata
strongdm.models.Trino
strongdm.models.Vertica
def
create(self, resource, timeout=None)
7104 def create(self, resource, timeout=None): 7105 ''' 7106 Create registers a new Resource. 7107 ''' 7108 deadline = None if timeout is None else time.time() + timeout 7109 req = ResourceCreateRequest() 7110 7111 if resource is not None: 7112 req.resource.CopyFrom( 7113 plumbing.convert_resource_to_plumbing(resource)) 7114 tries = 0 7115 plumbing_response = None 7116 while True: 7117 t = None if deadline is None else deadline - time.time() 7118 try: 7119 plumbing_response = self.stub.Create( 7120 req, 7121 metadata=self.parent.get_metadata('Resources.Create', req), 7122 timeout=t) 7123 except Exception as e: 7124 if self.parent.shouldRetry(tries, e, deadline): 7125 tries += 1 7126 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7127 continue 7128 raise plumbing.convert_error_to_porcelain(e) from e 7129 break 7130 7131 resp = models.ResourceCreateResponse() 7132 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 7133 plumbing_response.meta) 7134 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7135 plumbing_response.rate_limit) 7136 resp.resource = plumbing.convert_resource_to_porcelain( 7137 plumbing_response.resource) 7138 return resp
Create registers a new Resource.
def
get(self, id, timeout=None)
7140 def get(self, id, timeout=None): 7141 ''' 7142 Get reads one Resource by ID. 7143 ''' 7144 deadline = None if timeout is None else time.time() + timeout 7145 req = ResourceGetRequest() 7146 if self.parent.snapshot_datetime is not None: 7147 req.meta.CopyFrom(GetRequestMetadata()) 7148 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7149 7150 req.id = (id) 7151 tries = 0 7152 plumbing_response = None 7153 while True: 7154 t = None if deadline is None else deadline - time.time() 7155 try: 7156 plumbing_response = self.stub.Get( 7157 req, 7158 metadata=self.parent.get_metadata('Resources.Get', req), 7159 timeout=t) 7160 except Exception as e: 7161 if self.parent.shouldRetry(tries, e, deadline): 7162 tries += 1 7163 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7164 continue 7165 raise plumbing.convert_error_to_porcelain(e) from e 7166 break 7167 7168 resp = models.ResourceGetResponse() 7169 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 7170 plumbing_response.meta) 7171 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7172 plumbing_response.rate_limit) 7173 resp.resource = plumbing.convert_resource_to_porcelain( 7174 plumbing_response.resource) 7175 return resp
Get reads one Resource by ID.
def
update(self, resource, timeout=None)
7177 def update(self, resource, timeout=None): 7178 ''' 7179 Update replaces all the fields of a Resource by ID. 7180 ''' 7181 deadline = None if timeout is None else time.time() + timeout 7182 req = ResourceUpdateRequest() 7183 7184 if resource is not None: 7185 req.resource.CopyFrom( 7186 plumbing.convert_resource_to_plumbing(resource)) 7187 tries = 0 7188 plumbing_response = None 7189 while True: 7190 t = None if deadline is None else deadline - time.time() 7191 try: 7192 plumbing_response = self.stub.Update( 7193 req, 7194 metadata=self.parent.get_metadata('Resources.Update', req), 7195 timeout=t) 7196 except Exception as e: 7197 if self.parent.shouldRetry(tries, e, deadline): 7198 tries += 1 7199 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7200 continue 7201 raise plumbing.convert_error_to_porcelain(e) from e 7202 break 7203 7204 resp = models.ResourceUpdateResponse() 7205 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 7206 plumbing_response.meta) 7207 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7208 plumbing_response.rate_limit) 7209 resp.resource = plumbing.convert_resource_to_porcelain( 7210 plumbing_response.resource) 7211 return resp
Update replaces all the fields of a Resource by ID.
def
delete(self, id, timeout=None)
7213 def delete(self, id, timeout=None): 7214 ''' 7215 Delete removes a Resource by ID. 7216 ''' 7217 deadline = None if timeout is None else time.time() + timeout 7218 req = ResourceDeleteRequest() 7219 7220 req.id = (id) 7221 tries = 0 7222 plumbing_response = None 7223 while True: 7224 t = None if deadline is None else deadline - time.time() 7225 try: 7226 plumbing_response = self.stub.Delete( 7227 req, 7228 metadata=self.parent.get_metadata('Resources.Delete', req), 7229 timeout=t) 7230 except Exception as e: 7231 if self.parent.shouldRetry(tries, e, deadline): 7232 tries += 1 7233 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7234 continue 7235 raise plumbing.convert_error_to_porcelain(e) from e 7236 break 7237 7238 resp = models.ResourceDeleteResponse() 7239 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 7240 plumbing_response.meta) 7241 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7242 plumbing_response.rate_limit) 7243 return resp
Delete removes a Resource by ID.
def
list(self, filter, *args, timeout=None)
7245 def list(self, filter, *args, timeout=None): 7246 ''' 7247 List gets a list of Resources matching a given set of criteria. 7248 ''' 7249 deadline = None if timeout is None else time.time() + timeout 7250 req = ResourceListRequest() 7251 req.meta.CopyFrom(ListRequestMetadata()) 7252 if self.parent.page_limit > 0: 7253 req.meta.limit = self.parent.page_limit 7254 if self.parent.snapshot_datetime is not None: 7255 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7256 7257 req.filter = plumbing.quote_filter_args(filter, *args) 7258 7259 def generator(svc, req): 7260 tries = 0 7261 while True: 7262 t = None if deadline is None else deadline - time.time() 7263 try: 7264 plumbing_response = svc.stub.List( 7265 req, 7266 metadata=svc.parent.get_metadata( 7267 'Resources.List', req), 7268 timeout=t) 7269 except Exception as e: 7270 if self.parent.shouldRetry(tries, e, deadline): 7271 tries += 1 7272 time.sleep( 7273 self.parent.exponentialBackoff(tries, deadline)) 7274 continue 7275 raise plumbing.convert_error_to_porcelain(e) from e 7276 tries = 0 7277 for plumbing_item in plumbing_response.resources: 7278 yield plumbing.convert_resource_to_porcelain(plumbing_item) 7279 if plumbing_response.meta.next_cursor == '': 7280 break 7281 req.meta.cursor = plumbing_response.meta.next_cursor 7282 7283 return generator(self, req)
List gets a list of Resources matching a given set of criteria.
def
healthcheck(self, id, timeout=None)
7285 def healthcheck(self, id, timeout=None): 7286 ''' 7287 Healthcheck triggers a remote healthcheck. It may take minutes to propagate across a 7288 large network of Nodes. The call will return immediately, and the updated health of the 7289 Resource can be retrieved via Get or List. 7290 ''' 7291 deadline = None if timeout is None else time.time() + timeout 7292 req = ResourceHealthcheckRequest() 7293 7294 req.id = (id) 7295 tries = 0 7296 plumbing_response = None 7297 while True: 7298 t = None if deadline is None else deadline - time.time() 7299 try: 7300 plumbing_response = self.stub.Healthcheck( 7301 req, 7302 metadata=self.parent.get_metadata('Resources.Healthcheck', 7303 req), 7304 timeout=t) 7305 except Exception as e: 7306 if self.parent.shouldRetry(tries, e, deadline): 7307 tries += 1 7308 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7309 continue 7310 raise plumbing.convert_error_to_porcelain(e) from e 7311 break 7312 7313 resp = models.ResourceHealthcheckResponse() 7314 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 7315 plumbing_response.meta) 7316 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7317 plumbing_response.rate_limit) 7318 return resp
Healthcheck triggers a remote healthcheck. It may take minutes to propagate across a large network of Nodes. The call will return immediately, and the updated health of the Resource can be retrieved via Get or List.
class
SnapshotResources:
7321class SnapshotResources: 7322 ''' 7323 SnapshotResources exposes the read only methods of the Resources 7324 service for historical queries. 7325 ''' 7326 def __init__(self, resources): 7327 self.resources = resources 7328 7329 def get(self, id, timeout=None): 7330 ''' 7331 Get reads one Resource by ID. 7332 ''' 7333 return self.resources.get(id, timeout=timeout) 7334 7335 def list(self, filter, *args, timeout=None): 7336 ''' 7337 List gets a list of Resources matching a given set of criteria. 7338 ''' 7339 return self.resources.list(filter, *args, timeout=timeout)
SnapshotResources exposes the read only methods of the Resources service for historical queries.
def
get(self, id, timeout=None)
7329 def get(self, id, timeout=None): 7330 ''' 7331 Get reads one Resource by ID. 7332 ''' 7333 return self.resources.get(id, timeout=timeout)
Get reads one Resource by ID.
def
list(self, filter, *args, timeout=None)
7335 def list(self, filter, *args, timeout=None): 7336 ''' 7337 List gets a list of Resources matching a given set of criteria. 7338 ''' 7339 return self.resources.list(filter, *args, timeout=timeout)
List gets a list of Resources matching a given set of criteria.
class
ResourcesHistory:
7342class ResourcesHistory: 7343 ''' 7344 ResourcesHistory records all changes to the state of a Resource. 7345 See `strongdm.models.ResourceHistory`. 7346 ''' 7347 def __init__(self, channel, client): 7348 self.parent = client 7349 self.stub = ResourcesHistoryStub(channel) 7350 7351 def list(self, filter, *args, timeout=None): 7352 ''' 7353 List gets a list of ResourceHistory records matching a given set of criteria. 7354 ''' 7355 deadline = None if timeout is None else time.time() + timeout 7356 req = ResourceHistoryListRequest() 7357 req.meta.CopyFrom(ListRequestMetadata()) 7358 if self.parent.page_limit > 0: 7359 req.meta.limit = self.parent.page_limit 7360 if self.parent.snapshot_datetime is not None: 7361 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7362 7363 req.filter = plumbing.quote_filter_args(filter, *args) 7364 7365 def generator(svc, req): 7366 tries = 0 7367 while True: 7368 t = None if deadline is None else deadline - time.time() 7369 try: 7370 plumbing_response = svc.stub.List( 7371 req, 7372 metadata=svc.parent.get_metadata( 7373 'ResourcesHistory.List', req), 7374 timeout=t) 7375 except Exception as e: 7376 if self.parent.shouldRetry(tries, e, deadline): 7377 tries += 1 7378 time.sleep( 7379 self.parent.exponentialBackoff(tries, deadline)) 7380 continue 7381 raise plumbing.convert_error_to_porcelain(e) from e 7382 tries = 0 7383 for plumbing_item in plumbing_response.history: 7384 yield plumbing.convert_resource_history_to_porcelain( 7385 plumbing_item) 7386 if plumbing_response.meta.next_cursor == '': 7387 break 7388 req.meta.cursor = plumbing_response.meta.next_cursor 7389 7390 return generator(self, req)
ResourcesHistory records all changes to the state of a Resource.
See strongdm.models.ResourceHistory.
def
list(self, filter, *args, timeout=None)
7351 def list(self, filter, *args, timeout=None): 7352 ''' 7353 List gets a list of ResourceHistory records matching a given set of criteria. 7354 ''' 7355 deadline = None if timeout is None else time.time() + timeout 7356 req = ResourceHistoryListRequest() 7357 req.meta.CopyFrom(ListRequestMetadata()) 7358 if self.parent.page_limit > 0: 7359 req.meta.limit = self.parent.page_limit 7360 if self.parent.snapshot_datetime is not None: 7361 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7362 7363 req.filter = plumbing.quote_filter_args(filter, *args) 7364 7365 def generator(svc, req): 7366 tries = 0 7367 while True: 7368 t = None if deadline is None else deadline - time.time() 7369 try: 7370 plumbing_response = svc.stub.List( 7371 req, 7372 metadata=svc.parent.get_metadata( 7373 'ResourcesHistory.List', req), 7374 timeout=t) 7375 except Exception as e: 7376 if self.parent.shouldRetry(tries, e, deadline): 7377 tries += 1 7378 time.sleep( 7379 self.parent.exponentialBackoff(tries, deadline)) 7380 continue 7381 raise plumbing.convert_error_to_porcelain(e) from e 7382 tries = 0 7383 for plumbing_item in plumbing_response.history: 7384 yield plumbing.convert_resource_history_to_porcelain( 7385 plumbing_item) 7386 if plumbing_response.meta.next_cursor == '': 7387 break 7388 req.meta.cursor = plumbing_response.meta.next_cursor 7389 7390 return generator(self, req)
List gets a list of ResourceHistory records matching a given set of criteria.
class
RoleResources:
7393class RoleResources: 7394 ''' 7395 RoleResources enumerates the resources to which roles have access. 7396 The RoleResources service is read-only. 7397 See `strongdm.models.RoleResource`. 7398 ''' 7399 def __init__(self, channel, client): 7400 self.parent = client 7401 self.stub = RoleResourcesStub(channel) 7402 7403 def list(self, filter, *args, timeout=None): 7404 ''' 7405 List gets a list of RoleResource records matching a given set of criteria. 7406 ''' 7407 deadline = None if timeout is None else time.time() + timeout 7408 req = RoleResourceListRequest() 7409 req.meta.CopyFrom(ListRequestMetadata()) 7410 if self.parent.page_limit > 0: 7411 req.meta.limit = self.parent.page_limit 7412 if self.parent.snapshot_datetime is not None: 7413 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7414 7415 req.filter = plumbing.quote_filter_args(filter, *args) 7416 7417 def generator(svc, req): 7418 tries = 0 7419 while True: 7420 t = None if deadline is None else deadline - time.time() 7421 try: 7422 plumbing_response = svc.stub.List( 7423 req, 7424 metadata=svc.parent.get_metadata( 7425 'RoleResources.List', req), 7426 timeout=t) 7427 except Exception as e: 7428 if self.parent.shouldRetry(tries, e, deadline): 7429 tries += 1 7430 time.sleep( 7431 self.parent.exponentialBackoff(tries, deadline)) 7432 continue 7433 raise plumbing.convert_error_to_porcelain(e) from e 7434 tries = 0 7435 for plumbing_item in plumbing_response.role_resources: 7436 yield plumbing.convert_role_resource_to_porcelain( 7437 plumbing_item) 7438 if plumbing_response.meta.next_cursor == '': 7439 break 7440 req.meta.cursor = plumbing_response.meta.next_cursor 7441 7442 return generator(self, req)
RoleResources enumerates the resources to which roles have access.
The RoleResources service is read-only.
See strongdm.models.RoleResource.
def
list(self, filter, *args, timeout=None)
7403 def list(self, filter, *args, timeout=None): 7404 ''' 7405 List gets a list of RoleResource records matching a given set of criteria. 7406 ''' 7407 deadline = None if timeout is None else time.time() + timeout 7408 req = RoleResourceListRequest() 7409 req.meta.CopyFrom(ListRequestMetadata()) 7410 if self.parent.page_limit > 0: 7411 req.meta.limit = self.parent.page_limit 7412 if self.parent.snapshot_datetime is not None: 7413 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7414 7415 req.filter = plumbing.quote_filter_args(filter, *args) 7416 7417 def generator(svc, req): 7418 tries = 0 7419 while True: 7420 t = None if deadline is None else deadline - time.time() 7421 try: 7422 plumbing_response = svc.stub.List( 7423 req, 7424 metadata=svc.parent.get_metadata( 7425 'RoleResources.List', req), 7426 timeout=t) 7427 except Exception as e: 7428 if self.parent.shouldRetry(tries, e, deadline): 7429 tries += 1 7430 time.sleep( 7431 self.parent.exponentialBackoff(tries, deadline)) 7432 continue 7433 raise plumbing.convert_error_to_porcelain(e) from e 7434 tries = 0 7435 for plumbing_item in plumbing_response.role_resources: 7436 yield plumbing.convert_role_resource_to_porcelain( 7437 plumbing_item) 7438 if plumbing_response.meta.next_cursor == '': 7439 break 7440 req.meta.cursor = plumbing_response.meta.next_cursor 7441 7442 return generator(self, req)
List gets a list of RoleResource records matching a given set of criteria.
class
SnapshotRoleResources:
7445class SnapshotRoleResources: 7446 ''' 7447 SnapshotRoleResources exposes the read only methods of the RoleResources 7448 service for historical queries. 7449 ''' 7450 def __init__(self, role_resources): 7451 self.role_resources = role_resources 7452 7453 def list(self, filter, *args, timeout=None): 7454 ''' 7455 List gets a list of RoleResource records matching a given set of criteria. 7456 ''' 7457 return self.role_resources.list(filter, *args, timeout=timeout)
SnapshotRoleResources exposes the read only methods of the RoleResources service for historical queries.
def
list(self, filter, *args, timeout=None)
7453 def list(self, filter, *args, timeout=None): 7454 ''' 7455 List gets a list of RoleResource records matching a given set of criteria. 7456 ''' 7457 return self.role_resources.list(filter, *args, timeout=timeout)
List gets a list of RoleResource records matching a given set of criteria.
class
RoleResourcesHistory:
7460class RoleResourcesHistory: 7461 ''' 7462 RoleResourcesHistory records all changes to the state of a RoleResource. 7463 See `strongdm.models.RoleResourceHistory`. 7464 ''' 7465 def __init__(self, channel, client): 7466 self.parent = client 7467 self.stub = RoleResourcesHistoryStub(channel) 7468 7469 def list(self, filter, *args, timeout=None): 7470 ''' 7471 List gets a list of RoleResourceHistory records matching a given set of criteria. 7472 ''' 7473 deadline = None if timeout is None else time.time() + timeout 7474 req = RoleResourceHistoryListRequest() 7475 req.meta.CopyFrom(ListRequestMetadata()) 7476 if self.parent.page_limit > 0: 7477 req.meta.limit = self.parent.page_limit 7478 if self.parent.snapshot_datetime is not None: 7479 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7480 7481 req.filter = plumbing.quote_filter_args(filter, *args) 7482 7483 def generator(svc, req): 7484 tries = 0 7485 while True: 7486 t = None if deadline is None else deadline - time.time() 7487 try: 7488 plumbing_response = svc.stub.List( 7489 req, 7490 metadata=svc.parent.get_metadata( 7491 'RoleResourcesHistory.List', req), 7492 timeout=t) 7493 except Exception as e: 7494 if self.parent.shouldRetry(tries, e, deadline): 7495 tries += 1 7496 time.sleep( 7497 self.parent.exponentialBackoff(tries, deadline)) 7498 continue 7499 raise plumbing.convert_error_to_porcelain(e) from e 7500 tries = 0 7501 for plumbing_item in plumbing_response.history: 7502 yield plumbing.convert_role_resource_history_to_porcelain( 7503 plumbing_item) 7504 if plumbing_response.meta.next_cursor == '': 7505 break 7506 req.meta.cursor = plumbing_response.meta.next_cursor 7507 7508 return generator(self, req)
RoleResourcesHistory records all changes to the state of a RoleResource.
See strongdm.models.RoleResourceHistory.
def
list(self, filter, *args, timeout=None)
7469 def list(self, filter, *args, timeout=None): 7470 ''' 7471 List gets a list of RoleResourceHistory records matching a given set of criteria. 7472 ''' 7473 deadline = None if timeout is None else time.time() + timeout 7474 req = RoleResourceHistoryListRequest() 7475 req.meta.CopyFrom(ListRequestMetadata()) 7476 if self.parent.page_limit > 0: 7477 req.meta.limit = self.parent.page_limit 7478 if self.parent.snapshot_datetime is not None: 7479 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7480 7481 req.filter = plumbing.quote_filter_args(filter, *args) 7482 7483 def generator(svc, req): 7484 tries = 0 7485 while True: 7486 t = None if deadline is None else deadline - time.time() 7487 try: 7488 plumbing_response = svc.stub.List( 7489 req, 7490 metadata=svc.parent.get_metadata( 7491 'RoleResourcesHistory.List', req), 7492 timeout=t) 7493 except Exception as e: 7494 if self.parent.shouldRetry(tries, e, deadline): 7495 tries += 1 7496 time.sleep( 7497 self.parent.exponentialBackoff(tries, deadline)) 7498 continue 7499 raise plumbing.convert_error_to_porcelain(e) from e 7500 tries = 0 7501 for plumbing_item in plumbing_response.history: 7502 yield plumbing.convert_role_resource_history_to_porcelain( 7503 plumbing_item) 7504 if plumbing_response.meta.next_cursor == '': 7505 break 7506 req.meta.cursor = plumbing_response.meta.next_cursor 7507 7508 return generator(self, req)
List gets a list of RoleResourceHistory records matching a given set of criteria.
class
RolesHistory:
7511class RolesHistory: 7512 ''' 7513 RolesHistory records all changes to the state of a Role. 7514 See `strongdm.models.RoleHistory`. 7515 ''' 7516 def __init__(self, channel, client): 7517 self.parent = client 7518 self.stub = RolesHistoryStub(channel) 7519 7520 def list(self, filter, *args, timeout=None): 7521 ''' 7522 List gets a list of RoleHistory records matching a given set of criteria. 7523 ''' 7524 deadline = None if timeout is None else time.time() + timeout 7525 req = RoleHistoryListRequest() 7526 req.meta.CopyFrom(ListRequestMetadata()) 7527 if self.parent.page_limit > 0: 7528 req.meta.limit = self.parent.page_limit 7529 if self.parent.snapshot_datetime is not None: 7530 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7531 7532 req.filter = plumbing.quote_filter_args(filter, *args) 7533 7534 def generator(svc, req): 7535 tries = 0 7536 while True: 7537 t = None if deadline is None else deadline - time.time() 7538 try: 7539 plumbing_response = svc.stub.List( 7540 req, 7541 metadata=svc.parent.get_metadata( 7542 'RolesHistory.List', req), 7543 timeout=t) 7544 except Exception as e: 7545 if self.parent.shouldRetry(tries, e, deadline): 7546 tries += 1 7547 time.sleep( 7548 self.parent.exponentialBackoff(tries, deadline)) 7549 continue 7550 raise plumbing.convert_error_to_porcelain(e) from e 7551 tries = 0 7552 for plumbing_item in plumbing_response.history: 7553 yield plumbing.convert_role_history_to_porcelain( 7554 plumbing_item) 7555 if plumbing_response.meta.next_cursor == '': 7556 break 7557 req.meta.cursor = plumbing_response.meta.next_cursor 7558 7559 return generator(self, req)
RolesHistory records all changes to the state of a Role.
See strongdm.models.RoleHistory.
def
list(self, filter, *args, timeout=None)
7520 def list(self, filter, *args, timeout=None): 7521 ''' 7522 List gets a list of RoleHistory records matching a given set of criteria. 7523 ''' 7524 deadline = None if timeout is None else time.time() + timeout 7525 req = RoleHistoryListRequest() 7526 req.meta.CopyFrom(ListRequestMetadata()) 7527 if self.parent.page_limit > 0: 7528 req.meta.limit = self.parent.page_limit 7529 if self.parent.snapshot_datetime is not None: 7530 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7531 7532 req.filter = plumbing.quote_filter_args(filter, *args) 7533 7534 def generator(svc, req): 7535 tries = 0 7536 while True: 7537 t = None if deadline is None else deadline - time.time() 7538 try: 7539 plumbing_response = svc.stub.List( 7540 req, 7541 metadata=svc.parent.get_metadata( 7542 'RolesHistory.List', req), 7543 timeout=t) 7544 except Exception as e: 7545 if self.parent.shouldRetry(tries, e, deadline): 7546 tries += 1 7547 time.sleep( 7548 self.parent.exponentialBackoff(tries, deadline)) 7549 continue 7550 raise plumbing.convert_error_to_porcelain(e) from e 7551 tries = 0 7552 for plumbing_item in plumbing_response.history: 7553 yield plumbing.convert_role_history_to_porcelain( 7554 plumbing_item) 7555 if plumbing_response.meta.next_cursor == '': 7556 break 7557 req.meta.cursor = plumbing_response.meta.next_cursor 7558 7559 return generator(self, req)
List gets a list of RoleHistory records matching a given set of criteria.
class
SecretStores:
7562class SecretStores: 7563 ''' 7564 SecretStores are servers where resource secrets (passwords, keys) are stored. 7565 See: 7566 `strongdm.models.ActiveDirectoryStore` 7567 `strongdm.models.AWSStore` 7568 `strongdm.models.AWSCertX509Store` 7569 `strongdm.models.AzureStore` 7570 `strongdm.models.CyberarkConjurStore` 7571 `strongdm.models.CyberarkPAMStore` 7572 `strongdm.models.CyberarkPAMExperimentalStore` 7573 `strongdm.models.DelineaStore` 7574 `strongdm.models.DelineaDSVStore` 7575 `strongdm.models.GCPStore` 7576 `strongdm.models.GCPCertX509Store` 7577 `strongdm.models.KeyfactorSSHStore` 7578 `strongdm.models.KeyfactorX509Store` 7579 `strongdm.models.StrongVaultStore` 7580 `strongdm.models.VaultAppRoleStore` 7581 `strongdm.models.VaultAppRoleCertSSHStore` 7582 `strongdm.models.VaultAppRoleCertX509Store` 7583 `strongdm.models.VaultAWSEC2Store` 7584 `strongdm.models.VaultAWSEC2CertSSHStore` 7585 `strongdm.models.VaultAWSEC2CertX509Store` 7586 `strongdm.models.VaultAWSIAMStore` 7587 `strongdm.models.VaultAWSIAMCertSSHStore` 7588 `strongdm.models.VaultAWSIAMCertX509Store` 7589 `strongdm.models.VaultTLSStore` 7590 `strongdm.models.VaultTLSCertSSHStore` 7591 `strongdm.models.VaultTLSCertX509Store` 7592 `strongdm.models.VaultTokenStore` 7593 `strongdm.models.VaultTokenCertSSHStore` 7594 `strongdm.models.VaultTokenCertX509Store` 7595 ''' 7596 def __init__(self, channel, client): 7597 self.parent = client 7598 self.stub = SecretStoresStub(channel) 7599 7600 def create(self, secret_store, timeout=None): 7601 deadline = None if timeout is None else time.time() + timeout 7602 req = SecretStoreCreateRequest() 7603 7604 if secret_store is not None: 7605 req.secret_store.CopyFrom( 7606 plumbing.convert_secret_store_to_plumbing(secret_store)) 7607 tries = 0 7608 plumbing_response = None 7609 while True: 7610 t = None if deadline is None else deadline - time.time() 7611 try: 7612 plumbing_response = self.stub.Create( 7613 req, 7614 metadata=self.parent.get_metadata('SecretStores.Create', 7615 req), 7616 timeout=t) 7617 except Exception as e: 7618 if self.parent.shouldRetry(tries, e, deadline): 7619 tries += 1 7620 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7621 continue 7622 raise plumbing.convert_error_to_porcelain(e) from e 7623 break 7624 7625 resp = models.SecretStoreCreateResponse() 7626 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 7627 plumbing_response.meta) 7628 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7629 plumbing_response.rate_limit) 7630 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 7631 plumbing_response.secret_store) 7632 return resp 7633 7634 def get(self, id, timeout=None): 7635 ''' 7636 Get reads one SecretStore by ID. 7637 ''' 7638 deadline = None if timeout is None else time.time() + timeout 7639 req = SecretStoreGetRequest() 7640 if self.parent.snapshot_datetime is not None: 7641 req.meta.CopyFrom(GetRequestMetadata()) 7642 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7643 7644 req.id = (id) 7645 tries = 0 7646 plumbing_response = None 7647 while True: 7648 t = None if deadline is None else deadline - time.time() 7649 try: 7650 plumbing_response = self.stub.Get( 7651 req, 7652 metadata=self.parent.get_metadata('SecretStores.Get', req), 7653 timeout=t) 7654 except Exception as e: 7655 if self.parent.shouldRetry(tries, e, deadline): 7656 tries += 1 7657 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7658 continue 7659 raise plumbing.convert_error_to_porcelain(e) from e 7660 break 7661 7662 resp = models.SecretStoreGetResponse() 7663 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 7664 plumbing_response.meta) 7665 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7666 plumbing_response.rate_limit) 7667 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 7668 plumbing_response.secret_store) 7669 return resp 7670 7671 def update(self, secret_store, timeout=None): 7672 ''' 7673 Update replaces all the fields of a SecretStore by ID. 7674 ''' 7675 deadline = None if timeout is None else time.time() + timeout 7676 req = SecretStoreUpdateRequest() 7677 7678 if secret_store is not None: 7679 req.secret_store.CopyFrom( 7680 plumbing.convert_secret_store_to_plumbing(secret_store)) 7681 tries = 0 7682 plumbing_response = None 7683 while True: 7684 t = None if deadline is None else deadline - time.time() 7685 try: 7686 plumbing_response = self.stub.Update( 7687 req, 7688 metadata=self.parent.get_metadata('SecretStores.Update', 7689 req), 7690 timeout=t) 7691 except Exception as e: 7692 if self.parent.shouldRetry(tries, e, deadline): 7693 tries += 1 7694 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7695 continue 7696 raise plumbing.convert_error_to_porcelain(e) from e 7697 break 7698 7699 resp = models.SecretStoreUpdateResponse() 7700 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 7701 plumbing_response.meta) 7702 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7703 plumbing_response.rate_limit) 7704 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 7705 plumbing_response.secret_store) 7706 return resp 7707 7708 def delete(self, id, timeout=None): 7709 ''' 7710 Delete removes a SecretStore by ID. 7711 ''' 7712 deadline = None if timeout is None else time.time() + timeout 7713 req = SecretStoreDeleteRequest() 7714 7715 req.id = (id) 7716 tries = 0 7717 plumbing_response = None 7718 while True: 7719 t = None if deadline is None else deadline - time.time() 7720 try: 7721 plumbing_response = self.stub.Delete( 7722 req, 7723 metadata=self.parent.get_metadata('SecretStores.Delete', 7724 req), 7725 timeout=t) 7726 except Exception as e: 7727 if self.parent.shouldRetry(tries, e, deadline): 7728 tries += 1 7729 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7730 continue 7731 raise plumbing.convert_error_to_porcelain(e) from e 7732 break 7733 7734 resp = models.SecretStoreDeleteResponse() 7735 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 7736 plumbing_response.meta) 7737 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7738 plumbing_response.rate_limit) 7739 return resp 7740 7741 def list(self, filter, *args, timeout=None): 7742 ''' 7743 List gets a list of SecretStores matching a given set of criteria. 7744 ''' 7745 deadline = None if timeout is None else time.time() + timeout 7746 req = SecretStoreListRequest() 7747 req.meta.CopyFrom(ListRequestMetadata()) 7748 if self.parent.page_limit > 0: 7749 req.meta.limit = self.parent.page_limit 7750 if self.parent.snapshot_datetime is not None: 7751 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7752 7753 req.filter = plumbing.quote_filter_args(filter, *args) 7754 7755 def generator(svc, req): 7756 tries = 0 7757 while True: 7758 t = None if deadline is None else deadline - time.time() 7759 try: 7760 plumbing_response = svc.stub.List( 7761 req, 7762 metadata=svc.parent.get_metadata( 7763 'SecretStores.List', req), 7764 timeout=t) 7765 except Exception as e: 7766 if self.parent.shouldRetry(tries, e, deadline): 7767 tries += 1 7768 time.sleep( 7769 self.parent.exponentialBackoff(tries, deadline)) 7770 continue 7771 raise plumbing.convert_error_to_porcelain(e) from e 7772 tries = 0 7773 for plumbing_item in plumbing_response.secret_stores: 7774 yield plumbing.convert_secret_store_to_porcelain( 7775 plumbing_item) 7776 if plumbing_response.meta.next_cursor == '': 7777 break 7778 req.meta.cursor = plumbing_response.meta.next_cursor 7779 7780 return generator(self, req)
SecretStores are servers where resource secrets (passwords, keys) are stored.
See:
strongdm.models.ActiveDirectoryStore
strongdm.models.AWSStore
strongdm.models.AWSCertX509Store
strongdm.models.AzureStore
strongdm.models.CyberarkConjurStore
strongdm.models.CyberarkPAMStore
strongdm.models.CyberarkPAMExperimentalStore
strongdm.models.DelineaStore
strongdm.models.DelineaDSVStore
strongdm.models.GCPStore
strongdm.models.GCPCertX509Store
strongdm.models.KeyfactorSSHStore
strongdm.models.KeyfactorX509Store
strongdm.models.StrongVaultStore
strongdm.models.VaultAppRoleStore
strongdm.models.VaultAppRoleCertSSHStore
strongdm.models.VaultAppRoleCertX509Store
strongdm.models.VaultAWSEC2Store
strongdm.models.VaultAWSEC2CertSSHStore
strongdm.models.VaultAWSEC2CertX509Store
strongdm.models.VaultAWSIAMStore
strongdm.models.VaultAWSIAMCertSSHStore
strongdm.models.VaultAWSIAMCertX509Store
strongdm.models.VaultTLSStore
strongdm.models.VaultTLSCertSSHStore
strongdm.models.VaultTLSCertX509Store
strongdm.models.VaultTokenStore
strongdm.models.VaultTokenCertSSHStore
strongdm.models.VaultTokenCertX509Store
def
create(self, secret_store, timeout=None)
7600 def create(self, secret_store, timeout=None): 7601 deadline = None if timeout is None else time.time() + timeout 7602 req = SecretStoreCreateRequest() 7603 7604 if secret_store is not None: 7605 req.secret_store.CopyFrom( 7606 plumbing.convert_secret_store_to_plumbing(secret_store)) 7607 tries = 0 7608 plumbing_response = None 7609 while True: 7610 t = None if deadline is None else deadline - time.time() 7611 try: 7612 plumbing_response = self.stub.Create( 7613 req, 7614 metadata=self.parent.get_metadata('SecretStores.Create', 7615 req), 7616 timeout=t) 7617 except Exception as e: 7618 if self.parent.shouldRetry(tries, e, deadline): 7619 tries += 1 7620 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7621 continue 7622 raise plumbing.convert_error_to_porcelain(e) from e 7623 break 7624 7625 resp = models.SecretStoreCreateResponse() 7626 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 7627 plumbing_response.meta) 7628 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7629 plumbing_response.rate_limit) 7630 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 7631 plumbing_response.secret_store) 7632 return resp
def
get(self, id, timeout=None)
7634 def get(self, id, timeout=None): 7635 ''' 7636 Get reads one SecretStore by ID. 7637 ''' 7638 deadline = None if timeout is None else time.time() + timeout 7639 req = SecretStoreGetRequest() 7640 if self.parent.snapshot_datetime is not None: 7641 req.meta.CopyFrom(GetRequestMetadata()) 7642 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7643 7644 req.id = (id) 7645 tries = 0 7646 plumbing_response = None 7647 while True: 7648 t = None if deadline is None else deadline - time.time() 7649 try: 7650 plumbing_response = self.stub.Get( 7651 req, 7652 metadata=self.parent.get_metadata('SecretStores.Get', req), 7653 timeout=t) 7654 except Exception as e: 7655 if self.parent.shouldRetry(tries, e, deadline): 7656 tries += 1 7657 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7658 continue 7659 raise plumbing.convert_error_to_porcelain(e) from e 7660 break 7661 7662 resp = models.SecretStoreGetResponse() 7663 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 7664 plumbing_response.meta) 7665 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7666 plumbing_response.rate_limit) 7667 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 7668 plumbing_response.secret_store) 7669 return resp
Get reads one SecretStore by ID.
def
update(self, secret_store, timeout=None)
7671 def update(self, secret_store, timeout=None): 7672 ''' 7673 Update replaces all the fields of a SecretStore by ID. 7674 ''' 7675 deadline = None if timeout is None else time.time() + timeout 7676 req = SecretStoreUpdateRequest() 7677 7678 if secret_store is not None: 7679 req.secret_store.CopyFrom( 7680 plumbing.convert_secret_store_to_plumbing(secret_store)) 7681 tries = 0 7682 plumbing_response = None 7683 while True: 7684 t = None if deadline is None else deadline - time.time() 7685 try: 7686 plumbing_response = self.stub.Update( 7687 req, 7688 metadata=self.parent.get_metadata('SecretStores.Update', 7689 req), 7690 timeout=t) 7691 except Exception as e: 7692 if self.parent.shouldRetry(tries, e, deadline): 7693 tries += 1 7694 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7695 continue 7696 raise plumbing.convert_error_to_porcelain(e) from e 7697 break 7698 7699 resp = models.SecretStoreUpdateResponse() 7700 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 7701 plumbing_response.meta) 7702 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7703 plumbing_response.rate_limit) 7704 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 7705 plumbing_response.secret_store) 7706 return resp
Update replaces all the fields of a SecretStore by ID.
def
delete(self, id, timeout=None)
7708 def delete(self, id, timeout=None): 7709 ''' 7710 Delete removes a SecretStore by ID. 7711 ''' 7712 deadline = None if timeout is None else time.time() + timeout 7713 req = SecretStoreDeleteRequest() 7714 7715 req.id = (id) 7716 tries = 0 7717 plumbing_response = None 7718 while True: 7719 t = None if deadline is None else deadline - time.time() 7720 try: 7721 plumbing_response = self.stub.Delete( 7722 req, 7723 metadata=self.parent.get_metadata('SecretStores.Delete', 7724 req), 7725 timeout=t) 7726 except Exception as e: 7727 if self.parent.shouldRetry(tries, e, deadline): 7728 tries += 1 7729 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7730 continue 7731 raise plumbing.convert_error_to_porcelain(e) from e 7732 break 7733 7734 resp = models.SecretStoreDeleteResponse() 7735 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 7736 plumbing_response.meta) 7737 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7738 plumbing_response.rate_limit) 7739 return resp
Delete removes a SecretStore by ID.
def
list(self, filter, *args, timeout=None)
7741 def list(self, filter, *args, timeout=None): 7742 ''' 7743 List gets a list of SecretStores matching a given set of criteria. 7744 ''' 7745 deadline = None if timeout is None else time.time() + timeout 7746 req = SecretStoreListRequest() 7747 req.meta.CopyFrom(ListRequestMetadata()) 7748 if self.parent.page_limit > 0: 7749 req.meta.limit = self.parent.page_limit 7750 if self.parent.snapshot_datetime is not None: 7751 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7752 7753 req.filter = plumbing.quote_filter_args(filter, *args) 7754 7755 def generator(svc, req): 7756 tries = 0 7757 while True: 7758 t = None if deadline is None else deadline - time.time() 7759 try: 7760 plumbing_response = svc.stub.List( 7761 req, 7762 metadata=svc.parent.get_metadata( 7763 'SecretStores.List', req), 7764 timeout=t) 7765 except Exception as e: 7766 if self.parent.shouldRetry(tries, e, deadline): 7767 tries += 1 7768 time.sleep( 7769 self.parent.exponentialBackoff(tries, deadline)) 7770 continue 7771 raise plumbing.convert_error_to_porcelain(e) from e 7772 tries = 0 7773 for plumbing_item in plumbing_response.secret_stores: 7774 yield plumbing.convert_secret_store_to_porcelain( 7775 plumbing_item) 7776 if plumbing_response.meta.next_cursor == '': 7777 break 7778 req.meta.cursor = plumbing_response.meta.next_cursor 7779 7780 return generator(self, req)
List gets a list of SecretStores matching a given set of criteria.
class
SnapshotSecretStores:
7783class SnapshotSecretStores: 7784 ''' 7785 SnapshotSecretStores exposes the read only methods of the SecretStores 7786 service for historical queries. 7787 ''' 7788 def __init__(self, secret_stores): 7789 self.secret_stores = secret_stores 7790 7791 def get(self, id, timeout=None): 7792 ''' 7793 Get reads one SecretStore by ID. 7794 ''' 7795 return self.secret_stores.get(id, timeout=timeout) 7796 7797 def list(self, filter, *args, timeout=None): 7798 ''' 7799 List gets a list of SecretStores matching a given set of criteria. 7800 ''' 7801 return self.secret_stores.list(filter, *args, timeout=timeout)
SnapshotSecretStores exposes the read only methods of the SecretStores service for historical queries.
def
get(self, id, timeout=None)
7791 def get(self, id, timeout=None): 7792 ''' 7793 Get reads one SecretStore by ID. 7794 ''' 7795 return self.secret_stores.get(id, timeout=timeout)
Get reads one SecretStore by ID.
def
list(self, filter, *args, timeout=None)
7797 def list(self, filter, *args, timeout=None): 7798 ''' 7799 List gets a list of SecretStores matching a given set of criteria. 7800 ''' 7801 return self.secret_stores.list(filter, *args, timeout=timeout)
List gets a list of SecretStores matching a given set of criteria.
class
SecretEngines:
7804class SecretEngines: 7805 ''' 7806 7807 See: 7808 `strongdm.models.ActiveDirectoryEngine` 7809 `strongdm.models.KeyValueEngine` 7810 `strongdm.models.MysqlEngine` 7811 `strongdm.models.PostgresEngine` 7812 `strongdm.models.SqlserverEngine` 7813 ''' 7814 def __init__(self, channel, client): 7815 self.parent = client 7816 self.stub = SecretEnginesStub(channel) 7817 7818 def list(self, filter, *args, timeout=None): 7819 ''' 7820 List returns a list of Secret Engines 7821 ''' 7822 deadline = None if timeout is None else time.time() + timeout 7823 req = SecretEngineListRequest() 7824 req.meta.CopyFrom(ListRequestMetadata()) 7825 if self.parent.page_limit > 0: 7826 req.meta.limit = self.parent.page_limit 7827 if self.parent.snapshot_datetime is not None: 7828 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7829 7830 req.filter = plumbing.quote_filter_args(filter, *args) 7831 7832 def generator(svc, req): 7833 tries = 0 7834 while True: 7835 t = None if deadline is None else deadline - time.time() 7836 try: 7837 plumbing_response = svc.stub.List( 7838 req, 7839 metadata=svc.parent.get_metadata( 7840 'SecretEngines.List', req), 7841 timeout=t) 7842 except Exception as e: 7843 if self.parent.shouldRetry(tries, e, deadline): 7844 tries += 1 7845 time.sleep( 7846 self.parent.exponentialBackoff(tries, deadline)) 7847 continue 7848 raise plumbing.convert_error_to_porcelain(e) from e 7849 tries = 0 7850 for plumbing_item in plumbing_response.secret_engines: 7851 yield plumbing.convert_secret_engine_to_porcelain( 7852 plumbing_item) 7853 if plumbing_response.meta.next_cursor == '': 7854 break 7855 req.meta.cursor = plumbing_response.meta.next_cursor 7856 7857 return generator(self, req) 7858 7859 def get(self, id, timeout=None): 7860 ''' 7861 Get returns a secret engine details 7862 ''' 7863 deadline = None if timeout is None else time.time() + timeout 7864 req = SecretEngineGetRequest() 7865 if self.parent.snapshot_datetime is not None: 7866 req.meta.CopyFrom(GetRequestMetadata()) 7867 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7868 7869 req.id = (id) 7870 tries = 0 7871 plumbing_response = None 7872 while True: 7873 t = None if deadline is None else deadline - time.time() 7874 try: 7875 plumbing_response = self.stub.Get( 7876 req, 7877 metadata=self.parent.get_metadata('SecretEngines.Get', 7878 req), 7879 timeout=t) 7880 except Exception as e: 7881 if self.parent.shouldRetry(tries, e, deadline): 7882 tries += 1 7883 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7884 continue 7885 raise plumbing.convert_error_to_porcelain(e) from e 7886 break 7887 7888 resp = models.SecretEngineGetResponse() 7889 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 7890 plumbing_response.meta) 7891 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7892 plumbing_response.rate_limit) 7893 resp.secret_engine = plumbing.convert_secret_engine_to_porcelain( 7894 plumbing_response.secret_engine) 7895 return resp 7896 7897 def create(self, secret_engine, timeout=None): 7898 ''' 7899 Create creates a secret engine 7900 ''' 7901 deadline = None if timeout is None else time.time() + timeout 7902 req = SecretEngineCreateRequest() 7903 7904 if secret_engine is not None: 7905 req.secret_engine.CopyFrom( 7906 plumbing.convert_secret_engine_to_plumbing(secret_engine)) 7907 tries = 0 7908 plumbing_response = None 7909 while True: 7910 t = None if deadline is None else deadline - time.time() 7911 try: 7912 plumbing_response = self.stub.Create( 7913 req, 7914 metadata=self.parent.get_metadata('SecretEngines.Create', 7915 req), 7916 timeout=t) 7917 except Exception as e: 7918 if self.parent.shouldRetry(tries, e, deadline): 7919 tries += 1 7920 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7921 continue 7922 raise plumbing.convert_error_to_porcelain(e) from e 7923 break 7924 7925 resp = models.SecretEngineCreateResponse() 7926 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 7927 plumbing_response.meta) 7928 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7929 plumbing_response.rate_limit) 7930 resp.secret_engine = plumbing.convert_secret_engine_to_porcelain( 7931 plumbing_response.secret_engine) 7932 return resp 7933 7934 def update(self, secret_engine, timeout=None): 7935 ''' 7936 Update updates a secret engine 7937 ''' 7938 deadline = None if timeout is None else time.time() + timeout 7939 req = SecretEngineUpdateRequest() 7940 7941 if secret_engine is not None: 7942 req.secret_engine.CopyFrom( 7943 plumbing.convert_secret_engine_to_plumbing(secret_engine)) 7944 tries = 0 7945 plumbing_response = None 7946 while True: 7947 t = None if deadline is None else deadline - time.time() 7948 try: 7949 plumbing_response = self.stub.Update( 7950 req, 7951 metadata=self.parent.get_metadata('SecretEngines.Update', 7952 req), 7953 timeout=t) 7954 except Exception as e: 7955 if self.parent.shouldRetry(tries, e, deadline): 7956 tries += 1 7957 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7958 continue 7959 raise plumbing.convert_error_to_porcelain(e) from e 7960 break 7961 7962 resp = models.SecretEngineUpdateResponse() 7963 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 7964 plumbing_response.meta) 7965 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7966 plumbing_response.rate_limit) 7967 resp.secret_engine = plumbing.convert_secret_engine_to_porcelain( 7968 plumbing_response.secret_engine) 7969 return resp 7970 7971 def delete(self, id, timeout=None): 7972 ''' 7973 Delete deletes a secret engine 7974 ''' 7975 deadline = None if timeout is None else time.time() + timeout 7976 req = SecretEngineDeleteRequest() 7977 7978 req.id = (id) 7979 tries = 0 7980 plumbing_response = None 7981 while True: 7982 t = None if deadline is None else deadline - time.time() 7983 try: 7984 plumbing_response = self.stub.Delete( 7985 req, 7986 metadata=self.parent.get_metadata('SecretEngines.Delete', 7987 req), 7988 timeout=t) 7989 except Exception as e: 7990 if self.parent.shouldRetry(tries, e, deadline): 7991 tries += 1 7992 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7993 continue 7994 raise plumbing.convert_error_to_porcelain(e) from e 7995 break 7996 7997 resp = models.SecretEngineDeleteResponse() 7998 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7999 plumbing_response.rate_limit) 8000 return resp 8001 8002 def list_secret_stores(self, filter, *args, timeout=None): 8003 ''' 8004 ListSecretStores returns a list of Secret Stores that can be used as a backing store 8005 for Secret Engine 8006 ''' 8007 deadline = None if timeout is None else time.time() + timeout 8008 req = SecretStoreListRequest() 8009 req.meta.CopyFrom(ListRequestMetadata()) 8010 if self.parent.page_limit > 0: 8011 req.meta.limit = self.parent.page_limit 8012 if self.parent.snapshot_datetime is not None: 8013 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8014 8015 req.filter = plumbing.quote_filter_args(filter, *args) 8016 8017 def generator(svc, req): 8018 tries = 0 8019 while True: 8020 t = None if deadline is None else deadline - time.time() 8021 try: 8022 plumbing_response = svc.stub.ListSecretStores( 8023 req, 8024 metadata=svc.parent.get_metadata( 8025 'SecretEngines.ListSecretStores', req), 8026 timeout=t) 8027 except Exception as e: 8028 if self.parent.shouldRetry(tries, e, deadline): 8029 tries += 1 8030 time.sleep( 8031 self.parent.exponentialBackoff(tries, deadline)) 8032 continue 8033 raise plumbing.convert_error_to_porcelain(e) from e 8034 tries = 0 8035 for plumbing_item in plumbing_response.secret_stores: 8036 yield plumbing.convert_secret_store_to_porcelain( 8037 plumbing_item) 8038 if plumbing_response.meta.next_cursor == '': 8039 break 8040 req.meta.cursor = plumbing_response.meta.next_cursor 8041 8042 return generator(self, req) 8043 8044 def generate_keys(self, secret_engine_id, timeout=None): 8045 ''' 8046 GenerateKeys generates a private key, stores it in a secret store and stores a public key in a secret engine 8047 ''' 8048 deadline = None if timeout is None else time.time() + timeout 8049 req = GenerateKeysRequest() 8050 8051 req.secret_engine_id = (secret_engine_id) 8052 tries = 0 8053 plumbing_response = None 8054 while True: 8055 t = None if deadline is None else deadline - time.time() 8056 try: 8057 plumbing_response = self.stub.GenerateKeys( 8058 req, 8059 metadata=self.parent.get_metadata( 8060 'SecretEngines.GenerateKeys', req), 8061 timeout=t) 8062 except Exception as e: 8063 if self.parent.shouldRetry(tries, e, deadline): 8064 tries += 1 8065 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8066 continue 8067 raise plumbing.convert_error_to_porcelain(e) from e 8068 break 8069 8070 resp = models.GenerateKeysResponse() 8071 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8072 plumbing_response.rate_limit) 8073 return resp 8074 8075 def healthcheck(self, secret_engine_id, timeout=None): 8076 ''' 8077 Healthcheck triggers a healthcheck for all nodes serving a secret engine 8078 ''' 8079 deadline = None if timeout is None else time.time() + timeout 8080 req = HealthcheckRequest() 8081 8082 req.secret_engine_id = (secret_engine_id) 8083 tries = 0 8084 plumbing_response = None 8085 while True: 8086 t = None if deadline is None else deadline - time.time() 8087 try: 8088 plumbing_response = self.stub.Healthcheck( 8089 req, 8090 metadata=self.parent.get_metadata( 8091 'SecretEngines.Healthcheck', req), 8092 timeout=t) 8093 except Exception as e: 8094 if self.parent.shouldRetry(tries, e, deadline): 8095 tries += 1 8096 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8097 continue 8098 raise plumbing.convert_error_to_porcelain(e) from e 8099 break 8100 8101 resp = models.HealthcheckResponse() 8102 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8103 plumbing_response.rate_limit) 8104 resp.status = plumbing.convert_repeated_healthcheck_status_to_porcelain( 8105 plumbing_response.status) 8106 return resp 8107 8108 def rotate(self, id, password_policy, timeout=None): 8109 ''' 8110 Rotate rotates secret engine's credentials 8111 ''' 8112 deadline = None if timeout is None else time.time() + timeout 8113 req = SecretEngineRotateRequest() 8114 8115 req.id = (id) 8116 if password_policy is not None: 8117 req.password_policy.CopyFrom( 8118 plumbing.convert_secret_engine_password_policy_to_plumbing( 8119 password_policy)) 8120 tries = 0 8121 plumbing_response = None 8122 while True: 8123 t = None if deadline is None else deadline - time.time() 8124 try: 8125 plumbing_response = self.stub.Rotate( 8126 req, 8127 metadata=self.parent.get_metadata('SecretEngines.Rotate', 8128 req), 8129 timeout=t) 8130 except Exception as e: 8131 if self.parent.shouldRetry(tries, e, deadline): 8132 tries += 1 8133 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8134 continue 8135 raise plumbing.convert_error_to_porcelain(e) from e 8136 break 8137 8138 resp = models.SecretEngineRotateResponse() 8139 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8140 plumbing_response.rate_limit) 8141 return resp
See:
strongdm.models.ActiveDirectoryEngine
strongdm.models.KeyValueEngine
strongdm.models.MysqlEngine
strongdm.models.PostgresEngine
strongdm.models.SqlserverEngine
def
list(self, filter, *args, timeout=None)
7818 def list(self, filter, *args, timeout=None): 7819 ''' 7820 List returns a list of Secret Engines 7821 ''' 7822 deadline = None if timeout is None else time.time() + timeout 7823 req = SecretEngineListRequest() 7824 req.meta.CopyFrom(ListRequestMetadata()) 7825 if self.parent.page_limit > 0: 7826 req.meta.limit = self.parent.page_limit 7827 if self.parent.snapshot_datetime is not None: 7828 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7829 7830 req.filter = plumbing.quote_filter_args(filter, *args) 7831 7832 def generator(svc, req): 7833 tries = 0 7834 while True: 7835 t = None if deadline is None else deadline - time.time() 7836 try: 7837 plumbing_response = svc.stub.List( 7838 req, 7839 metadata=svc.parent.get_metadata( 7840 'SecretEngines.List', req), 7841 timeout=t) 7842 except Exception as e: 7843 if self.parent.shouldRetry(tries, e, deadline): 7844 tries += 1 7845 time.sleep( 7846 self.parent.exponentialBackoff(tries, deadline)) 7847 continue 7848 raise plumbing.convert_error_to_porcelain(e) from e 7849 tries = 0 7850 for plumbing_item in plumbing_response.secret_engines: 7851 yield plumbing.convert_secret_engine_to_porcelain( 7852 plumbing_item) 7853 if plumbing_response.meta.next_cursor == '': 7854 break 7855 req.meta.cursor = plumbing_response.meta.next_cursor 7856 7857 return generator(self, req)
List returns a list of Secret Engines
def
get(self, id, timeout=None)
7859 def get(self, id, timeout=None): 7860 ''' 7861 Get returns a secret engine details 7862 ''' 7863 deadline = None if timeout is None else time.time() + timeout 7864 req = SecretEngineGetRequest() 7865 if self.parent.snapshot_datetime is not None: 7866 req.meta.CopyFrom(GetRequestMetadata()) 7867 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7868 7869 req.id = (id) 7870 tries = 0 7871 plumbing_response = None 7872 while True: 7873 t = None if deadline is None else deadline - time.time() 7874 try: 7875 plumbing_response = self.stub.Get( 7876 req, 7877 metadata=self.parent.get_metadata('SecretEngines.Get', 7878 req), 7879 timeout=t) 7880 except Exception as e: 7881 if self.parent.shouldRetry(tries, e, deadline): 7882 tries += 1 7883 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7884 continue 7885 raise plumbing.convert_error_to_porcelain(e) from e 7886 break 7887 7888 resp = models.SecretEngineGetResponse() 7889 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 7890 plumbing_response.meta) 7891 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7892 plumbing_response.rate_limit) 7893 resp.secret_engine = plumbing.convert_secret_engine_to_porcelain( 7894 plumbing_response.secret_engine) 7895 return resp
Get returns a secret engine details
def
create(self, secret_engine, timeout=None)
7897 def create(self, secret_engine, timeout=None): 7898 ''' 7899 Create creates a secret engine 7900 ''' 7901 deadline = None if timeout is None else time.time() + timeout 7902 req = SecretEngineCreateRequest() 7903 7904 if secret_engine is not None: 7905 req.secret_engine.CopyFrom( 7906 plumbing.convert_secret_engine_to_plumbing(secret_engine)) 7907 tries = 0 7908 plumbing_response = None 7909 while True: 7910 t = None if deadline is None else deadline - time.time() 7911 try: 7912 plumbing_response = self.stub.Create( 7913 req, 7914 metadata=self.parent.get_metadata('SecretEngines.Create', 7915 req), 7916 timeout=t) 7917 except Exception as e: 7918 if self.parent.shouldRetry(tries, e, deadline): 7919 tries += 1 7920 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7921 continue 7922 raise plumbing.convert_error_to_porcelain(e) from e 7923 break 7924 7925 resp = models.SecretEngineCreateResponse() 7926 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 7927 plumbing_response.meta) 7928 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7929 plumbing_response.rate_limit) 7930 resp.secret_engine = plumbing.convert_secret_engine_to_porcelain( 7931 plumbing_response.secret_engine) 7932 return resp
Create creates a secret engine
def
update(self, secret_engine, timeout=None)
7934 def update(self, secret_engine, timeout=None): 7935 ''' 7936 Update updates a secret engine 7937 ''' 7938 deadline = None if timeout is None else time.time() + timeout 7939 req = SecretEngineUpdateRequest() 7940 7941 if secret_engine is not None: 7942 req.secret_engine.CopyFrom( 7943 plumbing.convert_secret_engine_to_plumbing(secret_engine)) 7944 tries = 0 7945 plumbing_response = None 7946 while True: 7947 t = None if deadline is None else deadline - time.time() 7948 try: 7949 plumbing_response = self.stub.Update( 7950 req, 7951 metadata=self.parent.get_metadata('SecretEngines.Update', 7952 req), 7953 timeout=t) 7954 except Exception as e: 7955 if self.parent.shouldRetry(tries, e, deadline): 7956 tries += 1 7957 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7958 continue 7959 raise plumbing.convert_error_to_porcelain(e) from e 7960 break 7961 7962 resp = models.SecretEngineUpdateResponse() 7963 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 7964 plumbing_response.meta) 7965 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7966 plumbing_response.rate_limit) 7967 resp.secret_engine = plumbing.convert_secret_engine_to_porcelain( 7968 plumbing_response.secret_engine) 7969 return resp
Update updates a secret engine
def
delete(self, id, timeout=None)
7971 def delete(self, id, timeout=None): 7972 ''' 7973 Delete deletes a secret engine 7974 ''' 7975 deadline = None if timeout is None else time.time() + timeout 7976 req = SecretEngineDeleteRequest() 7977 7978 req.id = (id) 7979 tries = 0 7980 plumbing_response = None 7981 while True: 7982 t = None if deadline is None else deadline - time.time() 7983 try: 7984 plumbing_response = self.stub.Delete( 7985 req, 7986 metadata=self.parent.get_metadata('SecretEngines.Delete', 7987 req), 7988 timeout=t) 7989 except Exception as e: 7990 if self.parent.shouldRetry(tries, e, deadline): 7991 tries += 1 7992 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7993 continue 7994 raise plumbing.convert_error_to_porcelain(e) from e 7995 break 7996 7997 resp = models.SecretEngineDeleteResponse() 7998 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7999 plumbing_response.rate_limit) 8000 return resp
Delete deletes a secret engine
def
list_secret_stores(self, filter, *args, timeout=None)
8002 def list_secret_stores(self, filter, *args, timeout=None): 8003 ''' 8004 ListSecretStores returns a list of Secret Stores that can be used as a backing store 8005 for Secret Engine 8006 ''' 8007 deadline = None if timeout is None else time.time() + timeout 8008 req = SecretStoreListRequest() 8009 req.meta.CopyFrom(ListRequestMetadata()) 8010 if self.parent.page_limit > 0: 8011 req.meta.limit = self.parent.page_limit 8012 if self.parent.snapshot_datetime is not None: 8013 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8014 8015 req.filter = plumbing.quote_filter_args(filter, *args) 8016 8017 def generator(svc, req): 8018 tries = 0 8019 while True: 8020 t = None if deadline is None else deadline - time.time() 8021 try: 8022 plumbing_response = svc.stub.ListSecretStores( 8023 req, 8024 metadata=svc.parent.get_metadata( 8025 'SecretEngines.ListSecretStores', req), 8026 timeout=t) 8027 except Exception as e: 8028 if self.parent.shouldRetry(tries, e, deadline): 8029 tries += 1 8030 time.sleep( 8031 self.parent.exponentialBackoff(tries, deadline)) 8032 continue 8033 raise plumbing.convert_error_to_porcelain(e) from e 8034 tries = 0 8035 for plumbing_item in plumbing_response.secret_stores: 8036 yield plumbing.convert_secret_store_to_porcelain( 8037 plumbing_item) 8038 if plumbing_response.meta.next_cursor == '': 8039 break 8040 req.meta.cursor = plumbing_response.meta.next_cursor 8041 8042 return generator(self, req)
ListSecretStores returns a list of Secret Stores that can be used as a backing store for Secret Engine
def
generate_keys(self, secret_engine_id, timeout=None)
8044 def generate_keys(self, secret_engine_id, timeout=None): 8045 ''' 8046 GenerateKeys generates a private key, stores it in a secret store and stores a public key in a secret engine 8047 ''' 8048 deadline = None if timeout is None else time.time() + timeout 8049 req = GenerateKeysRequest() 8050 8051 req.secret_engine_id = (secret_engine_id) 8052 tries = 0 8053 plumbing_response = None 8054 while True: 8055 t = None if deadline is None else deadline - time.time() 8056 try: 8057 plumbing_response = self.stub.GenerateKeys( 8058 req, 8059 metadata=self.parent.get_metadata( 8060 'SecretEngines.GenerateKeys', req), 8061 timeout=t) 8062 except Exception as e: 8063 if self.parent.shouldRetry(tries, e, deadline): 8064 tries += 1 8065 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8066 continue 8067 raise plumbing.convert_error_to_porcelain(e) from e 8068 break 8069 8070 resp = models.GenerateKeysResponse() 8071 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8072 plumbing_response.rate_limit) 8073 return resp
GenerateKeys generates a private key, stores it in a secret store and stores a public key in a secret engine
def
healthcheck(self, secret_engine_id, timeout=None)
8075 def healthcheck(self, secret_engine_id, timeout=None): 8076 ''' 8077 Healthcheck triggers a healthcheck for all nodes serving a secret engine 8078 ''' 8079 deadline = None if timeout is None else time.time() + timeout 8080 req = HealthcheckRequest() 8081 8082 req.secret_engine_id = (secret_engine_id) 8083 tries = 0 8084 plumbing_response = None 8085 while True: 8086 t = None if deadline is None else deadline - time.time() 8087 try: 8088 plumbing_response = self.stub.Healthcheck( 8089 req, 8090 metadata=self.parent.get_metadata( 8091 'SecretEngines.Healthcheck', req), 8092 timeout=t) 8093 except Exception as e: 8094 if self.parent.shouldRetry(tries, e, deadline): 8095 tries += 1 8096 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8097 continue 8098 raise plumbing.convert_error_to_porcelain(e) from e 8099 break 8100 8101 resp = models.HealthcheckResponse() 8102 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8103 plumbing_response.rate_limit) 8104 resp.status = plumbing.convert_repeated_healthcheck_status_to_porcelain( 8105 plumbing_response.status) 8106 return resp
Healthcheck triggers a healthcheck for all nodes serving a secret engine
def
rotate(self, id, password_policy, timeout=None)
8108 def rotate(self, id, password_policy, timeout=None): 8109 ''' 8110 Rotate rotates secret engine's credentials 8111 ''' 8112 deadline = None if timeout is None else time.time() + timeout 8113 req = SecretEngineRotateRequest() 8114 8115 req.id = (id) 8116 if password_policy is not None: 8117 req.password_policy.CopyFrom( 8118 plumbing.convert_secret_engine_password_policy_to_plumbing( 8119 password_policy)) 8120 tries = 0 8121 plumbing_response = None 8122 while True: 8123 t = None if deadline is None else deadline - time.time() 8124 try: 8125 plumbing_response = self.stub.Rotate( 8126 req, 8127 metadata=self.parent.get_metadata('SecretEngines.Rotate', 8128 req), 8129 timeout=t) 8130 except Exception as e: 8131 if self.parent.shouldRetry(tries, e, deadline): 8132 tries += 1 8133 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8134 continue 8135 raise plumbing.convert_error_to_porcelain(e) from e 8136 break 8137 8138 resp = models.SecretEngineRotateResponse() 8139 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8140 plumbing_response.rate_limit) 8141 return resp
Rotate rotates secret engine's credentials
class
SecretStoreHealths:
8144class SecretStoreHealths: 8145 ''' 8146 SecretStoreHealths exposes health states for secret stores. 8147 See `strongdm.models.SecretStoreHealth`. 8148 ''' 8149 def __init__(self, channel, client): 8150 self.parent = client 8151 self.stub = SecretStoreHealthsStub(channel) 8152 8153 def list(self, filter, *args, timeout=None): 8154 ''' 8155 List reports the health status of node to secret store pairs. 8156 ''' 8157 deadline = None if timeout is None else time.time() + timeout 8158 req = SecretStoreHealthListRequest() 8159 req.meta.CopyFrom(ListRequestMetadata()) 8160 if self.parent.page_limit > 0: 8161 req.meta.limit = self.parent.page_limit 8162 if self.parent.snapshot_datetime is not None: 8163 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8164 8165 req.filter = plumbing.quote_filter_args(filter, *args) 8166 8167 def generator(svc, req): 8168 tries = 0 8169 while True: 8170 t = None if deadline is None else deadline - time.time() 8171 try: 8172 plumbing_response = svc.stub.List( 8173 req, 8174 metadata=svc.parent.get_metadata( 8175 'SecretStoreHealths.List', req), 8176 timeout=t) 8177 except Exception as e: 8178 if self.parent.shouldRetry(tries, e, deadline): 8179 tries += 1 8180 time.sleep( 8181 self.parent.exponentialBackoff(tries, deadline)) 8182 continue 8183 raise plumbing.convert_error_to_porcelain(e) from e 8184 tries = 0 8185 for plumbing_item in plumbing_response.secret_store_healths: 8186 yield plumbing.convert_secret_store_health_to_porcelain( 8187 plumbing_item) 8188 if plumbing_response.meta.next_cursor == '': 8189 break 8190 req.meta.cursor = plumbing_response.meta.next_cursor 8191 8192 return generator(self, req) 8193 8194 def healthcheck(self, secret_store_id, timeout=None): 8195 ''' 8196 Healthcheck triggers a remote healthcheck request for a secret store. It may take minutes 8197 to propagate across a large network of Nodes. The call will return immediately, and the 8198 updated health of the Secret Store can be retrieved via List. 8199 ''' 8200 deadline = None if timeout is None else time.time() + timeout 8201 req = SecretStoreHealthcheckRequest() 8202 8203 req.secret_store_id = (secret_store_id) 8204 tries = 0 8205 plumbing_response = None 8206 while True: 8207 t = None if deadline is None else deadline - time.time() 8208 try: 8209 plumbing_response = self.stub.Healthcheck( 8210 req, 8211 metadata=self.parent.get_metadata( 8212 'SecretStoreHealths.Healthcheck', req), 8213 timeout=t) 8214 except Exception as e: 8215 if self.parent.shouldRetry(tries, e, deadline): 8216 tries += 1 8217 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8218 continue 8219 raise plumbing.convert_error_to_porcelain(e) from e 8220 break 8221 8222 resp = models.SecretStoreHealthcheckResponse() 8223 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8224 plumbing_response.rate_limit) 8225 return resp
SecretStoreHealths exposes health states for secret stores.
See strongdm.models.SecretStoreHealth.
def
list(self, filter, *args, timeout=None)
8153 def list(self, filter, *args, timeout=None): 8154 ''' 8155 List reports the health status of node to secret store pairs. 8156 ''' 8157 deadline = None if timeout is None else time.time() + timeout 8158 req = SecretStoreHealthListRequest() 8159 req.meta.CopyFrom(ListRequestMetadata()) 8160 if self.parent.page_limit > 0: 8161 req.meta.limit = self.parent.page_limit 8162 if self.parent.snapshot_datetime is not None: 8163 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8164 8165 req.filter = plumbing.quote_filter_args(filter, *args) 8166 8167 def generator(svc, req): 8168 tries = 0 8169 while True: 8170 t = None if deadline is None else deadline - time.time() 8171 try: 8172 plumbing_response = svc.stub.List( 8173 req, 8174 metadata=svc.parent.get_metadata( 8175 'SecretStoreHealths.List', req), 8176 timeout=t) 8177 except Exception as e: 8178 if self.parent.shouldRetry(tries, e, deadline): 8179 tries += 1 8180 time.sleep( 8181 self.parent.exponentialBackoff(tries, deadline)) 8182 continue 8183 raise plumbing.convert_error_to_porcelain(e) from e 8184 tries = 0 8185 for plumbing_item in plumbing_response.secret_store_healths: 8186 yield plumbing.convert_secret_store_health_to_porcelain( 8187 plumbing_item) 8188 if plumbing_response.meta.next_cursor == '': 8189 break 8190 req.meta.cursor = plumbing_response.meta.next_cursor 8191 8192 return generator(self, req)
List reports the health status of node to secret store pairs.
def
healthcheck(self, secret_store_id, timeout=None)
8194 def healthcheck(self, secret_store_id, timeout=None): 8195 ''' 8196 Healthcheck triggers a remote healthcheck request for a secret store. It may take minutes 8197 to propagate across a large network of Nodes. The call will return immediately, and the 8198 updated health of the Secret Store can be retrieved via List. 8199 ''' 8200 deadline = None if timeout is None else time.time() + timeout 8201 req = SecretStoreHealthcheckRequest() 8202 8203 req.secret_store_id = (secret_store_id) 8204 tries = 0 8205 plumbing_response = None 8206 while True: 8207 t = None if deadline is None else deadline - time.time() 8208 try: 8209 plumbing_response = self.stub.Healthcheck( 8210 req, 8211 metadata=self.parent.get_metadata( 8212 'SecretStoreHealths.Healthcheck', req), 8213 timeout=t) 8214 except Exception as e: 8215 if self.parent.shouldRetry(tries, e, deadline): 8216 tries += 1 8217 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8218 continue 8219 raise plumbing.convert_error_to_porcelain(e) from e 8220 break 8221 8222 resp = models.SecretStoreHealthcheckResponse() 8223 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8224 plumbing_response.rate_limit) 8225 return resp
Healthcheck triggers a remote healthcheck request for a secret store. It may take minutes to propagate across a large network of Nodes. The call will return immediately, and the updated health of the Secret Store can be retrieved via List.
class
SecretStoresHistory:
8228class SecretStoresHistory: 8229 ''' 8230 SecretStoresHistory records all changes to the state of a SecretStore. 8231 See `strongdm.models.SecretStoreHistory`. 8232 ''' 8233 def __init__(self, channel, client): 8234 self.parent = client 8235 self.stub = SecretStoresHistoryStub(channel) 8236 8237 def list(self, filter, *args, timeout=None): 8238 ''' 8239 List gets a list of SecretStoreHistory records matching a given set of criteria. 8240 ''' 8241 deadline = None if timeout is None else time.time() + timeout 8242 req = SecretStoreHistoryListRequest() 8243 req.meta.CopyFrom(ListRequestMetadata()) 8244 if self.parent.page_limit > 0: 8245 req.meta.limit = self.parent.page_limit 8246 if self.parent.snapshot_datetime is not None: 8247 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8248 8249 req.filter = plumbing.quote_filter_args(filter, *args) 8250 8251 def generator(svc, req): 8252 tries = 0 8253 while True: 8254 t = None if deadline is None else deadline - time.time() 8255 try: 8256 plumbing_response = svc.stub.List( 8257 req, 8258 metadata=svc.parent.get_metadata( 8259 'SecretStoresHistory.List', req), 8260 timeout=t) 8261 except Exception as e: 8262 if self.parent.shouldRetry(tries, e, deadline): 8263 tries += 1 8264 time.sleep( 8265 self.parent.exponentialBackoff(tries, deadline)) 8266 continue 8267 raise plumbing.convert_error_to_porcelain(e) from e 8268 tries = 0 8269 for plumbing_item in plumbing_response.history: 8270 yield plumbing.convert_secret_store_history_to_porcelain( 8271 plumbing_item) 8272 if plumbing_response.meta.next_cursor == '': 8273 break 8274 req.meta.cursor = plumbing_response.meta.next_cursor 8275 8276 return generator(self, req)
SecretStoresHistory records all changes to the state of a SecretStore.
See strongdm.models.SecretStoreHistory.
def
list(self, filter, *args, timeout=None)
8237 def list(self, filter, *args, timeout=None): 8238 ''' 8239 List gets a list of SecretStoreHistory records matching a given set of criteria. 8240 ''' 8241 deadline = None if timeout is None else time.time() + timeout 8242 req = SecretStoreHistoryListRequest() 8243 req.meta.CopyFrom(ListRequestMetadata()) 8244 if self.parent.page_limit > 0: 8245 req.meta.limit = self.parent.page_limit 8246 if self.parent.snapshot_datetime is not None: 8247 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8248 8249 req.filter = plumbing.quote_filter_args(filter, *args) 8250 8251 def generator(svc, req): 8252 tries = 0 8253 while True: 8254 t = None if deadline is None else deadline - time.time() 8255 try: 8256 plumbing_response = svc.stub.List( 8257 req, 8258 metadata=svc.parent.get_metadata( 8259 'SecretStoresHistory.List', req), 8260 timeout=t) 8261 except Exception as e: 8262 if self.parent.shouldRetry(tries, e, deadline): 8263 tries += 1 8264 time.sleep( 8265 self.parent.exponentialBackoff(tries, deadline)) 8266 continue 8267 raise plumbing.convert_error_to_porcelain(e) from e 8268 tries = 0 8269 for plumbing_item in plumbing_response.history: 8270 yield plumbing.convert_secret_store_history_to_porcelain( 8271 plumbing_item) 8272 if plumbing_response.meta.next_cursor == '': 8273 break 8274 req.meta.cursor = plumbing_response.meta.next_cursor 8275 8276 return generator(self, req)
List gets a list of SecretStoreHistory records matching a given set of criteria.
class
WorkflowApprovers:
8279class WorkflowApprovers: 8280 ''' 8281 WorkflowApprovers is an account or a role with the ability to approve requests bound to a workflow. 8282 See `strongdm.models.WorkflowApprover`. 8283 ''' 8284 def __init__(self, channel, client): 8285 self.parent = client 8286 self.stub = WorkflowApproversStub(channel) 8287 8288 def create(self, workflow_approver, timeout=None): 8289 ''' 8290 Create creates a new workflow approver 8291 ''' 8292 deadline = None if timeout is None else time.time() + timeout 8293 req = WorkflowApproversCreateRequest() 8294 8295 if workflow_approver is not None: 8296 req.workflow_approver.CopyFrom( 8297 plumbing.convert_workflow_approver_to_plumbing( 8298 workflow_approver)) 8299 tries = 0 8300 plumbing_response = None 8301 while True: 8302 t = None if deadline is None else deadline - time.time() 8303 try: 8304 plumbing_response = self.stub.Create( 8305 req, 8306 metadata=self.parent.get_metadata( 8307 'WorkflowApprovers.Create', req), 8308 timeout=t) 8309 except Exception as e: 8310 if self.parent.shouldRetry(tries, e, deadline): 8311 tries += 1 8312 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8313 continue 8314 raise plumbing.convert_error_to_porcelain(e) from e 8315 break 8316 8317 resp = models.WorkflowApproversCreateResponse() 8318 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8319 plumbing_response.rate_limit) 8320 resp.workflow_approver = plumbing.convert_workflow_approver_to_porcelain( 8321 plumbing_response.workflow_approver) 8322 return resp 8323 8324 def get(self, id, timeout=None): 8325 ''' 8326 Get reads one workflow approver by ID. 8327 ''' 8328 deadline = None if timeout is None else time.time() + timeout 8329 req = WorkflowApproverGetRequest() 8330 if self.parent.snapshot_datetime is not None: 8331 req.meta.CopyFrom(GetRequestMetadata()) 8332 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8333 8334 req.id = (id) 8335 tries = 0 8336 plumbing_response = None 8337 while True: 8338 t = None if deadline is None else deadline - time.time() 8339 try: 8340 plumbing_response = self.stub.Get( 8341 req, 8342 metadata=self.parent.get_metadata('WorkflowApprovers.Get', 8343 req), 8344 timeout=t) 8345 except Exception as e: 8346 if self.parent.shouldRetry(tries, e, deadline): 8347 tries += 1 8348 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8349 continue 8350 raise plumbing.convert_error_to_porcelain(e) from e 8351 break 8352 8353 resp = models.WorkflowApproverGetResponse() 8354 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 8355 plumbing_response.meta) 8356 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8357 plumbing_response.rate_limit) 8358 resp.workflow_approver = plumbing.convert_workflow_approver_to_porcelain( 8359 plumbing_response.workflow_approver) 8360 return resp 8361 8362 def delete(self, id, timeout=None): 8363 ''' 8364 Delete deletes a workflow approver 8365 ''' 8366 deadline = None if timeout is None else time.time() + timeout 8367 req = WorkflowApproversDeleteRequest() 8368 8369 req.id = (id) 8370 tries = 0 8371 plumbing_response = None 8372 while True: 8373 t = None if deadline is None else deadline - time.time() 8374 try: 8375 plumbing_response = self.stub.Delete( 8376 req, 8377 metadata=self.parent.get_metadata( 8378 'WorkflowApprovers.Delete', req), 8379 timeout=t) 8380 except Exception as e: 8381 if self.parent.shouldRetry(tries, e, deadline): 8382 tries += 1 8383 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8384 continue 8385 raise plumbing.convert_error_to_porcelain(e) from e 8386 break 8387 8388 resp = models.WorkflowApproversDeleteResponse() 8389 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8390 plumbing_response.rate_limit) 8391 return resp 8392 8393 def list(self, filter, *args, timeout=None): 8394 ''' 8395 Lists existing workflow approvers. 8396 ''' 8397 deadline = None if timeout is None else time.time() + timeout 8398 req = WorkflowApproversListRequest() 8399 req.meta.CopyFrom(ListRequestMetadata()) 8400 if self.parent.page_limit > 0: 8401 req.meta.limit = self.parent.page_limit 8402 if self.parent.snapshot_datetime is not None: 8403 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8404 8405 req.filter = plumbing.quote_filter_args(filter, *args) 8406 8407 def generator(svc, req): 8408 tries = 0 8409 while True: 8410 t = None if deadline is None else deadline - time.time() 8411 try: 8412 plumbing_response = svc.stub.List( 8413 req, 8414 metadata=svc.parent.get_metadata( 8415 'WorkflowApprovers.List', req), 8416 timeout=t) 8417 except Exception as e: 8418 if self.parent.shouldRetry(tries, e, deadline): 8419 tries += 1 8420 time.sleep( 8421 self.parent.exponentialBackoff(tries, deadline)) 8422 continue 8423 raise plumbing.convert_error_to_porcelain(e) from e 8424 tries = 0 8425 for plumbing_item in plumbing_response.workflow_approvers: 8426 yield plumbing.convert_workflow_approver_to_porcelain( 8427 plumbing_item) 8428 if plumbing_response.meta.next_cursor == '': 8429 break 8430 req.meta.cursor = plumbing_response.meta.next_cursor 8431 8432 return generator(self, req)
WorkflowApprovers is an account or a role with the ability to approve requests bound to a workflow.
See strongdm.models.WorkflowApprover.
def
create(self, workflow_approver, timeout=None)
8288 def create(self, workflow_approver, timeout=None): 8289 ''' 8290 Create creates a new workflow approver 8291 ''' 8292 deadline = None if timeout is None else time.time() + timeout 8293 req = WorkflowApproversCreateRequest() 8294 8295 if workflow_approver is not None: 8296 req.workflow_approver.CopyFrom( 8297 plumbing.convert_workflow_approver_to_plumbing( 8298 workflow_approver)) 8299 tries = 0 8300 plumbing_response = None 8301 while True: 8302 t = None if deadline is None else deadline - time.time() 8303 try: 8304 plumbing_response = self.stub.Create( 8305 req, 8306 metadata=self.parent.get_metadata( 8307 'WorkflowApprovers.Create', req), 8308 timeout=t) 8309 except Exception as e: 8310 if self.parent.shouldRetry(tries, e, deadline): 8311 tries += 1 8312 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8313 continue 8314 raise plumbing.convert_error_to_porcelain(e) from e 8315 break 8316 8317 resp = models.WorkflowApproversCreateResponse() 8318 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8319 plumbing_response.rate_limit) 8320 resp.workflow_approver = plumbing.convert_workflow_approver_to_porcelain( 8321 plumbing_response.workflow_approver) 8322 return resp
Create creates a new workflow approver
def
get(self, id, timeout=None)
8324 def get(self, id, timeout=None): 8325 ''' 8326 Get reads one workflow approver by ID. 8327 ''' 8328 deadline = None if timeout is None else time.time() + timeout 8329 req = WorkflowApproverGetRequest() 8330 if self.parent.snapshot_datetime is not None: 8331 req.meta.CopyFrom(GetRequestMetadata()) 8332 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8333 8334 req.id = (id) 8335 tries = 0 8336 plumbing_response = None 8337 while True: 8338 t = None if deadline is None else deadline - time.time() 8339 try: 8340 plumbing_response = self.stub.Get( 8341 req, 8342 metadata=self.parent.get_metadata('WorkflowApprovers.Get', 8343 req), 8344 timeout=t) 8345 except Exception as e: 8346 if self.parent.shouldRetry(tries, e, deadline): 8347 tries += 1 8348 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8349 continue 8350 raise plumbing.convert_error_to_porcelain(e) from e 8351 break 8352 8353 resp = models.WorkflowApproverGetResponse() 8354 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 8355 plumbing_response.meta) 8356 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8357 plumbing_response.rate_limit) 8358 resp.workflow_approver = plumbing.convert_workflow_approver_to_porcelain( 8359 plumbing_response.workflow_approver) 8360 return resp
Get reads one workflow approver by ID.
def
delete(self, id, timeout=None)
8362 def delete(self, id, timeout=None): 8363 ''' 8364 Delete deletes a workflow approver 8365 ''' 8366 deadline = None if timeout is None else time.time() + timeout 8367 req = WorkflowApproversDeleteRequest() 8368 8369 req.id = (id) 8370 tries = 0 8371 plumbing_response = None 8372 while True: 8373 t = None if deadline is None else deadline - time.time() 8374 try: 8375 plumbing_response = self.stub.Delete( 8376 req, 8377 metadata=self.parent.get_metadata( 8378 'WorkflowApprovers.Delete', req), 8379 timeout=t) 8380 except Exception as e: 8381 if self.parent.shouldRetry(tries, e, deadline): 8382 tries += 1 8383 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8384 continue 8385 raise plumbing.convert_error_to_porcelain(e) from e 8386 break 8387 8388 resp = models.WorkflowApproversDeleteResponse() 8389 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8390 plumbing_response.rate_limit) 8391 return resp
Delete deletes a workflow approver
def
list(self, filter, *args, timeout=None)
8393 def list(self, filter, *args, timeout=None): 8394 ''' 8395 Lists existing workflow approvers. 8396 ''' 8397 deadline = None if timeout is None else time.time() + timeout 8398 req = WorkflowApproversListRequest() 8399 req.meta.CopyFrom(ListRequestMetadata()) 8400 if self.parent.page_limit > 0: 8401 req.meta.limit = self.parent.page_limit 8402 if self.parent.snapshot_datetime is not None: 8403 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8404 8405 req.filter = plumbing.quote_filter_args(filter, *args) 8406 8407 def generator(svc, req): 8408 tries = 0 8409 while True: 8410 t = None if deadline is None else deadline - time.time() 8411 try: 8412 plumbing_response = svc.stub.List( 8413 req, 8414 metadata=svc.parent.get_metadata( 8415 'WorkflowApprovers.List', req), 8416 timeout=t) 8417 except Exception as e: 8418 if self.parent.shouldRetry(tries, e, deadline): 8419 tries += 1 8420 time.sleep( 8421 self.parent.exponentialBackoff(tries, deadline)) 8422 continue 8423 raise plumbing.convert_error_to_porcelain(e) from e 8424 tries = 0 8425 for plumbing_item in plumbing_response.workflow_approvers: 8426 yield plumbing.convert_workflow_approver_to_porcelain( 8427 plumbing_item) 8428 if plumbing_response.meta.next_cursor == '': 8429 break 8430 req.meta.cursor = plumbing_response.meta.next_cursor 8431 8432 return generator(self, req)
Lists existing workflow approvers.
class
SnapshotWorkflowApprovers:
8435class SnapshotWorkflowApprovers: 8436 ''' 8437 SnapshotWorkflowApprovers exposes the read only methods of the WorkflowApprovers 8438 service for historical queries. 8439 ''' 8440 def __init__(self, workflow_approvers): 8441 self.workflow_approvers = workflow_approvers 8442 8443 def get(self, id, timeout=None): 8444 ''' 8445 Get reads one workflow approver by ID. 8446 ''' 8447 return self.workflow_approvers.get(id, timeout=timeout) 8448 8449 def list(self, filter, *args, timeout=None): 8450 ''' 8451 Lists existing workflow approvers. 8452 ''' 8453 return self.workflow_approvers.list(filter, *args, timeout=timeout)
SnapshotWorkflowApprovers exposes the read only methods of the WorkflowApprovers service for historical queries.
class
WorkflowApproversHistory:
8456class WorkflowApproversHistory: 8457 ''' 8458 WorkflowApproversHistory provides records of all changes to the state of a WorkflowApprover. 8459 See `strongdm.models.WorkflowApproverHistory`. 8460 ''' 8461 def __init__(self, channel, client): 8462 self.parent = client 8463 self.stub = WorkflowApproversHistoryStub(channel) 8464 8465 def list(self, filter, *args, timeout=None): 8466 ''' 8467 List gets a list of WorkflowApproversHistory records matching a given set of criteria. 8468 ''' 8469 deadline = None if timeout is None else time.time() + timeout 8470 req = WorkflowApproversHistoryListRequest() 8471 req.meta.CopyFrom(ListRequestMetadata()) 8472 if self.parent.page_limit > 0: 8473 req.meta.limit = self.parent.page_limit 8474 if self.parent.snapshot_datetime is not None: 8475 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8476 8477 req.filter = plumbing.quote_filter_args(filter, *args) 8478 8479 def generator(svc, req): 8480 tries = 0 8481 while True: 8482 t = None if deadline is None else deadline - time.time() 8483 try: 8484 plumbing_response = svc.stub.List( 8485 req, 8486 metadata=svc.parent.get_metadata( 8487 'WorkflowApproversHistory.List', req), 8488 timeout=t) 8489 except Exception as e: 8490 if self.parent.shouldRetry(tries, e, deadline): 8491 tries += 1 8492 time.sleep( 8493 self.parent.exponentialBackoff(tries, deadline)) 8494 continue 8495 raise plumbing.convert_error_to_porcelain(e) from e 8496 tries = 0 8497 for plumbing_item in plumbing_response.history: 8498 yield plumbing.convert_workflow_approver_history_to_porcelain( 8499 plumbing_item) 8500 if plumbing_response.meta.next_cursor == '': 8501 break 8502 req.meta.cursor = plumbing_response.meta.next_cursor 8503 8504 return generator(self, req)
WorkflowApproversHistory provides records of all changes to the state of a WorkflowApprover.
See strongdm.models.WorkflowApproverHistory.
def
list(self, filter, *args, timeout=None)
8465 def list(self, filter, *args, timeout=None): 8466 ''' 8467 List gets a list of WorkflowApproversHistory records matching a given set of criteria. 8468 ''' 8469 deadline = None if timeout is None else time.time() + timeout 8470 req = WorkflowApproversHistoryListRequest() 8471 req.meta.CopyFrom(ListRequestMetadata()) 8472 if self.parent.page_limit > 0: 8473 req.meta.limit = self.parent.page_limit 8474 if self.parent.snapshot_datetime is not None: 8475 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8476 8477 req.filter = plumbing.quote_filter_args(filter, *args) 8478 8479 def generator(svc, req): 8480 tries = 0 8481 while True: 8482 t = None if deadline is None else deadline - time.time() 8483 try: 8484 plumbing_response = svc.stub.List( 8485 req, 8486 metadata=svc.parent.get_metadata( 8487 'WorkflowApproversHistory.List', req), 8488 timeout=t) 8489 except Exception as e: 8490 if self.parent.shouldRetry(tries, e, deadline): 8491 tries += 1 8492 time.sleep( 8493 self.parent.exponentialBackoff(tries, deadline)) 8494 continue 8495 raise plumbing.convert_error_to_porcelain(e) from e 8496 tries = 0 8497 for plumbing_item in plumbing_response.history: 8498 yield plumbing.convert_workflow_approver_history_to_porcelain( 8499 plumbing_item) 8500 if plumbing_response.meta.next_cursor == '': 8501 break 8502 req.meta.cursor = plumbing_response.meta.next_cursor 8503 8504 return generator(self, req)
List gets a list of WorkflowApproversHistory records matching a given set of criteria.
class
WorkflowRoles:
8507class WorkflowRoles: 8508 ''' 8509 WorkflowRole links a role to a workflow. The linked roles indicate which roles a user must be a part of 8510 to request access to a resource via the workflow. 8511 See `strongdm.models.WorkflowRole`. 8512 ''' 8513 def __init__(self, channel, client): 8514 self.parent = client 8515 self.stub = WorkflowRolesStub(channel) 8516 8517 def create(self, workflow_role, timeout=None): 8518 ''' 8519 Create creates a new workflow role 8520 ''' 8521 deadline = None if timeout is None else time.time() + timeout 8522 req = WorkflowRolesCreateRequest() 8523 8524 if workflow_role is not None: 8525 req.workflow_role.CopyFrom( 8526 plumbing.convert_workflow_role_to_plumbing(workflow_role)) 8527 tries = 0 8528 plumbing_response = None 8529 while True: 8530 t = None if deadline is None else deadline - time.time() 8531 try: 8532 plumbing_response = self.stub.Create( 8533 req, 8534 metadata=self.parent.get_metadata('WorkflowRoles.Create', 8535 req), 8536 timeout=t) 8537 except Exception as e: 8538 if self.parent.shouldRetry(tries, e, deadline): 8539 tries += 1 8540 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8541 continue 8542 raise plumbing.convert_error_to_porcelain(e) from e 8543 break 8544 8545 resp = models.WorkflowRolesCreateResponse() 8546 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8547 plumbing_response.rate_limit) 8548 resp.workflow_role = plumbing.convert_workflow_role_to_porcelain( 8549 plumbing_response.workflow_role) 8550 return resp 8551 8552 def get(self, id, timeout=None): 8553 ''' 8554 Get reads one workflow role by ID. 8555 ''' 8556 deadline = None if timeout is None else time.time() + timeout 8557 req = WorkflowRoleGetRequest() 8558 if self.parent.snapshot_datetime is not None: 8559 req.meta.CopyFrom(GetRequestMetadata()) 8560 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8561 8562 req.id = (id) 8563 tries = 0 8564 plumbing_response = None 8565 while True: 8566 t = None if deadline is None else deadline - time.time() 8567 try: 8568 plumbing_response = self.stub.Get( 8569 req, 8570 metadata=self.parent.get_metadata('WorkflowRoles.Get', 8571 req), 8572 timeout=t) 8573 except Exception as e: 8574 if self.parent.shouldRetry(tries, e, deadline): 8575 tries += 1 8576 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8577 continue 8578 raise plumbing.convert_error_to_porcelain(e) from e 8579 break 8580 8581 resp = models.WorkflowRoleGetResponse() 8582 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 8583 plumbing_response.meta) 8584 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8585 plumbing_response.rate_limit) 8586 resp.workflow_role = plumbing.convert_workflow_role_to_porcelain( 8587 plumbing_response.workflow_role) 8588 return resp 8589 8590 def delete(self, id, timeout=None): 8591 ''' 8592 Delete deletes a workflow role 8593 ''' 8594 deadline = None if timeout is None else time.time() + timeout 8595 req = WorkflowRolesDeleteRequest() 8596 8597 req.id = (id) 8598 tries = 0 8599 plumbing_response = None 8600 while True: 8601 t = None if deadline is None else deadline - time.time() 8602 try: 8603 plumbing_response = self.stub.Delete( 8604 req, 8605 metadata=self.parent.get_metadata('WorkflowRoles.Delete', 8606 req), 8607 timeout=t) 8608 except Exception as e: 8609 if self.parent.shouldRetry(tries, e, deadline): 8610 tries += 1 8611 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8612 continue 8613 raise plumbing.convert_error_to_porcelain(e) from e 8614 break 8615 8616 resp = models.WorkflowRolesDeleteResponse() 8617 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8618 plumbing_response.rate_limit) 8619 return resp 8620 8621 def list(self, filter, *args, timeout=None): 8622 ''' 8623 Lists existing workflow roles. 8624 ''' 8625 deadline = None if timeout is None else time.time() + timeout 8626 req = WorkflowRolesListRequest() 8627 req.meta.CopyFrom(ListRequestMetadata()) 8628 if self.parent.page_limit > 0: 8629 req.meta.limit = self.parent.page_limit 8630 if self.parent.snapshot_datetime is not None: 8631 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8632 8633 req.filter = plumbing.quote_filter_args(filter, *args) 8634 8635 def generator(svc, req): 8636 tries = 0 8637 while True: 8638 t = None if deadline is None else deadline - time.time() 8639 try: 8640 plumbing_response = svc.stub.List( 8641 req, 8642 metadata=svc.parent.get_metadata( 8643 'WorkflowRoles.List', req), 8644 timeout=t) 8645 except Exception as e: 8646 if self.parent.shouldRetry(tries, e, deadline): 8647 tries += 1 8648 time.sleep( 8649 self.parent.exponentialBackoff(tries, deadline)) 8650 continue 8651 raise plumbing.convert_error_to_porcelain(e) from e 8652 tries = 0 8653 for plumbing_item in plumbing_response.workflow_role: 8654 yield plumbing.convert_workflow_role_to_porcelain( 8655 plumbing_item) 8656 if plumbing_response.meta.next_cursor == '': 8657 break 8658 req.meta.cursor = plumbing_response.meta.next_cursor 8659 8660 return generator(self, req)
WorkflowRole links a role to a workflow. The linked roles indicate which roles a user must be a part of
to request access to a resource via the workflow.
See strongdm.models.WorkflowRole.
def
create(self, workflow_role, timeout=None)
8517 def create(self, workflow_role, timeout=None): 8518 ''' 8519 Create creates a new workflow role 8520 ''' 8521 deadline = None if timeout is None else time.time() + timeout 8522 req = WorkflowRolesCreateRequest() 8523 8524 if workflow_role is not None: 8525 req.workflow_role.CopyFrom( 8526 plumbing.convert_workflow_role_to_plumbing(workflow_role)) 8527 tries = 0 8528 plumbing_response = None 8529 while True: 8530 t = None if deadline is None else deadline - time.time() 8531 try: 8532 plumbing_response = self.stub.Create( 8533 req, 8534 metadata=self.parent.get_metadata('WorkflowRoles.Create', 8535 req), 8536 timeout=t) 8537 except Exception as e: 8538 if self.parent.shouldRetry(tries, e, deadline): 8539 tries += 1 8540 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8541 continue 8542 raise plumbing.convert_error_to_porcelain(e) from e 8543 break 8544 8545 resp = models.WorkflowRolesCreateResponse() 8546 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8547 plumbing_response.rate_limit) 8548 resp.workflow_role = plumbing.convert_workflow_role_to_porcelain( 8549 plumbing_response.workflow_role) 8550 return resp
Create creates a new workflow role
def
get(self, id, timeout=None)
8552 def get(self, id, timeout=None): 8553 ''' 8554 Get reads one workflow role by ID. 8555 ''' 8556 deadline = None if timeout is None else time.time() + timeout 8557 req = WorkflowRoleGetRequest() 8558 if self.parent.snapshot_datetime is not None: 8559 req.meta.CopyFrom(GetRequestMetadata()) 8560 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8561 8562 req.id = (id) 8563 tries = 0 8564 plumbing_response = None 8565 while True: 8566 t = None if deadline is None else deadline - time.time() 8567 try: 8568 plumbing_response = self.stub.Get( 8569 req, 8570 metadata=self.parent.get_metadata('WorkflowRoles.Get', 8571 req), 8572 timeout=t) 8573 except Exception as e: 8574 if self.parent.shouldRetry(tries, e, deadline): 8575 tries += 1 8576 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8577 continue 8578 raise plumbing.convert_error_to_porcelain(e) from e 8579 break 8580 8581 resp = models.WorkflowRoleGetResponse() 8582 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 8583 plumbing_response.meta) 8584 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8585 plumbing_response.rate_limit) 8586 resp.workflow_role = plumbing.convert_workflow_role_to_porcelain( 8587 plumbing_response.workflow_role) 8588 return resp
Get reads one workflow role by ID.
def
delete(self, id, timeout=None)
8590 def delete(self, id, timeout=None): 8591 ''' 8592 Delete deletes a workflow role 8593 ''' 8594 deadline = None if timeout is None else time.time() + timeout 8595 req = WorkflowRolesDeleteRequest() 8596 8597 req.id = (id) 8598 tries = 0 8599 plumbing_response = None 8600 while True: 8601 t = None if deadline is None else deadline - time.time() 8602 try: 8603 plumbing_response = self.stub.Delete( 8604 req, 8605 metadata=self.parent.get_metadata('WorkflowRoles.Delete', 8606 req), 8607 timeout=t) 8608 except Exception as e: 8609 if self.parent.shouldRetry(tries, e, deadline): 8610 tries += 1 8611 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8612 continue 8613 raise plumbing.convert_error_to_porcelain(e) from e 8614 break 8615 8616 resp = models.WorkflowRolesDeleteResponse() 8617 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8618 plumbing_response.rate_limit) 8619 return resp
Delete deletes a workflow role
def
list(self, filter, *args, timeout=None)
8621 def list(self, filter, *args, timeout=None): 8622 ''' 8623 Lists existing workflow roles. 8624 ''' 8625 deadline = None if timeout is None else time.time() + timeout 8626 req = WorkflowRolesListRequest() 8627 req.meta.CopyFrom(ListRequestMetadata()) 8628 if self.parent.page_limit > 0: 8629 req.meta.limit = self.parent.page_limit 8630 if self.parent.snapshot_datetime is not None: 8631 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8632 8633 req.filter = plumbing.quote_filter_args(filter, *args) 8634 8635 def generator(svc, req): 8636 tries = 0 8637 while True: 8638 t = None if deadline is None else deadline - time.time() 8639 try: 8640 plumbing_response = svc.stub.List( 8641 req, 8642 metadata=svc.parent.get_metadata( 8643 'WorkflowRoles.List', req), 8644 timeout=t) 8645 except Exception as e: 8646 if self.parent.shouldRetry(tries, e, deadline): 8647 tries += 1 8648 time.sleep( 8649 self.parent.exponentialBackoff(tries, deadline)) 8650 continue 8651 raise plumbing.convert_error_to_porcelain(e) from e 8652 tries = 0 8653 for plumbing_item in plumbing_response.workflow_role: 8654 yield plumbing.convert_workflow_role_to_porcelain( 8655 plumbing_item) 8656 if plumbing_response.meta.next_cursor == '': 8657 break 8658 req.meta.cursor = plumbing_response.meta.next_cursor 8659 8660 return generator(self, req)
Lists existing workflow roles.
class
SnapshotWorkflowRoles:
8663class SnapshotWorkflowRoles: 8664 ''' 8665 SnapshotWorkflowRoles exposes the read only methods of the WorkflowRoles 8666 service for historical queries. 8667 ''' 8668 def __init__(self, workflow_roles): 8669 self.workflow_roles = workflow_roles 8670 8671 def get(self, id, timeout=None): 8672 ''' 8673 Get reads one workflow role by ID. 8674 ''' 8675 return self.workflow_roles.get(id, timeout=timeout) 8676 8677 def list(self, filter, *args, timeout=None): 8678 ''' 8679 Lists existing workflow roles. 8680 ''' 8681 return self.workflow_roles.list(filter, *args, timeout=timeout)
SnapshotWorkflowRoles exposes the read only methods of the WorkflowRoles service for historical queries.
class
WorkflowRolesHistory:
8684class WorkflowRolesHistory: 8685 ''' 8686 WorkflowRolesHistory provides records of all changes to the state of a WorkflowRole 8687 See `strongdm.models.WorkflowRoleHistory`. 8688 ''' 8689 def __init__(self, channel, client): 8690 self.parent = client 8691 self.stub = WorkflowRolesHistoryStub(channel) 8692 8693 def list(self, filter, *args, timeout=None): 8694 ''' 8695 List gets a list of WorkflowRolesHistory records matching a given set of criteria. 8696 ''' 8697 deadline = None if timeout is None else time.time() + timeout 8698 req = WorkflowRolesHistoryListRequest() 8699 req.meta.CopyFrom(ListRequestMetadata()) 8700 if self.parent.page_limit > 0: 8701 req.meta.limit = self.parent.page_limit 8702 if self.parent.snapshot_datetime is not None: 8703 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8704 8705 req.filter = plumbing.quote_filter_args(filter, *args) 8706 8707 def generator(svc, req): 8708 tries = 0 8709 while True: 8710 t = None if deadline is None else deadline - time.time() 8711 try: 8712 plumbing_response = svc.stub.List( 8713 req, 8714 metadata=svc.parent.get_metadata( 8715 'WorkflowRolesHistory.List', req), 8716 timeout=t) 8717 except Exception as e: 8718 if self.parent.shouldRetry(tries, e, deadline): 8719 tries += 1 8720 time.sleep( 8721 self.parent.exponentialBackoff(tries, deadline)) 8722 continue 8723 raise plumbing.convert_error_to_porcelain(e) from e 8724 tries = 0 8725 for plumbing_item in plumbing_response.history: 8726 yield plumbing.convert_workflow_role_history_to_porcelain( 8727 plumbing_item) 8728 if plumbing_response.meta.next_cursor == '': 8729 break 8730 req.meta.cursor = plumbing_response.meta.next_cursor 8731 8732 return generator(self, req)
WorkflowRolesHistory provides records of all changes to the state of a WorkflowRole
See strongdm.models.WorkflowRoleHistory.
def
list(self, filter, *args, timeout=None)
8693 def list(self, filter, *args, timeout=None): 8694 ''' 8695 List gets a list of WorkflowRolesHistory records matching a given set of criteria. 8696 ''' 8697 deadline = None if timeout is None else time.time() + timeout 8698 req = WorkflowRolesHistoryListRequest() 8699 req.meta.CopyFrom(ListRequestMetadata()) 8700 if self.parent.page_limit > 0: 8701 req.meta.limit = self.parent.page_limit 8702 if self.parent.snapshot_datetime is not None: 8703 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8704 8705 req.filter = plumbing.quote_filter_args(filter, *args) 8706 8707 def generator(svc, req): 8708 tries = 0 8709 while True: 8710 t = None if deadline is None else deadline - time.time() 8711 try: 8712 plumbing_response = svc.stub.List( 8713 req, 8714 metadata=svc.parent.get_metadata( 8715 'WorkflowRolesHistory.List', req), 8716 timeout=t) 8717 except Exception as e: 8718 if self.parent.shouldRetry(tries, e, deadline): 8719 tries += 1 8720 time.sleep( 8721 self.parent.exponentialBackoff(tries, deadline)) 8722 continue 8723 raise plumbing.convert_error_to_porcelain(e) from e 8724 tries = 0 8725 for plumbing_item in plumbing_response.history: 8726 yield plumbing.convert_workflow_role_history_to_porcelain( 8727 plumbing_item) 8728 if plumbing_response.meta.next_cursor == '': 8729 break 8730 req.meta.cursor = plumbing_response.meta.next_cursor 8731 8732 return generator(self, req)
List gets a list of WorkflowRolesHistory records matching a given set of criteria.
class
Workflows:
8735class Workflows: 8736 ''' 8737 Workflows are the collection of rules that define the resources to which access can be requested, 8738 the users that can request that access, and the mechanism for approving those requests which can either 8739 be automatic approval or a set of users authorized to approve the requests. 8740 See `strongdm.models.Workflow`. 8741 ''' 8742 def __init__(self, channel, client): 8743 self.parent = client 8744 self.stub = WorkflowsStub(channel) 8745 8746 def create(self, workflow, timeout=None): 8747 ''' 8748 Create creates a new workflow and requires a name for the workflow. 8749 ''' 8750 deadline = None if timeout is None else time.time() + timeout 8751 req = WorkflowCreateRequest() 8752 8753 if workflow is not None: 8754 req.workflow.CopyFrom( 8755 plumbing.convert_workflow_to_plumbing(workflow)) 8756 tries = 0 8757 plumbing_response = None 8758 while True: 8759 t = None if deadline is None else deadline - time.time() 8760 try: 8761 plumbing_response = self.stub.Create( 8762 req, 8763 metadata=self.parent.get_metadata('Workflows.Create', req), 8764 timeout=t) 8765 except Exception as e: 8766 if self.parent.shouldRetry(tries, e, deadline): 8767 tries += 1 8768 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8769 continue 8770 raise plumbing.convert_error_to_porcelain(e) from e 8771 break 8772 8773 resp = models.WorkflowCreateResponse() 8774 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8775 plumbing_response.rate_limit) 8776 resp.workflow = plumbing.convert_workflow_to_porcelain( 8777 plumbing_response.workflow) 8778 return resp 8779 8780 def get(self, id, timeout=None): 8781 ''' 8782 Get reads one workflow by ID. 8783 ''' 8784 deadline = None if timeout is None else time.time() + timeout 8785 req = WorkflowGetRequest() 8786 if self.parent.snapshot_datetime is not None: 8787 req.meta.CopyFrom(GetRequestMetadata()) 8788 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8789 8790 req.id = (id) 8791 tries = 0 8792 plumbing_response = None 8793 while True: 8794 t = None if deadline is None else deadline - time.time() 8795 try: 8796 plumbing_response = self.stub.Get( 8797 req, 8798 metadata=self.parent.get_metadata('Workflows.Get', req), 8799 timeout=t) 8800 except Exception as e: 8801 if self.parent.shouldRetry(tries, e, deadline): 8802 tries += 1 8803 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8804 continue 8805 raise plumbing.convert_error_to_porcelain(e) from e 8806 break 8807 8808 resp = models.WorkflowGetResponse() 8809 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 8810 plumbing_response.meta) 8811 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8812 plumbing_response.rate_limit) 8813 resp.workflow = plumbing.convert_workflow_to_porcelain( 8814 plumbing_response.workflow) 8815 return resp 8816 8817 def delete(self, id, timeout=None): 8818 ''' 8819 Delete deletes an existing workflow. 8820 ''' 8821 deadline = None if timeout is None else time.time() + timeout 8822 req = WorkflowDeleteRequest() 8823 8824 req.id = (id) 8825 tries = 0 8826 plumbing_response = None 8827 while True: 8828 t = None if deadline is None else deadline - time.time() 8829 try: 8830 plumbing_response = self.stub.Delete( 8831 req, 8832 metadata=self.parent.get_metadata('Workflows.Delete', req), 8833 timeout=t) 8834 except Exception as e: 8835 if self.parent.shouldRetry(tries, e, deadline): 8836 tries += 1 8837 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8838 continue 8839 raise plumbing.convert_error_to_porcelain(e) from e 8840 break 8841 8842 resp = models.WorkflowDeleteResponse() 8843 resp.id = (plumbing_response.id) 8844 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8845 plumbing_response.rate_limit) 8846 return resp 8847 8848 def update(self, workflow, timeout=None): 8849 ''' 8850 Update updates an existing workflow. 8851 ''' 8852 deadline = None if timeout is None else time.time() + timeout 8853 req = WorkflowUpdateRequest() 8854 8855 if workflow is not None: 8856 req.workflow.CopyFrom( 8857 plumbing.convert_workflow_to_plumbing(workflow)) 8858 tries = 0 8859 plumbing_response = None 8860 while True: 8861 t = None if deadline is None else deadline - time.time() 8862 try: 8863 plumbing_response = self.stub.Update( 8864 req, 8865 metadata=self.parent.get_metadata('Workflows.Update', req), 8866 timeout=t) 8867 except Exception as e: 8868 if self.parent.shouldRetry(tries, e, deadline): 8869 tries += 1 8870 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8871 continue 8872 raise plumbing.convert_error_to_porcelain(e) from e 8873 break 8874 8875 resp = models.WorkflowUpdateResponse() 8876 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8877 plumbing_response.rate_limit) 8878 resp.workflow = plumbing.convert_workflow_to_porcelain( 8879 plumbing_response.workflow) 8880 return resp 8881 8882 def list(self, filter, *args, timeout=None): 8883 ''' 8884 Lists existing workflows. 8885 ''' 8886 deadline = None if timeout is None else time.time() + timeout 8887 req = WorkflowListRequest() 8888 req.meta.CopyFrom(ListRequestMetadata()) 8889 if self.parent.page_limit > 0: 8890 req.meta.limit = self.parent.page_limit 8891 if self.parent.snapshot_datetime is not None: 8892 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8893 8894 req.filter = plumbing.quote_filter_args(filter, *args) 8895 8896 def generator(svc, req): 8897 tries = 0 8898 while True: 8899 t = None if deadline is None else deadline - time.time() 8900 try: 8901 plumbing_response = svc.stub.List( 8902 req, 8903 metadata=svc.parent.get_metadata( 8904 'Workflows.List', req), 8905 timeout=t) 8906 except Exception as e: 8907 if self.parent.shouldRetry(tries, e, deadline): 8908 tries += 1 8909 time.sleep( 8910 self.parent.exponentialBackoff(tries, deadline)) 8911 continue 8912 raise plumbing.convert_error_to_porcelain(e) from e 8913 tries = 0 8914 for plumbing_item in plumbing_response.workflows: 8915 yield plumbing.convert_workflow_to_porcelain(plumbing_item) 8916 if plumbing_response.meta.next_cursor == '': 8917 break 8918 req.meta.cursor = plumbing_response.meta.next_cursor 8919 8920 return generator(self, req)
Workflows are the collection of rules that define the resources to which access can be requested,
the users that can request that access, and the mechanism for approving those requests which can either
be automatic approval or a set of users authorized to approve the requests.
See strongdm.models.Workflow.
def
create(self, workflow, timeout=None)
8746 def create(self, workflow, timeout=None): 8747 ''' 8748 Create creates a new workflow and requires a name for the workflow. 8749 ''' 8750 deadline = None if timeout is None else time.time() + timeout 8751 req = WorkflowCreateRequest() 8752 8753 if workflow is not None: 8754 req.workflow.CopyFrom( 8755 plumbing.convert_workflow_to_plumbing(workflow)) 8756 tries = 0 8757 plumbing_response = None 8758 while True: 8759 t = None if deadline is None else deadline - time.time() 8760 try: 8761 plumbing_response = self.stub.Create( 8762 req, 8763 metadata=self.parent.get_metadata('Workflows.Create', req), 8764 timeout=t) 8765 except Exception as e: 8766 if self.parent.shouldRetry(tries, e, deadline): 8767 tries += 1 8768 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8769 continue 8770 raise plumbing.convert_error_to_porcelain(e) from e 8771 break 8772 8773 resp = models.WorkflowCreateResponse() 8774 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8775 plumbing_response.rate_limit) 8776 resp.workflow = plumbing.convert_workflow_to_porcelain( 8777 plumbing_response.workflow) 8778 return resp
Create creates a new workflow and requires a name for the workflow.
def
get(self, id, timeout=None)
8780 def get(self, id, timeout=None): 8781 ''' 8782 Get reads one workflow by ID. 8783 ''' 8784 deadline = None if timeout is None else time.time() + timeout 8785 req = WorkflowGetRequest() 8786 if self.parent.snapshot_datetime is not None: 8787 req.meta.CopyFrom(GetRequestMetadata()) 8788 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8789 8790 req.id = (id) 8791 tries = 0 8792 plumbing_response = None 8793 while True: 8794 t = None if deadline is None else deadline - time.time() 8795 try: 8796 plumbing_response = self.stub.Get( 8797 req, 8798 metadata=self.parent.get_metadata('Workflows.Get', req), 8799 timeout=t) 8800 except Exception as e: 8801 if self.parent.shouldRetry(tries, e, deadline): 8802 tries += 1 8803 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8804 continue 8805 raise plumbing.convert_error_to_porcelain(e) from e 8806 break 8807 8808 resp = models.WorkflowGetResponse() 8809 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 8810 plumbing_response.meta) 8811 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8812 plumbing_response.rate_limit) 8813 resp.workflow = plumbing.convert_workflow_to_porcelain( 8814 plumbing_response.workflow) 8815 return resp
Get reads one workflow by ID.
def
delete(self, id, timeout=None)
8817 def delete(self, id, timeout=None): 8818 ''' 8819 Delete deletes an existing workflow. 8820 ''' 8821 deadline = None if timeout is None else time.time() + timeout 8822 req = WorkflowDeleteRequest() 8823 8824 req.id = (id) 8825 tries = 0 8826 plumbing_response = None 8827 while True: 8828 t = None if deadline is None else deadline - time.time() 8829 try: 8830 plumbing_response = self.stub.Delete( 8831 req, 8832 metadata=self.parent.get_metadata('Workflows.Delete', req), 8833 timeout=t) 8834 except Exception as e: 8835 if self.parent.shouldRetry(tries, e, deadline): 8836 tries += 1 8837 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8838 continue 8839 raise plumbing.convert_error_to_porcelain(e) from e 8840 break 8841 8842 resp = models.WorkflowDeleteResponse() 8843 resp.id = (plumbing_response.id) 8844 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8845 plumbing_response.rate_limit) 8846 return resp
Delete deletes an existing workflow.
def
update(self, workflow, timeout=None)
8848 def update(self, workflow, timeout=None): 8849 ''' 8850 Update updates an existing workflow. 8851 ''' 8852 deadline = None if timeout is None else time.time() + timeout 8853 req = WorkflowUpdateRequest() 8854 8855 if workflow is not None: 8856 req.workflow.CopyFrom( 8857 plumbing.convert_workflow_to_plumbing(workflow)) 8858 tries = 0 8859 plumbing_response = None 8860 while True: 8861 t = None if deadline is None else deadline - time.time() 8862 try: 8863 plumbing_response = self.stub.Update( 8864 req, 8865 metadata=self.parent.get_metadata('Workflows.Update', req), 8866 timeout=t) 8867 except Exception as e: 8868 if self.parent.shouldRetry(tries, e, deadline): 8869 tries += 1 8870 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8871 continue 8872 raise plumbing.convert_error_to_porcelain(e) from e 8873 break 8874 8875 resp = models.WorkflowUpdateResponse() 8876 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8877 plumbing_response.rate_limit) 8878 resp.workflow = plumbing.convert_workflow_to_porcelain( 8879 plumbing_response.workflow) 8880 return resp
Update updates an existing workflow.
def
list(self, filter, *args, timeout=None)
8882 def list(self, filter, *args, timeout=None): 8883 ''' 8884 Lists existing workflows. 8885 ''' 8886 deadline = None if timeout is None else time.time() + timeout 8887 req = WorkflowListRequest() 8888 req.meta.CopyFrom(ListRequestMetadata()) 8889 if self.parent.page_limit > 0: 8890 req.meta.limit = self.parent.page_limit 8891 if self.parent.snapshot_datetime is not None: 8892 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8893 8894 req.filter = plumbing.quote_filter_args(filter, *args) 8895 8896 def generator(svc, req): 8897 tries = 0 8898 while True: 8899 t = None if deadline is None else deadline - time.time() 8900 try: 8901 plumbing_response = svc.stub.List( 8902 req, 8903 metadata=svc.parent.get_metadata( 8904 'Workflows.List', req), 8905 timeout=t) 8906 except Exception as e: 8907 if self.parent.shouldRetry(tries, e, deadline): 8908 tries += 1 8909 time.sleep( 8910 self.parent.exponentialBackoff(tries, deadline)) 8911 continue 8912 raise plumbing.convert_error_to_porcelain(e) from e 8913 tries = 0 8914 for plumbing_item in plumbing_response.workflows: 8915 yield plumbing.convert_workflow_to_porcelain(plumbing_item) 8916 if plumbing_response.meta.next_cursor == '': 8917 break 8918 req.meta.cursor = plumbing_response.meta.next_cursor 8919 8920 return generator(self, req)
Lists existing workflows.
class
SnapshotWorkflows:
8923class SnapshotWorkflows: 8924 ''' 8925 SnapshotWorkflows exposes the read only methods of the Workflows 8926 service for historical queries. 8927 ''' 8928 def __init__(self, workflows): 8929 self.workflows = workflows 8930 8931 def get(self, id, timeout=None): 8932 ''' 8933 Get reads one workflow by ID. 8934 ''' 8935 return self.workflows.get(id, timeout=timeout) 8936 8937 def list(self, filter, *args, timeout=None): 8938 ''' 8939 Lists existing workflows. 8940 ''' 8941 return self.workflows.list(filter, *args, timeout=timeout)
SnapshotWorkflows exposes the read only methods of the Workflows service for historical queries.
class
WorkflowsHistory:
8944class WorkflowsHistory: 8945 ''' 8946 WorkflowsHistory provides records of all changes to the state of a Workflow. 8947 See `strongdm.models.WorkflowHistory`. 8948 ''' 8949 def __init__(self, channel, client): 8950 self.parent = client 8951 self.stub = WorkflowsHistoryStub(channel) 8952 8953 def list(self, filter, *args, timeout=None): 8954 ''' 8955 List gets a list of WorkflowHistory records matching a given set of criteria. 8956 ''' 8957 deadline = None if timeout is None else time.time() + timeout 8958 req = WorkflowHistoryListRequest() 8959 req.meta.CopyFrom(ListRequestMetadata()) 8960 if self.parent.page_limit > 0: 8961 req.meta.limit = self.parent.page_limit 8962 if self.parent.snapshot_datetime is not None: 8963 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8964 8965 req.filter = plumbing.quote_filter_args(filter, *args) 8966 8967 def generator(svc, req): 8968 tries = 0 8969 while True: 8970 t = None if deadline is None else deadline - time.time() 8971 try: 8972 plumbing_response = svc.stub.List( 8973 req, 8974 metadata=svc.parent.get_metadata( 8975 'WorkflowsHistory.List', req), 8976 timeout=t) 8977 except Exception as e: 8978 if self.parent.shouldRetry(tries, e, deadline): 8979 tries += 1 8980 time.sleep( 8981 self.parent.exponentialBackoff(tries, deadline)) 8982 continue 8983 raise plumbing.convert_error_to_porcelain(e) from e 8984 tries = 0 8985 for plumbing_item in plumbing_response.history: 8986 yield plumbing.convert_workflow_history_to_porcelain( 8987 plumbing_item) 8988 if plumbing_response.meta.next_cursor == '': 8989 break 8990 req.meta.cursor = plumbing_response.meta.next_cursor 8991 8992 return generator(self, req)
WorkflowsHistory provides records of all changes to the state of a Workflow.
See strongdm.models.WorkflowHistory.
def
list(self, filter, *args, timeout=None)
8953 def list(self, filter, *args, timeout=None): 8954 ''' 8955 List gets a list of WorkflowHistory records matching a given set of criteria. 8956 ''' 8957 deadline = None if timeout is None else time.time() + timeout 8958 req = WorkflowHistoryListRequest() 8959 req.meta.CopyFrom(ListRequestMetadata()) 8960 if self.parent.page_limit > 0: 8961 req.meta.limit = self.parent.page_limit 8962 if self.parent.snapshot_datetime is not None: 8963 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8964 8965 req.filter = plumbing.quote_filter_args(filter, *args) 8966 8967 def generator(svc, req): 8968 tries = 0 8969 while True: 8970 t = None if deadline is None else deadline - time.time() 8971 try: 8972 plumbing_response = svc.stub.List( 8973 req, 8974 metadata=svc.parent.get_metadata( 8975 'WorkflowsHistory.List', req), 8976 timeout=t) 8977 except Exception as e: 8978 if self.parent.shouldRetry(tries, e, deadline): 8979 tries += 1 8980 time.sleep( 8981 self.parent.exponentialBackoff(tries, deadline)) 8982 continue 8983 raise plumbing.convert_error_to_porcelain(e) from e 8984 tries = 0 8985 for plumbing_item in plumbing_response.history: 8986 yield plumbing.convert_workflow_history_to_porcelain( 8987 plumbing_item) 8988 if plumbing_response.meta.next_cursor == '': 8989 break 8990 req.meta.cursor = plumbing_response.meta.next_cursor 8991 8992 return generator(self, req)
List gets a list of WorkflowHistory records matching a given set of criteria.