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.GoogleSpanner` 6999 `strongdm.models.Greenplum` 7000 `strongdm.models.HTTPAuth` 7001 `strongdm.models.HTTPBasicAuth` 7002 `strongdm.models.HTTPNoAuth` 7003 `strongdm.models.Kubernetes` 7004 `strongdm.models.KubernetesBasicAuth` 7005 `strongdm.models.KubernetesPodIdentity` 7006 `strongdm.models.KubernetesServiceAccount` 7007 `strongdm.models.KubernetesServiceAccountUserImpersonation` 7008 `strongdm.models.KubernetesUserImpersonation` 7009 `strongdm.models.LLM` 7010 `strongdm.models.Maria` 7011 `strongdm.models.MCPGatewayNoAuth` 7012 `strongdm.models.MCPGatewayOAuth` 7013 `strongdm.models.MCPGatewayOAuthDCR` 7014 `strongdm.models.MCPGatewayPAT` 7015 `strongdm.models.Memcached` 7016 `strongdm.models.Memsql` 7017 `strongdm.models.MongoHost` 7018 `strongdm.models.MongoLegacyHost` 7019 `strongdm.models.MongoLegacyReplicaset` 7020 `strongdm.models.MongoReplicaSet` 7021 `strongdm.models.MongoShardedCluster` 7022 `strongdm.models.MTLSMysql` 7023 `strongdm.models.MTLSPostgres` 7024 `strongdm.models.Mysql` 7025 `strongdm.models.Neptune` 7026 `strongdm.models.NeptuneIAM` 7027 `strongdm.models.OktaGroups` 7028 `strongdm.models.Oracle` 7029 `strongdm.models.OracleNNE` 7030 `strongdm.models.Postgres` 7031 `strongdm.models.Presto` 7032 `strongdm.models.RabbitMQAMQP091` 7033 `strongdm.models.RawTCP` 7034 `strongdm.models.RDP` 7035 `strongdm.models.RDPCert` 7036 `strongdm.models.RDSPostgresIAM` 7037 `strongdm.models.Redis` 7038 `strongdm.models.RedisCluster` 7039 `strongdm.models.Redshift` 7040 `strongdm.models.RedshiftIAM` 7041 `strongdm.models.RedshiftServerlessIAM` 7042 `strongdm.models.SingleStore` 7043 `strongdm.models.Snowflake` 7044 `strongdm.models.Snowsight` 7045 `strongdm.models.SQLServer` 7046 `strongdm.models.SQLServerAzureAD` 7047 `strongdm.models.SQLServerKerberosAD` 7048 `strongdm.models.SSH` 7049 `strongdm.models.SSHCert` 7050 `strongdm.models.SSHCustomerKey` 7051 `strongdm.models.SSHPassword` 7052 `strongdm.models.Sybase` 7053 `strongdm.models.SybaseIQ` 7054 `strongdm.models.Teradata` 7055 `strongdm.models.Trino` 7056 `strongdm.models.Vertica` 7057 ''' 7058 def __init__(self, channel, client): 7059 self.parent = client 7060 self.stub = ResourcesStub(channel) 7061 7062 def enumerate_tags(self, filter, *args, timeout=None): 7063 ''' 7064 EnumerateTags gets a list of the filter matching tags. 7065 ''' 7066 deadline = None if timeout is None else time.time() + timeout 7067 req = EnumerateTagsRequest() 7068 req.meta.CopyFrom(ListRequestMetadata()) 7069 if self.parent.page_limit > 0: 7070 req.meta.limit = self.parent.page_limit 7071 if self.parent.snapshot_datetime is not None: 7072 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7073 7074 req.filter = plumbing.quote_filter_args(filter, *args) 7075 7076 def generator(svc, req): 7077 tries = 0 7078 while True: 7079 t = None if deadline is None else deadline - time.time() 7080 try: 7081 plumbing_response = svc.stub.EnumerateTags( 7082 req, 7083 metadata=svc.parent.get_metadata( 7084 'Resources.EnumerateTags', req), 7085 timeout=t) 7086 except Exception as e: 7087 if self.parent.shouldRetry(tries, e, deadline): 7088 tries += 1 7089 time.sleep( 7090 self.parent.exponentialBackoff(tries, deadline)) 7091 continue 7092 raise plumbing.convert_error_to_porcelain(e) from e 7093 tries = 0 7094 for plumbing_item in plumbing_response.matches: 7095 yield plumbing.convert_tag_to_porcelain(plumbing_item) 7096 if plumbing_response.meta.next_cursor == '': 7097 break 7098 req.meta.cursor = plumbing_response.meta.next_cursor 7099 7100 return generator(self, req) 7101 7102 def create(self, resource, timeout=None): 7103 ''' 7104 Create registers a new Resource. 7105 ''' 7106 deadline = None if timeout is None else time.time() + timeout 7107 req = ResourceCreateRequest() 7108 7109 if resource is not None: 7110 req.resource.CopyFrom( 7111 plumbing.convert_resource_to_plumbing(resource)) 7112 tries = 0 7113 plumbing_response = None 7114 while True: 7115 t = None if deadline is None else deadline - time.time() 7116 try: 7117 plumbing_response = self.stub.Create( 7118 req, 7119 metadata=self.parent.get_metadata('Resources.Create', req), 7120 timeout=t) 7121 except Exception as e: 7122 if self.parent.shouldRetry(tries, e, deadline): 7123 tries += 1 7124 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7125 continue 7126 raise plumbing.convert_error_to_porcelain(e) from e 7127 break 7128 7129 resp = models.ResourceCreateResponse() 7130 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 7131 plumbing_response.meta) 7132 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7133 plumbing_response.rate_limit) 7134 resp.resource = plumbing.convert_resource_to_porcelain( 7135 plumbing_response.resource) 7136 return resp 7137 7138 def get(self, id, timeout=None): 7139 ''' 7140 Get reads one Resource by ID. 7141 ''' 7142 deadline = None if timeout is None else time.time() + timeout 7143 req = ResourceGetRequest() 7144 if self.parent.snapshot_datetime is not None: 7145 req.meta.CopyFrom(GetRequestMetadata()) 7146 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7147 7148 req.id = (id) 7149 tries = 0 7150 plumbing_response = None 7151 while True: 7152 t = None if deadline is None else deadline - time.time() 7153 try: 7154 plumbing_response = self.stub.Get( 7155 req, 7156 metadata=self.parent.get_metadata('Resources.Get', req), 7157 timeout=t) 7158 except Exception as e: 7159 if self.parent.shouldRetry(tries, e, deadline): 7160 tries += 1 7161 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7162 continue 7163 raise plumbing.convert_error_to_porcelain(e) from e 7164 break 7165 7166 resp = models.ResourceGetResponse() 7167 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 7168 plumbing_response.meta) 7169 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7170 plumbing_response.rate_limit) 7171 resp.resource = plumbing.convert_resource_to_porcelain( 7172 plumbing_response.resource) 7173 return resp 7174 7175 def update(self, resource, timeout=None): 7176 ''' 7177 Update replaces all the fields of a Resource by ID. 7178 ''' 7179 deadline = None if timeout is None else time.time() + timeout 7180 req = ResourceUpdateRequest() 7181 7182 if resource is not None: 7183 req.resource.CopyFrom( 7184 plumbing.convert_resource_to_plumbing(resource)) 7185 tries = 0 7186 plumbing_response = None 7187 while True: 7188 t = None if deadline is None else deadline - time.time() 7189 try: 7190 plumbing_response = self.stub.Update( 7191 req, 7192 metadata=self.parent.get_metadata('Resources.Update', req), 7193 timeout=t) 7194 except Exception as e: 7195 if self.parent.shouldRetry(tries, e, deadline): 7196 tries += 1 7197 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7198 continue 7199 raise plumbing.convert_error_to_porcelain(e) from e 7200 break 7201 7202 resp = models.ResourceUpdateResponse() 7203 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 7204 plumbing_response.meta) 7205 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7206 plumbing_response.rate_limit) 7207 resp.resource = plumbing.convert_resource_to_porcelain( 7208 plumbing_response.resource) 7209 return resp 7210 7211 def delete(self, id, timeout=None): 7212 ''' 7213 Delete removes a Resource by ID. 7214 ''' 7215 deadline = None if timeout is None else time.time() + timeout 7216 req = ResourceDeleteRequest() 7217 7218 req.id = (id) 7219 tries = 0 7220 plumbing_response = None 7221 while True: 7222 t = None if deadline is None else deadline - time.time() 7223 try: 7224 plumbing_response = self.stub.Delete( 7225 req, 7226 metadata=self.parent.get_metadata('Resources.Delete', req), 7227 timeout=t) 7228 except Exception as e: 7229 if self.parent.shouldRetry(tries, e, deadline): 7230 tries += 1 7231 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7232 continue 7233 raise plumbing.convert_error_to_porcelain(e) from e 7234 break 7235 7236 resp = models.ResourceDeleteResponse() 7237 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 7238 plumbing_response.meta) 7239 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7240 plumbing_response.rate_limit) 7241 return resp 7242 7243 def list(self, filter, *args, timeout=None): 7244 ''' 7245 List gets a list of Resources matching a given set of criteria. 7246 ''' 7247 deadline = None if timeout is None else time.time() + timeout 7248 req = ResourceListRequest() 7249 req.meta.CopyFrom(ListRequestMetadata()) 7250 if self.parent.page_limit > 0: 7251 req.meta.limit = self.parent.page_limit 7252 if self.parent.snapshot_datetime is not None: 7253 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7254 7255 req.filter = plumbing.quote_filter_args(filter, *args) 7256 7257 def generator(svc, req): 7258 tries = 0 7259 while True: 7260 t = None if deadline is None else deadline - time.time() 7261 try: 7262 plumbing_response = svc.stub.List( 7263 req, 7264 metadata=svc.parent.get_metadata( 7265 'Resources.List', req), 7266 timeout=t) 7267 except Exception as e: 7268 if self.parent.shouldRetry(tries, e, deadline): 7269 tries += 1 7270 time.sleep( 7271 self.parent.exponentialBackoff(tries, deadline)) 7272 continue 7273 raise plumbing.convert_error_to_porcelain(e) from e 7274 tries = 0 7275 for plumbing_item in plumbing_response.resources: 7276 yield plumbing.convert_resource_to_porcelain(plumbing_item) 7277 if plumbing_response.meta.next_cursor == '': 7278 break 7279 req.meta.cursor = plumbing_response.meta.next_cursor 7280 7281 return generator(self, req) 7282 7283 def healthcheck(self, id, timeout=None): 7284 ''' 7285 Healthcheck triggers a remote healthcheck. It may take minutes to propagate across a 7286 large network of Nodes. The call will return immediately, and the updated health of the 7287 Resource can be retrieved via Get or List. 7288 ''' 7289 deadline = None if timeout is None else time.time() + timeout 7290 req = ResourceHealthcheckRequest() 7291 7292 req.id = (id) 7293 tries = 0 7294 plumbing_response = None 7295 while True: 7296 t = None if deadline is None else deadline - time.time() 7297 try: 7298 plumbing_response = self.stub.Healthcheck( 7299 req, 7300 metadata=self.parent.get_metadata('Resources.Healthcheck', 7301 req), 7302 timeout=t) 7303 except Exception as e: 7304 if self.parent.shouldRetry(tries, e, deadline): 7305 tries += 1 7306 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7307 continue 7308 raise plumbing.convert_error_to_porcelain(e) from e 7309 break 7310 7311 resp = models.ResourceHealthcheckResponse() 7312 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 7313 plumbing_response.meta) 7314 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7315 plumbing_response.rate_limit) 7316 return resp 7317 7318 7319class SnapshotResources: 7320 ''' 7321 SnapshotResources exposes the read only methods of the Resources 7322 service for historical queries. 7323 ''' 7324 def __init__(self, resources): 7325 self.resources = resources 7326 7327 def get(self, id, timeout=None): 7328 ''' 7329 Get reads one Resource by ID. 7330 ''' 7331 return self.resources.get(id, timeout=timeout) 7332 7333 def list(self, filter, *args, timeout=None): 7334 ''' 7335 List gets a list of Resources matching a given set of criteria. 7336 ''' 7337 return self.resources.list(filter, *args, timeout=timeout) 7338 7339 7340class ResourcesHistory: 7341 ''' 7342 ResourcesHistory records all changes to the state of a Resource. 7343 See `strongdm.models.ResourceHistory`. 7344 ''' 7345 def __init__(self, channel, client): 7346 self.parent = client 7347 self.stub = ResourcesHistoryStub(channel) 7348 7349 def list(self, filter, *args, timeout=None): 7350 ''' 7351 List gets a list of ResourceHistory records matching a given set of criteria. 7352 ''' 7353 deadline = None if timeout is None else time.time() + timeout 7354 req = ResourceHistoryListRequest() 7355 req.meta.CopyFrom(ListRequestMetadata()) 7356 if self.parent.page_limit > 0: 7357 req.meta.limit = self.parent.page_limit 7358 if self.parent.snapshot_datetime is not None: 7359 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7360 7361 req.filter = plumbing.quote_filter_args(filter, *args) 7362 7363 def generator(svc, req): 7364 tries = 0 7365 while True: 7366 t = None if deadline is None else deadline - time.time() 7367 try: 7368 plumbing_response = svc.stub.List( 7369 req, 7370 metadata=svc.parent.get_metadata( 7371 'ResourcesHistory.List', req), 7372 timeout=t) 7373 except Exception as e: 7374 if self.parent.shouldRetry(tries, e, deadline): 7375 tries += 1 7376 time.sleep( 7377 self.parent.exponentialBackoff(tries, deadline)) 7378 continue 7379 raise plumbing.convert_error_to_porcelain(e) from e 7380 tries = 0 7381 for plumbing_item in plumbing_response.history: 7382 yield plumbing.convert_resource_history_to_porcelain( 7383 plumbing_item) 7384 if plumbing_response.meta.next_cursor == '': 7385 break 7386 req.meta.cursor = plumbing_response.meta.next_cursor 7387 7388 return generator(self, req) 7389 7390 7391class RoleResources: 7392 ''' 7393 RoleResources enumerates the resources to which roles have access. 7394 The RoleResources service is read-only. 7395 See `strongdm.models.RoleResource`. 7396 ''' 7397 def __init__(self, channel, client): 7398 self.parent = client 7399 self.stub = RoleResourcesStub(channel) 7400 7401 def list(self, filter, *args, timeout=None): 7402 ''' 7403 List gets a list of RoleResource records matching a given set of criteria. 7404 ''' 7405 deadline = None if timeout is None else time.time() + timeout 7406 req = RoleResourceListRequest() 7407 req.meta.CopyFrom(ListRequestMetadata()) 7408 if self.parent.page_limit > 0: 7409 req.meta.limit = self.parent.page_limit 7410 if self.parent.snapshot_datetime is not None: 7411 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7412 7413 req.filter = plumbing.quote_filter_args(filter, *args) 7414 7415 def generator(svc, req): 7416 tries = 0 7417 while True: 7418 t = None if deadline is None else deadline - time.time() 7419 try: 7420 plumbing_response = svc.stub.List( 7421 req, 7422 metadata=svc.parent.get_metadata( 7423 'RoleResources.List', req), 7424 timeout=t) 7425 except Exception as e: 7426 if self.parent.shouldRetry(tries, e, deadline): 7427 tries += 1 7428 time.sleep( 7429 self.parent.exponentialBackoff(tries, deadline)) 7430 continue 7431 raise plumbing.convert_error_to_porcelain(e) from e 7432 tries = 0 7433 for plumbing_item in plumbing_response.role_resources: 7434 yield plumbing.convert_role_resource_to_porcelain( 7435 plumbing_item) 7436 if plumbing_response.meta.next_cursor == '': 7437 break 7438 req.meta.cursor = plumbing_response.meta.next_cursor 7439 7440 return generator(self, req) 7441 7442 7443class SnapshotRoleResources: 7444 ''' 7445 SnapshotRoleResources exposes the read only methods of the RoleResources 7446 service for historical queries. 7447 ''' 7448 def __init__(self, role_resources): 7449 self.role_resources = role_resources 7450 7451 def list(self, filter, *args, timeout=None): 7452 ''' 7453 List gets a list of RoleResource records matching a given set of criteria. 7454 ''' 7455 return self.role_resources.list(filter, *args, timeout=timeout) 7456 7457 7458class RoleResourcesHistory: 7459 ''' 7460 RoleResourcesHistory records all changes to the state of a RoleResource. 7461 See `strongdm.models.RoleResourceHistory`. 7462 ''' 7463 def __init__(self, channel, client): 7464 self.parent = client 7465 self.stub = RoleResourcesHistoryStub(channel) 7466 7467 def list(self, filter, *args, timeout=None): 7468 ''' 7469 List gets a list of RoleResourceHistory records matching a given set of criteria. 7470 ''' 7471 deadline = None if timeout is None else time.time() + timeout 7472 req = RoleResourceHistoryListRequest() 7473 req.meta.CopyFrom(ListRequestMetadata()) 7474 if self.parent.page_limit > 0: 7475 req.meta.limit = self.parent.page_limit 7476 if self.parent.snapshot_datetime is not None: 7477 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7478 7479 req.filter = plumbing.quote_filter_args(filter, *args) 7480 7481 def generator(svc, req): 7482 tries = 0 7483 while True: 7484 t = None if deadline is None else deadline - time.time() 7485 try: 7486 plumbing_response = svc.stub.List( 7487 req, 7488 metadata=svc.parent.get_metadata( 7489 'RoleResourcesHistory.List', req), 7490 timeout=t) 7491 except Exception as e: 7492 if self.parent.shouldRetry(tries, e, deadline): 7493 tries += 1 7494 time.sleep( 7495 self.parent.exponentialBackoff(tries, deadline)) 7496 continue 7497 raise plumbing.convert_error_to_porcelain(e) from e 7498 tries = 0 7499 for plumbing_item in plumbing_response.history: 7500 yield plumbing.convert_role_resource_history_to_porcelain( 7501 plumbing_item) 7502 if plumbing_response.meta.next_cursor == '': 7503 break 7504 req.meta.cursor = plumbing_response.meta.next_cursor 7505 7506 return generator(self, req) 7507 7508 7509class RolesHistory: 7510 ''' 7511 RolesHistory records all changes to the state of a Role. 7512 See `strongdm.models.RoleHistory`. 7513 ''' 7514 def __init__(self, channel, client): 7515 self.parent = client 7516 self.stub = RolesHistoryStub(channel) 7517 7518 def list(self, filter, *args, timeout=None): 7519 ''' 7520 List gets a list of RoleHistory records matching a given set of criteria. 7521 ''' 7522 deadline = None if timeout is None else time.time() + timeout 7523 req = RoleHistoryListRequest() 7524 req.meta.CopyFrom(ListRequestMetadata()) 7525 if self.parent.page_limit > 0: 7526 req.meta.limit = self.parent.page_limit 7527 if self.parent.snapshot_datetime is not None: 7528 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7529 7530 req.filter = plumbing.quote_filter_args(filter, *args) 7531 7532 def generator(svc, req): 7533 tries = 0 7534 while True: 7535 t = None if deadline is None else deadline - time.time() 7536 try: 7537 plumbing_response = svc.stub.List( 7538 req, 7539 metadata=svc.parent.get_metadata( 7540 'RolesHistory.List', req), 7541 timeout=t) 7542 except Exception as e: 7543 if self.parent.shouldRetry(tries, e, deadline): 7544 tries += 1 7545 time.sleep( 7546 self.parent.exponentialBackoff(tries, deadline)) 7547 continue 7548 raise plumbing.convert_error_to_porcelain(e) from e 7549 tries = 0 7550 for plumbing_item in plumbing_response.history: 7551 yield plumbing.convert_role_history_to_porcelain( 7552 plumbing_item) 7553 if plumbing_response.meta.next_cursor == '': 7554 break 7555 req.meta.cursor = plumbing_response.meta.next_cursor 7556 7557 return generator(self, req) 7558 7559 7560class SecretStores: 7561 ''' 7562 SecretStores are servers where resource secrets (passwords, keys) are stored. 7563 See: 7564 `strongdm.models.ActiveDirectoryStore` 7565 `strongdm.models.AWSStore` 7566 `strongdm.models.AWSCertX509Store` 7567 `strongdm.models.AzureStore` 7568 `strongdm.models.CyberarkConjurStore` 7569 `strongdm.models.CyberarkPAMStore` 7570 `strongdm.models.CyberarkPAMExperimentalStore` 7571 `strongdm.models.DelineaStore` 7572 `strongdm.models.GCPStore` 7573 `strongdm.models.GCPCertX509Store` 7574 `strongdm.models.KeyfactorSSHStore` 7575 `strongdm.models.KeyfactorX509Store` 7576 `strongdm.models.StrongVaultStore` 7577 `strongdm.models.VaultAppRoleStore` 7578 `strongdm.models.VaultAppRoleCertSSHStore` 7579 `strongdm.models.VaultAppRoleCertX509Store` 7580 `strongdm.models.VaultAWSEC2Store` 7581 `strongdm.models.VaultAWSEC2CertSSHStore` 7582 `strongdm.models.VaultAWSEC2CertX509Store` 7583 `strongdm.models.VaultAWSIAMStore` 7584 `strongdm.models.VaultAWSIAMCertSSHStore` 7585 `strongdm.models.VaultAWSIAMCertX509Store` 7586 `strongdm.models.VaultTLSStore` 7587 `strongdm.models.VaultTLSCertSSHStore` 7588 `strongdm.models.VaultTLSCertX509Store` 7589 `strongdm.models.VaultTokenStore` 7590 `strongdm.models.VaultTokenCertSSHStore` 7591 `strongdm.models.VaultTokenCertX509Store` 7592 ''' 7593 def __init__(self, channel, client): 7594 self.parent = client 7595 self.stub = SecretStoresStub(channel) 7596 7597 def create(self, secret_store, timeout=None): 7598 deadline = None if timeout is None else time.time() + timeout 7599 req = SecretStoreCreateRequest() 7600 7601 if secret_store is not None: 7602 req.secret_store.CopyFrom( 7603 plumbing.convert_secret_store_to_plumbing(secret_store)) 7604 tries = 0 7605 plumbing_response = None 7606 while True: 7607 t = None if deadline is None else deadline - time.time() 7608 try: 7609 plumbing_response = self.stub.Create( 7610 req, 7611 metadata=self.parent.get_metadata('SecretStores.Create', 7612 req), 7613 timeout=t) 7614 except Exception as e: 7615 if self.parent.shouldRetry(tries, e, deadline): 7616 tries += 1 7617 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7618 continue 7619 raise plumbing.convert_error_to_porcelain(e) from e 7620 break 7621 7622 resp = models.SecretStoreCreateResponse() 7623 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 7624 plumbing_response.meta) 7625 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7626 plumbing_response.rate_limit) 7627 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 7628 plumbing_response.secret_store) 7629 return resp 7630 7631 def get(self, id, timeout=None): 7632 ''' 7633 Get reads one SecretStore by ID. 7634 ''' 7635 deadline = None if timeout is None else time.time() + timeout 7636 req = SecretStoreGetRequest() 7637 if self.parent.snapshot_datetime is not None: 7638 req.meta.CopyFrom(GetRequestMetadata()) 7639 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7640 7641 req.id = (id) 7642 tries = 0 7643 plumbing_response = None 7644 while True: 7645 t = None if deadline is None else deadline - time.time() 7646 try: 7647 plumbing_response = self.stub.Get( 7648 req, 7649 metadata=self.parent.get_metadata('SecretStores.Get', req), 7650 timeout=t) 7651 except Exception as e: 7652 if self.parent.shouldRetry(tries, e, deadline): 7653 tries += 1 7654 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7655 continue 7656 raise plumbing.convert_error_to_porcelain(e) from e 7657 break 7658 7659 resp = models.SecretStoreGetResponse() 7660 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 7661 plumbing_response.meta) 7662 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7663 plumbing_response.rate_limit) 7664 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 7665 plumbing_response.secret_store) 7666 return resp 7667 7668 def update(self, secret_store, timeout=None): 7669 ''' 7670 Update replaces all the fields of a SecretStore by ID. 7671 ''' 7672 deadline = None if timeout is None else time.time() + timeout 7673 req = SecretStoreUpdateRequest() 7674 7675 if secret_store is not None: 7676 req.secret_store.CopyFrom( 7677 plumbing.convert_secret_store_to_plumbing(secret_store)) 7678 tries = 0 7679 plumbing_response = None 7680 while True: 7681 t = None if deadline is None else deadline - time.time() 7682 try: 7683 plumbing_response = self.stub.Update( 7684 req, 7685 metadata=self.parent.get_metadata('SecretStores.Update', 7686 req), 7687 timeout=t) 7688 except Exception as e: 7689 if self.parent.shouldRetry(tries, e, deadline): 7690 tries += 1 7691 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7692 continue 7693 raise plumbing.convert_error_to_porcelain(e) from e 7694 break 7695 7696 resp = models.SecretStoreUpdateResponse() 7697 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 7698 plumbing_response.meta) 7699 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7700 plumbing_response.rate_limit) 7701 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 7702 plumbing_response.secret_store) 7703 return resp 7704 7705 def delete(self, id, timeout=None): 7706 ''' 7707 Delete removes a SecretStore by ID. 7708 ''' 7709 deadline = None if timeout is None else time.time() + timeout 7710 req = SecretStoreDeleteRequest() 7711 7712 req.id = (id) 7713 tries = 0 7714 plumbing_response = None 7715 while True: 7716 t = None if deadline is None else deadline - time.time() 7717 try: 7718 plumbing_response = self.stub.Delete( 7719 req, 7720 metadata=self.parent.get_metadata('SecretStores.Delete', 7721 req), 7722 timeout=t) 7723 except Exception as e: 7724 if self.parent.shouldRetry(tries, e, deadline): 7725 tries += 1 7726 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7727 continue 7728 raise plumbing.convert_error_to_porcelain(e) from e 7729 break 7730 7731 resp = models.SecretStoreDeleteResponse() 7732 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 7733 plumbing_response.meta) 7734 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7735 plumbing_response.rate_limit) 7736 return resp 7737 7738 def list(self, filter, *args, timeout=None): 7739 ''' 7740 List gets a list of SecretStores matching a given set of criteria. 7741 ''' 7742 deadline = None if timeout is None else time.time() + timeout 7743 req = SecretStoreListRequest() 7744 req.meta.CopyFrom(ListRequestMetadata()) 7745 if self.parent.page_limit > 0: 7746 req.meta.limit = self.parent.page_limit 7747 if self.parent.snapshot_datetime is not None: 7748 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7749 7750 req.filter = plumbing.quote_filter_args(filter, *args) 7751 7752 def generator(svc, req): 7753 tries = 0 7754 while True: 7755 t = None if deadline is None else deadline - time.time() 7756 try: 7757 plumbing_response = svc.stub.List( 7758 req, 7759 metadata=svc.parent.get_metadata( 7760 'SecretStores.List', req), 7761 timeout=t) 7762 except Exception as e: 7763 if self.parent.shouldRetry(tries, e, deadline): 7764 tries += 1 7765 time.sleep( 7766 self.parent.exponentialBackoff(tries, deadline)) 7767 continue 7768 raise plumbing.convert_error_to_porcelain(e) from e 7769 tries = 0 7770 for plumbing_item in plumbing_response.secret_stores: 7771 yield plumbing.convert_secret_store_to_porcelain( 7772 plumbing_item) 7773 if plumbing_response.meta.next_cursor == '': 7774 break 7775 req.meta.cursor = plumbing_response.meta.next_cursor 7776 7777 return generator(self, req) 7778 7779 7780class SnapshotSecretStores: 7781 ''' 7782 SnapshotSecretStores exposes the read only methods of the SecretStores 7783 service for historical queries. 7784 ''' 7785 def __init__(self, secret_stores): 7786 self.secret_stores = secret_stores 7787 7788 def get(self, id, timeout=None): 7789 ''' 7790 Get reads one SecretStore by ID. 7791 ''' 7792 return self.secret_stores.get(id, timeout=timeout) 7793 7794 def list(self, filter, *args, timeout=None): 7795 ''' 7796 List gets a list of SecretStores matching a given set of criteria. 7797 ''' 7798 return self.secret_stores.list(filter, *args, timeout=timeout) 7799 7800 7801class SecretEngines: 7802 ''' 7803 7804 See: 7805 `strongdm.models.ActiveDirectoryEngine` 7806 `strongdm.models.KeyValueEngine` 7807 `strongdm.models.MysqlEngine` 7808 `strongdm.models.PostgresEngine` 7809 `strongdm.models.SqlserverEngine` 7810 ''' 7811 def __init__(self, channel, client): 7812 self.parent = client 7813 self.stub = SecretEnginesStub(channel) 7814 7815 def list(self, filter, *args, timeout=None): 7816 ''' 7817 List returns a list of Secret Engines 7818 ''' 7819 deadline = None if timeout is None else time.time() + timeout 7820 req = SecretEngineListRequest() 7821 req.meta.CopyFrom(ListRequestMetadata()) 7822 if self.parent.page_limit > 0: 7823 req.meta.limit = self.parent.page_limit 7824 if self.parent.snapshot_datetime is not None: 7825 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7826 7827 req.filter = plumbing.quote_filter_args(filter, *args) 7828 7829 def generator(svc, req): 7830 tries = 0 7831 while True: 7832 t = None if deadline is None else deadline - time.time() 7833 try: 7834 plumbing_response = svc.stub.List( 7835 req, 7836 metadata=svc.parent.get_metadata( 7837 'SecretEngines.List', req), 7838 timeout=t) 7839 except Exception as e: 7840 if self.parent.shouldRetry(tries, e, deadline): 7841 tries += 1 7842 time.sleep( 7843 self.parent.exponentialBackoff(tries, deadline)) 7844 continue 7845 raise plumbing.convert_error_to_porcelain(e) from e 7846 tries = 0 7847 for plumbing_item in plumbing_response.secret_engines: 7848 yield plumbing.convert_secret_engine_to_porcelain( 7849 plumbing_item) 7850 if plumbing_response.meta.next_cursor == '': 7851 break 7852 req.meta.cursor = plumbing_response.meta.next_cursor 7853 7854 return generator(self, req) 7855 7856 def get(self, id, timeout=None): 7857 ''' 7858 Get returns a secret engine details 7859 ''' 7860 deadline = None if timeout is None else time.time() + timeout 7861 req = SecretEngineGetRequest() 7862 if self.parent.snapshot_datetime is not None: 7863 req.meta.CopyFrom(GetRequestMetadata()) 7864 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7865 7866 req.id = (id) 7867 tries = 0 7868 plumbing_response = None 7869 while True: 7870 t = None if deadline is None else deadline - time.time() 7871 try: 7872 plumbing_response = self.stub.Get( 7873 req, 7874 metadata=self.parent.get_metadata('SecretEngines.Get', 7875 req), 7876 timeout=t) 7877 except Exception as e: 7878 if self.parent.shouldRetry(tries, e, deadline): 7879 tries += 1 7880 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7881 continue 7882 raise plumbing.convert_error_to_porcelain(e) from e 7883 break 7884 7885 resp = models.SecretEngineGetResponse() 7886 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 7887 plumbing_response.meta) 7888 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7889 plumbing_response.rate_limit) 7890 resp.secret_engine = plumbing.convert_secret_engine_to_porcelain( 7891 plumbing_response.secret_engine) 7892 return resp 7893 7894 def create(self, secret_engine, timeout=None): 7895 ''' 7896 Create creates a secret engine 7897 ''' 7898 deadline = None if timeout is None else time.time() + timeout 7899 req = SecretEngineCreateRequest() 7900 7901 if secret_engine is not None: 7902 req.secret_engine.CopyFrom( 7903 plumbing.convert_secret_engine_to_plumbing(secret_engine)) 7904 tries = 0 7905 plumbing_response = None 7906 while True: 7907 t = None if deadline is None else deadline - time.time() 7908 try: 7909 plumbing_response = self.stub.Create( 7910 req, 7911 metadata=self.parent.get_metadata('SecretEngines.Create', 7912 req), 7913 timeout=t) 7914 except Exception as e: 7915 if self.parent.shouldRetry(tries, e, deadline): 7916 tries += 1 7917 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7918 continue 7919 raise plumbing.convert_error_to_porcelain(e) from e 7920 break 7921 7922 resp = models.SecretEngineCreateResponse() 7923 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 7924 plumbing_response.meta) 7925 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7926 plumbing_response.rate_limit) 7927 resp.secret_engine = plumbing.convert_secret_engine_to_porcelain( 7928 plumbing_response.secret_engine) 7929 return resp 7930 7931 def update(self, secret_engine, timeout=None): 7932 ''' 7933 Update updates a secret engine 7934 ''' 7935 deadline = None if timeout is None else time.time() + timeout 7936 req = SecretEngineUpdateRequest() 7937 7938 if secret_engine is not None: 7939 req.secret_engine.CopyFrom( 7940 plumbing.convert_secret_engine_to_plumbing(secret_engine)) 7941 tries = 0 7942 plumbing_response = None 7943 while True: 7944 t = None if deadline is None else deadline - time.time() 7945 try: 7946 plumbing_response = self.stub.Update( 7947 req, 7948 metadata=self.parent.get_metadata('SecretEngines.Update', 7949 req), 7950 timeout=t) 7951 except Exception as e: 7952 if self.parent.shouldRetry(tries, e, deadline): 7953 tries += 1 7954 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7955 continue 7956 raise plumbing.convert_error_to_porcelain(e) from e 7957 break 7958 7959 resp = models.SecretEngineUpdateResponse() 7960 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 7961 plumbing_response.meta) 7962 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7963 plumbing_response.rate_limit) 7964 resp.secret_engine = plumbing.convert_secret_engine_to_porcelain( 7965 plumbing_response.secret_engine) 7966 return resp 7967 7968 def delete(self, id, timeout=None): 7969 ''' 7970 Delete deletes a secret engine 7971 ''' 7972 deadline = None if timeout is None else time.time() + timeout 7973 req = SecretEngineDeleteRequest() 7974 7975 req.id = (id) 7976 tries = 0 7977 plumbing_response = None 7978 while True: 7979 t = None if deadline is None else deadline - time.time() 7980 try: 7981 plumbing_response = self.stub.Delete( 7982 req, 7983 metadata=self.parent.get_metadata('SecretEngines.Delete', 7984 req), 7985 timeout=t) 7986 except Exception as e: 7987 if self.parent.shouldRetry(tries, e, deadline): 7988 tries += 1 7989 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7990 continue 7991 raise plumbing.convert_error_to_porcelain(e) from e 7992 break 7993 7994 resp = models.SecretEngineDeleteResponse() 7995 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7996 plumbing_response.rate_limit) 7997 return resp 7998 7999 def list_secret_stores(self, filter, *args, timeout=None): 8000 ''' 8001 ListSecretStores returns a list of Secret Stores that can be used as a backing store 8002 for Secret Engine 8003 ''' 8004 deadline = None if timeout is None else time.time() + timeout 8005 req = SecretStoreListRequest() 8006 req.meta.CopyFrom(ListRequestMetadata()) 8007 if self.parent.page_limit > 0: 8008 req.meta.limit = self.parent.page_limit 8009 if self.parent.snapshot_datetime is not None: 8010 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8011 8012 req.filter = plumbing.quote_filter_args(filter, *args) 8013 8014 def generator(svc, req): 8015 tries = 0 8016 while True: 8017 t = None if deadline is None else deadline - time.time() 8018 try: 8019 plumbing_response = svc.stub.ListSecretStores( 8020 req, 8021 metadata=svc.parent.get_metadata( 8022 'SecretEngines.ListSecretStores', req), 8023 timeout=t) 8024 except Exception as e: 8025 if self.parent.shouldRetry(tries, e, deadline): 8026 tries += 1 8027 time.sleep( 8028 self.parent.exponentialBackoff(tries, deadline)) 8029 continue 8030 raise plumbing.convert_error_to_porcelain(e) from e 8031 tries = 0 8032 for plumbing_item in plumbing_response.secret_stores: 8033 yield plumbing.convert_secret_store_to_porcelain( 8034 plumbing_item) 8035 if plumbing_response.meta.next_cursor == '': 8036 break 8037 req.meta.cursor = plumbing_response.meta.next_cursor 8038 8039 return generator(self, req) 8040 8041 def generate_keys(self, secret_engine_id, timeout=None): 8042 ''' 8043 GenerateKeys generates a private key, stores it in a secret store and stores a public key in a secret engine 8044 ''' 8045 deadline = None if timeout is None else time.time() + timeout 8046 req = GenerateKeysRequest() 8047 8048 req.secret_engine_id = (secret_engine_id) 8049 tries = 0 8050 plumbing_response = None 8051 while True: 8052 t = None if deadline is None else deadline - time.time() 8053 try: 8054 plumbing_response = self.stub.GenerateKeys( 8055 req, 8056 metadata=self.parent.get_metadata( 8057 'SecretEngines.GenerateKeys', req), 8058 timeout=t) 8059 except Exception as e: 8060 if self.parent.shouldRetry(tries, e, deadline): 8061 tries += 1 8062 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8063 continue 8064 raise plumbing.convert_error_to_porcelain(e) from e 8065 break 8066 8067 resp = models.GenerateKeysResponse() 8068 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8069 plumbing_response.rate_limit) 8070 return resp 8071 8072 def healthcheck(self, secret_engine_id, timeout=None): 8073 ''' 8074 Healthcheck triggers a healthcheck for all nodes serving a secret engine 8075 ''' 8076 deadline = None if timeout is None else time.time() + timeout 8077 req = HealthcheckRequest() 8078 8079 req.secret_engine_id = (secret_engine_id) 8080 tries = 0 8081 plumbing_response = None 8082 while True: 8083 t = None if deadline is None else deadline - time.time() 8084 try: 8085 plumbing_response = self.stub.Healthcheck( 8086 req, 8087 metadata=self.parent.get_metadata( 8088 'SecretEngines.Healthcheck', req), 8089 timeout=t) 8090 except Exception as e: 8091 if self.parent.shouldRetry(tries, e, deadline): 8092 tries += 1 8093 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8094 continue 8095 raise plumbing.convert_error_to_porcelain(e) from e 8096 break 8097 8098 resp = models.HealthcheckResponse() 8099 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8100 plumbing_response.rate_limit) 8101 resp.status = plumbing.convert_repeated_healthcheck_status_to_porcelain( 8102 plumbing_response.status) 8103 return resp 8104 8105 def rotate(self, id, password_policy, timeout=None): 8106 ''' 8107 Rotate rotates secret engine's credentials 8108 ''' 8109 deadline = None if timeout is None else time.time() + timeout 8110 req = SecretEngineRotateRequest() 8111 8112 req.id = (id) 8113 if password_policy is not None: 8114 req.password_policy.CopyFrom( 8115 plumbing.convert_secret_engine_password_policy_to_plumbing( 8116 password_policy)) 8117 tries = 0 8118 plumbing_response = None 8119 while True: 8120 t = None if deadline is None else deadline - time.time() 8121 try: 8122 plumbing_response = self.stub.Rotate( 8123 req, 8124 metadata=self.parent.get_metadata('SecretEngines.Rotate', 8125 req), 8126 timeout=t) 8127 except Exception as e: 8128 if self.parent.shouldRetry(tries, e, deadline): 8129 tries += 1 8130 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8131 continue 8132 raise plumbing.convert_error_to_porcelain(e) from e 8133 break 8134 8135 resp = models.SecretEngineRotateResponse() 8136 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8137 plumbing_response.rate_limit) 8138 return resp 8139 8140 8141class SecretStoreHealths: 8142 ''' 8143 SecretStoreHealths exposes health states for secret stores. 8144 See `strongdm.models.SecretStoreHealth`. 8145 ''' 8146 def __init__(self, channel, client): 8147 self.parent = client 8148 self.stub = SecretStoreHealthsStub(channel) 8149 8150 def list(self, filter, *args, timeout=None): 8151 ''' 8152 List reports the health status of node to secret store pairs. 8153 ''' 8154 deadline = None if timeout is None else time.time() + timeout 8155 req = SecretStoreHealthListRequest() 8156 req.meta.CopyFrom(ListRequestMetadata()) 8157 if self.parent.page_limit > 0: 8158 req.meta.limit = self.parent.page_limit 8159 if self.parent.snapshot_datetime is not None: 8160 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8161 8162 req.filter = plumbing.quote_filter_args(filter, *args) 8163 8164 def generator(svc, req): 8165 tries = 0 8166 while True: 8167 t = None if deadline is None else deadline - time.time() 8168 try: 8169 plumbing_response = svc.stub.List( 8170 req, 8171 metadata=svc.parent.get_metadata( 8172 'SecretStoreHealths.List', req), 8173 timeout=t) 8174 except Exception as e: 8175 if self.parent.shouldRetry(tries, e, deadline): 8176 tries += 1 8177 time.sleep( 8178 self.parent.exponentialBackoff(tries, deadline)) 8179 continue 8180 raise plumbing.convert_error_to_porcelain(e) from e 8181 tries = 0 8182 for plumbing_item in plumbing_response.secret_store_healths: 8183 yield plumbing.convert_secret_store_health_to_porcelain( 8184 plumbing_item) 8185 if plumbing_response.meta.next_cursor == '': 8186 break 8187 req.meta.cursor = plumbing_response.meta.next_cursor 8188 8189 return generator(self, req) 8190 8191 def healthcheck(self, secret_store_id, timeout=None): 8192 ''' 8193 Healthcheck triggers a remote healthcheck request for a secret store. It may take minutes 8194 to propagate across a large network of Nodes. The call will return immediately, and the 8195 updated health of the Secret Store can be retrieved via List. 8196 ''' 8197 deadline = None if timeout is None else time.time() + timeout 8198 req = SecretStoreHealthcheckRequest() 8199 8200 req.secret_store_id = (secret_store_id) 8201 tries = 0 8202 plumbing_response = None 8203 while True: 8204 t = None if deadline is None else deadline - time.time() 8205 try: 8206 plumbing_response = self.stub.Healthcheck( 8207 req, 8208 metadata=self.parent.get_metadata( 8209 'SecretStoreHealths.Healthcheck', req), 8210 timeout=t) 8211 except Exception as e: 8212 if self.parent.shouldRetry(tries, e, deadline): 8213 tries += 1 8214 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8215 continue 8216 raise plumbing.convert_error_to_porcelain(e) from e 8217 break 8218 8219 resp = models.SecretStoreHealthcheckResponse() 8220 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8221 plumbing_response.rate_limit) 8222 return resp 8223 8224 8225class SecretStoresHistory: 8226 ''' 8227 SecretStoresHistory records all changes to the state of a SecretStore. 8228 See `strongdm.models.SecretStoreHistory`. 8229 ''' 8230 def __init__(self, channel, client): 8231 self.parent = client 8232 self.stub = SecretStoresHistoryStub(channel) 8233 8234 def list(self, filter, *args, timeout=None): 8235 ''' 8236 List gets a list of SecretStoreHistory records matching a given set of criteria. 8237 ''' 8238 deadline = None if timeout is None else time.time() + timeout 8239 req = SecretStoreHistoryListRequest() 8240 req.meta.CopyFrom(ListRequestMetadata()) 8241 if self.parent.page_limit > 0: 8242 req.meta.limit = self.parent.page_limit 8243 if self.parent.snapshot_datetime is not None: 8244 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8245 8246 req.filter = plumbing.quote_filter_args(filter, *args) 8247 8248 def generator(svc, req): 8249 tries = 0 8250 while True: 8251 t = None if deadline is None else deadline - time.time() 8252 try: 8253 plumbing_response = svc.stub.List( 8254 req, 8255 metadata=svc.parent.get_metadata( 8256 'SecretStoresHistory.List', req), 8257 timeout=t) 8258 except Exception as e: 8259 if self.parent.shouldRetry(tries, e, deadline): 8260 tries += 1 8261 time.sleep( 8262 self.parent.exponentialBackoff(tries, deadline)) 8263 continue 8264 raise plumbing.convert_error_to_porcelain(e) from e 8265 tries = 0 8266 for plumbing_item in plumbing_response.history: 8267 yield plumbing.convert_secret_store_history_to_porcelain( 8268 plumbing_item) 8269 if plumbing_response.meta.next_cursor == '': 8270 break 8271 req.meta.cursor = plumbing_response.meta.next_cursor 8272 8273 return generator(self, req) 8274 8275 8276class WorkflowApprovers: 8277 ''' 8278 WorkflowApprovers is an account or a role with the ability to approve requests bound to a workflow. 8279 See `strongdm.models.WorkflowApprover`. 8280 ''' 8281 def __init__(self, channel, client): 8282 self.parent = client 8283 self.stub = WorkflowApproversStub(channel) 8284 8285 def create(self, workflow_approver, timeout=None): 8286 ''' 8287 Create creates a new workflow approver 8288 ''' 8289 deadline = None if timeout is None else time.time() + timeout 8290 req = WorkflowApproversCreateRequest() 8291 8292 if workflow_approver is not None: 8293 req.workflow_approver.CopyFrom( 8294 plumbing.convert_workflow_approver_to_plumbing( 8295 workflow_approver)) 8296 tries = 0 8297 plumbing_response = None 8298 while True: 8299 t = None if deadline is None else deadline - time.time() 8300 try: 8301 plumbing_response = self.stub.Create( 8302 req, 8303 metadata=self.parent.get_metadata( 8304 'WorkflowApprovers.Create', req), 8305 timeout=t) 8306 except Exception as e: 8307 if self.parent.shouldRetry(tries, e, deadline): 8308 tries += 1 8309 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8310 continue 8311 raise plumbing.convert_error_to_porcelain(e) from e 8312 break 8313 8314 resp = models.WorkflowApproversCreateResponse() 8315 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8316 plumbing_response.rate_limit) 8317 resp.workflow_approver = plumbing.convert_workflow_approver_to_porcelain( 8318 plumbing_response.workflow_approver) 8319 return resp 8320 8321 def get(self, id, timeout=None): 8322 ''' 8323 Get reads one workflow approver by ID. 8324 ''' 8325 deadline = None if timeout is None else time.time() + timeout 8326 req = WorkflowApproverGetRequest() 8327 if self.parent.snapshot_datetime is not None: 8328 req.meta.CopyFrom(GetRequestMetadata()) 8329 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8330 8331 req.id = (id) 8332 tries = 0 8333 plumbing_response = None 8334 while True: 8335 t = None if deadline is None else deadline - time.time() 8336 try: 8337 plumbing_response = self.stub.Get( 8338 req, 8339 metadata=self.parent.get_metadata('WorkflowApprovers.Get', 8340 req), 8341 timeout=t) 8342 except Exception as e: 8343 if self.parent.shouldRetry(tries, e, deadline): 8344 tries += 1 8345 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8346 continue 8347 raise plumbing.convert_error_to_porcelain(e) from e 8348 break 8349 8350 resp = models.WorkflowApproverGetResponse() 8351 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 8352 plumbing_response.meta) 8353 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8354 plumbing_response.rate_limit) 8355 resp.workflow_approver = plumbing.convert_workflow_approver_to_porcelain( 8356 plumbing_response.workflow_approver) 8357 return resp 8358 8359 def delete(self, id, timeout=None): 8360 ''' 8361 Delete deletes a workflow approver 8362 ''' 8363 deadline = None if timeout is None else time.time() + timeout 8364 req = WorkflowApproversDeleteRequest() 8365 8366 req.id = (id) 8367 tries = 0 8368 plumbing_response = None 8369 while True: 8370 t = None if deadline is None else deadline - time.time() 8371 try: 8372 plumbing_response = self.stub.Delete( 8373 req, 8374 metadata=self.parent.get_metadata( 8375 'WorkflowApprovers.Delete', req), 8376 timeout=t) 8377 except Exception as e: 8378 if self.parent.shouldRetry(tries, e, deadline): 8379 tries += 1 8380 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8381 continue 8382 raise plumbing.convert_error_to_porcelain(e) from e 8383 break 8384 8385 resp = models.WorkflowApproversDeleteResponse() 8386 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8387 plumbing_response.rate_limit) 8388 return resp 8389 8390 def list(self, filter, *args, timeout=None): 8391 ''' 8392 Lists existing workflow approvers. 8393 ''' 8394 deadline = None if timeout is None else time.time() + timeout 8395 req = WorkflowApproversListRequest() 8396 req.meta.CopyFrom(ListRequestMetadata()) 8397 if self.parent.page_limit > 0: 8398 req.meta.limit = self.parent.page_limit 8399 if self.parent.snapshot_datetime is not None: 8400 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8401 8402 req.filter = plumbing.quote_filter_args(filter, *args) 8403 8404 def generator(svc, req): 8405 tries = 0 8406 while True: 8407 t = None if deadline is None else deadline - time.time() 8408 try: 8409 plumbing_response = svc.stub.List( 8410 req, 8411 metadata=svc.parent.get_metadata( 8412 'WorkflowApprovers.List', req), 8413 timeout=t) 8414 except Exception as e: 8415 if self.parent.shouldRetry(tries, e, deadline): 8416 tries += 1 8417 time.sleep( 8418 self.parent.exponentialBackoff(tries, deadline)) 8419 continue 8420 raise plumbing.convert_error_to_porcelain(e) from e 8421 tries = 0 8422 for plumbing_item in plumbing_response.workflow_approvers: 8423 yield plumbing.convert_workflow_approver_to_porcelain( 8424 plumbing_item) 8425 if plumbing_response.meta.next_cursor == '': 8426 break 8427 req.meta.cursor = plumbing_response.meta.next_cursor 8428 8429 return generator(self, req) 8430 8431 8432class SnapshotWorkflowApprovers: 8433 ''' 8434 SnapshotWorkflowApprovers exposes the read only methods of the WorkflowApprovers 8435 service for historical queries. 8436 ''' 8437 def __init__(self, workflow_approvers): 8438 self.workflow_approvers = workflow_approvers 8439 8440 def get(self, id, timeout=None): 8441 ''' 8442 Get reads one workflow approver by ID. 8443 ''' 8444 return self.workflow_approvers.get(id, timeout=timeout) 8445 8446 def list(self, filter, *args, timeout=None): 8447 ''' 8448 Lists existing workflow approvers. 8449 ''' 8450 return self.workflow_approvers.list(filter, *args, timeout=timeout) 8451 8452 8453class WorkflowApproversHistory: 8454 ''' 8455 WorkflowApproversHistory provides records of all changes to the state of a WorkflowApprover. 8456 See `strongdm.models.WorkflowApproverHistory`. 8457 ''' 8458 def __init__(self, channel, client): 8459 self.parent = client 8460 self.stub = WorkflowApproversHistoryStub(channel) 8461 8462 def list(self, filter, *args, timeout=None): 8463 ''' 8464 List gets a list of WorkflowApproversHistory records matching a given set of criteria. 8465 ''' 8466 deadline = None if timeout is None else time.time() + timeout 8467 req = WorkflowApproversHistoryListRequest() 8468 req.meta.CopyFrom(ListRequestMetadata()) 8469 if self.parent.page_limit > 0: 8470 req.meta.limit = self.parent.page_limit 8471 if self.parent.snapshot_datetime is not None: 8472 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8473 8474 req.filter = plumbing.quote_filter_args(filter, *args) 8475 8476 def generator(svc, req): 8477 tries = 0 8478 while True: 8479 t = None if deadline is None else deadline - time.time() 8480 try: 8481 plumbing_response = svc.stub.List( 8482 req, 8483 metadata=svc.parent.get_metadata( 8484 'WorkflowApproversHistory.List', req), 8485 timeout=t) 8486 except Exception as e: 8487 if self.parent.shouldRetry(tries, e, deadline): 8488 tries += 1 8489 time.sleep( 8490 self.parent.exponentialBackoff(tries, deadline)) 8491 continue 8492 raise plumbing.convert_error_to_porcelain(e) from e 8493 tries = 0 8494 for plumbing_item in plumbing_response.history: 8495 yield plumbing.convert_workflow_approver_history_to_porcelain( 8496 plumbing_item) 8497 if plumbing_response.meta.next_cursor == '': 8498 break 8499 req.meta.cursor = plumbing_response.meta.next_cursor 8500 8501 return generator(self, req) 8502 8503 8504class WorkflowRoles: 8505 ''' 8506 WorkflowRole links a role to a workflow. The linked roles indicate which roles a user must be a part of 8507 to request access to a resource via the workflow. 8508 See `strongdm.models.WorkflowRole`. 8509 ''' 8510 def __init__(self, channel, client): 8511 self.parent = client 8512 self.stub = WorkflowRolesStub(channel) 8513 8514 def create(self, workflow_role, timeout=None): 8515 ''' 8516 Create creates a new workflow role 8517 ''' 8518 deadline = None if timeout is None else time.time() + timeout 8519 req = WorkflowRolesCreateRequest() 8520 8521 if workflow_role is not None: 8522 req.workflow_role.CopyFrom( 8523 plumbing.convert_workflow_role_to_plumbing(workflow_role)) 8524 tries = 0 8525 plumbing_response = None 8526 while True: 8527 t = None if deadline is None else deadline - time.time() 8528 try: 8529 plumbing_response = self.stub.Create( 8530 req, 8531 metadata=self.parent.get_metadata('WorkflowRoles.Create', 8532 req), 8533 timeout=t) 8534 except Exception as e: 8535 if self.parent.shouldRetry(tries, e, deadline): 8536 tries += 1 8537 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8538 continue 8539 raise plumbing.convert_error_to_porcelain(e) from e 8540 break 8541 8542 resp = models.WorkflowRolesCreateResponse() 8543 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8544 plumbing_response.rate_limit) 8545 resp.workflow_role = plumbing.convert_workflow_role_to_porcelain( 8546 plumbing_response.workflow_role) 8547 return resp 8548 8549 def get(self, id, timeout=None): 8550 ''' 8551 Get reads one workflow role by ID. 8552 ''' 8553 deadline = None if timeout is None else time.time() + timeout 8554 req = WorkflowRoleGetRequest() 8555 if self.parent.snapshot_datetime is not None: 8556 req.meta.CopyFrom(GetRequestMetadata()) 8557 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8558 8559 req.id = (id) 8560 tries = 0 8561 plumbing_response = None 8562 while True: 8563 t = None if deadline is None else deadline - time.time() 8564 try: 8565 plumbing_response = self.stub.Get( 8566 req, 8567 metadata=self.parent.get_metadata('WorkflowRoles.Get', 8568 req), 8569 timeout=t) 8570 except Exception as e: 8571 if self.parent.shouldRetry(tries, e, deadline): 8572 tries += 1 8573 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8574 continue 8575 raise plumbing.convert_error_to_porcelain(e) from e 8576 break 8577 8578 resp = models.WorkflowRoleGetResponse() 8579 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 8580 plumbing_response.meta) 8581 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8582 plumbing_response.rate_limit) 8583 resp.workflow_role = plumbing.convert_workflow_role_to_porcelain( 8584 plumbing_response.workflow_role) 8585 return resp 8586 8587 def delete(self, id, timeout=None): 8588 ''' 8589 Delete deletes a workflow role 8590 ''' 8591 deadline = None if timeout is None else time.time() + timeout 8592 req = WorkflowRolesDeleteRequest() 8593 8594 req.id = (id) 8595 tries = 0 8596 plumbing_response = None 8597 while True: 8598 t = None if deadline is None else deadline - time.time() 8599 try: 8600 plumbing_response = self.stub.Delete( 8601 req, 8602 metadata=self.parent.get_metadata('WorkflowRoles.Delete', 8603 req), 8604 timeout=t) 8605 except Exception as e: 8606 if self.parent.shouldRetry(tries, e, deadline): 8607 tries += 1 8608 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8609 continue 8610 raise plumbing.convert_error_to_porcelain(e) from e 8611 break 8612 8613 resp = models.WorkflowRolesDeleteResponse() 8614 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8615 plumbing_response.rate_limit) 8616 return resp 8617 8618 def list(self, filter, *args, timeout=None): 8619 ''' 8620 Lists existing workflow roles. 8621 ''' 8622 deadline = None if timeout is None else time.time() + timeout 8623 req = WorkflowRolesListRequest() 8624 req.meta.CopyFrom(ListRequestMetadata()) 8625 if self.parent.page_limit > 0: 8626 req.meta.limit = self.parent.page_limit 8627 if self.parent.snapshot_datetime is not None: 8628 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8629 8630 req.filter = plumbing.quote_filter_args(filter, *args) 8631 8632 def generator(svc, req): 8633 tries = 0 8634 while True: 8635 t = None if deadline is None else deadline - time.time() 8636 try: 8637 plumbing_response = svc.stub.List( 8638 req, 8639 metadata=svc.parent.get_metadata( 8640 'WorkflowRoles.List', req), 8641 timeout=t) 8642 except Exception as e: 8643 if self.parent.shouldRetry(tries, e, deadline): 8644 tries += 1 8645 time.sleep( 8646 self.parent.exponentialBackoff(tries, deadline)) 8647 continue 8648 raise plumbing.convert_error_to_porcelain(e) from e 8649 tries = 0 8650 for plumbing_item in plumbing_response.workflow_role: 8651 yield plumbing.convert_workflow_role_to_porcelain( 8652 plumbing_item) 8653 if plumbing_response.meta.next_cursor == '': 8654 break 8655 req.meta.cursor = plumbing_response.meta.next_cursor 8656 8657 return generator(self, req) 8658 8659 8660class SnapshotWorkflowRoles: 8661 ''' 8662 SnapshotWorkflowRoles exposes the read only methods of the WorkflowRoles 8663 service for historical queries. 8664 ''' 8665 def __init__(self, workflow_roles): 8666 self.workflow_roles = workflow_roles 8667 8668 def get(self, id, timeout=None): 8669 ''' 8670 Get reads one workflow role by ID. 8671 ''' 8672 return self.workflow_roles.get(id, timeout=timeout) 8673 8674 def list(self, filter, *args, timeout=None): 8675 ''' 8676 Lists existing workflow roles. 8677 ''' 8678 return self.workflow_roles.list(filter, *args, timeout=timeout) 8679 8680 8681class WorkflowRolesHistory: 8682 ''' 8683 WorkflowRolesHistory provides records of all changes to the state of a WorkflowRole 8684 See `strongdm.models.WorkflowRoleHistory`. 8685 ''' 8686 def __init__(self, channel, client): 8687 self.parent = client 8688 self.stub = WorkflowRolesHistoryStub(channel) 8689 8690 def list(self, filter, *args, timeout=None): 8691 ''' 8692 List gets a list of WorkflowRolesHistory records matching a given set of criteria. 8693 ''' 8694 deadline = None if timeout is None else time.time() + timeout 8695 req = WorkflowRolesHistoryListRequest() 8696 req.meta.CopyFrom(ListRequestMetadata()) 8697 if self.parent.page_limit > 0: 8698 req.meta.limit = self.parent.page_limit 8699 if self.parent.snapshot_datetime is not None: 8700 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8701 8702 req.filter = plumbing.quote_filter_args(filter, *args) 8703 8704 def generator(svc, req): 8705 tries = 0 8706 while True: 8707 t = None if deadline is None else deadline - time.time() 8708 try: 8709 plumbing_response = svc.stub.List( 8710 req, 8711 metadata=svc.parent.get_metadata( 8712 'WorkflowRolesHistory.List', req), 8713 timeout=t) 8714 except Exception as e: 8715 if self.parent.shouldRetry(tries, e, deadline): 8716 tries += 1 8717 time.sleep( 8718 self.parent.exponentialBackoff(tries, deadline)) 8719 continue 8720 raise plumbing.convert_error_to_porcelain(e) from e 8721 tries = 0 8722 for plumbing_item in plumbing_response.history: 8723 yield plumbing.convert_workflow_role_history_to_porcelain( 8724 plumbing_item) 8725 if plumbing_response.meta.next_cursor == '': 8726 break 8727 req.meta.cursor = plumbing_response.meta.next_cursor 8728 8729 return generator(self, req) 8730 8731 8732class Workflows: 8733 ''' 8734 Workflows are the collection of rules that define the resources to which access can be requested, 8735 the users that can request that access, and the mechanism for approving those requests which can either 8736 be automatic approval or a set of users authorized to approve the requests. 8737 See `strongdm.models.Workflow`. 8738 ''' 8739 def __init__(self, channel, client): 8740 self.parent = client 8741 self.stub = WorkflowsStub(channel) 8742 8743 def create(self, workflow, timeout=None): 8744 ''' 8745 Create creates a new workflow and requires a name for the workflow. 8746 ''' 8747 deadline = None if timeout is None else time.time() + timeout 8748 req = WorkflowCreateRequest() 8749 8750 if workflow is not None: 8751 req.workflow.CopyFrom( 8752 plumbing.convert_workflow_to_plumbing(workflow)) 8753 tries = 0 8754 plumbing_response = None 8755 while True: 8756 t = None if deadline is None else deadline - time.time() 8757 try: 8758 plumbing_response = self.stub.Create( 8759 req, 8760 metadata=self.parent.get_metadata('Workflows.Create', req), 8761 timeout=t) 8762 except Exception as e: 8763 if self.parent.shouldRetry(tries, e, deadline): 8764 tries += 1 8765 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8766 continue 8767 raise plumbing.convert_error_to_porcelain(e) from e 8768 break 8769 8770 resp = models.WorkflowCreateResponse() 8771 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8772 plumbing_response.rate_limit) 8773 resp.workflow = plumbing.convert_workflow_to_porcelain( 8774 plumbing_response.workflow) 8775 return resp 8776 8777 def get(self, id, timeout=None): 8778 ''' 8779 Get reads one workflow by ID. 8780 ''' 8781 deadline = None if timeout is None else time.time() + timeout 8782 req = WorkflowGetRequest() 8783 if self.parent.snapshot_datetime is not None: 8784 req.meta.CopyFrom(GetRequestMetadata()) 8785 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8786 8787 req.id = (id) 8788 tries = 0 8789 plumbing_response = None 8790 while True: 8791 t = None if deadline is None else deadline - time.time() 8792 try: 8793 plumbing_response = self.stub.Get( 8794 req, 8795 metadata=self.parent.get_metadata('Workflows.Get', req), 8796 timeout=t) 8797 except Exception as e: 8798 if self.parent.shouldRetry(tries, e, deadline): 8799 tries += 1 8800 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8801 continue 8802 raise plumbing.convert_error_to_porcelain(e) from e 8803 break 8804 8805 resp = models.WorkflowGetResponse() 8806 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 8807 plumbing_response.meta) 8808 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8809 plumbing_response.rate_limit) 8810 resp.workflow = plumbing.convert_workflow_to_porcelain( 8811 plumbing_response.workflow) 8812 return resp 8813 8814 def delete(self, id, timeout=None): 8815 ''' 8816 Delete deletes an existing workflow. 8817 ''' 8818 deadline = None if timeout is None else time.time() + timeout 8819 req = WorkflowDeleteRequest() 8820 8821 req.id = (id) 8822 tries = 0 8823 plumbing_response = None 8824 while True: 8825 t = None if deadline is None else deadline - time.time() 8826 try: 8827 plumbing_response = self.stub.Delete( 8828 req, 8829 metadata=self.parent.get_metadata('Workflows.Delete', req), 8830 timeout=t) 8831 except Exception as e: 8832 if self.parent.shouldRetry(tries, e, deadline): 8833 tries += 1 8834 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8835 continue 8836 raise plumbing.convert_error_to_porcelain(e) from e 8837 break 8838 8839 resp = models.WorkflowDeleteResponse() 8840 resp.id = (plumbing_response.id) 8841 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8842 plumbing_response.rate_limit) 8843 return resp 8844 8845 def update(self, workflow, timeout=None): 8846 ''' 8847 Update updates an existing workflow. 8848 ''' 8849 deadline = None if timeout is None else time.time() + timeout 8850 req = WorkflowUpdateRequest() 8851 8852 if workflow is not None: 8853 req.workflow.CopyFrom( 8854 plumbing.convert_workflow_to_plumbing(workflow)) 8855 tries = 0 8856 plumbing_response = None 8857 while True: 8858 t = None if deadline is None else deadline - time.time() 8859 try: 8860 plumbing_response = self.stub.Update( 8861 req, 8862 metadata=self.parent.get_metadata('Workflows.Update', req), 8863 timeout=t) 8864 except Exception as e: 8865 if self.parent.shouldRetry(tries, e, deadline): 8866 tries += 1 8867 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8868 continue 8869 raise plumbing.convert_error_to_porcelain(e) from e 8870 break 8871 8872 resp = models.WorkflowUpdateResponse() 8873 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8874 plumbing_response.rate_limit) 8875 resp.workflow = plumbing.convert_workflow_to_porcelain( 8876 plumbing_response.workflow) 8877 return resp 8878 8879 def list(self, filter, *args, timeout=None): 8880 ''' 8881 Lists existing workflows. 8882 ''' 8883 deadline = None if timeout is None else time.time() + timeout 8884 req = WorkflowListRequest() 8885 req.meta.CopyFrom(ListRequestMetadata()) 8886 if self.parent.page_limit > 0: 8887 req.meta.limit = self.parent.page_limit 8888 if self.parent.snapshot_datetime is not None: 8889 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8890 8891 req.filter = plumbing.quote_filter_args(filter, *args) 8892 8893 def generator(svc, req): 8894 tries = 0 8895 while True: 8896 t = None if deadline is None else deadline - time.time() 8897 try: 8898 plumbing_response = svc.stub.List( 8899 req, 8900 metadata=svc.parent.get_metadata( 8901 'Workflows.List', req), 8902 timeout=t) 8903 except Exception as e: 8904 if self.parent.shouldRetry(tries, e, deadline): 8905 tries += 1 8906 time.sleep( 8907 self.parent.exponentialBackoff(tries, deadline)) 8908 continue 8909 raise plumbing.convert_error_to_porcelain(e) from e 8910 tries = 0 8911 for plumbing_item in plumbing_response.workflows: 8912 yield plumbing.convert_workflow_to_porcelain(plumbing_item) 8913 if plumbing_response.meta.next_cursor == '': 8914 break 8915 req.meta.cursor = plumbing_response.meta.next_cursor 8916 8917 return generator(self, req) 8918 8919 8920class SnapshotWorkflows: 8921 ''' 8922 SnapshotWorkflows exposes the read only methods of the Workflows 8923 service for historical queries. 8924 ''' 8925 def __init__(self, workflows): 8926 self.workflows = workflows 8927 8928 def get(self, id, timeout=None): 8929 ''' 8930 Get reads one workflow by ID. 8931 ''' 8932 return self.workflows.get(id, timeout=timeout) 8933 8934 def list(self, filter, *args, timeout=None): 8935 ''' 8936 Lists existing workflows. 8937 ''' 8938 return self.workflows.list(filter, *args, timeout=timeout) 8939 8940 8941class WorkflowsHistory: 8942 ''' 8943 WorkflowsHistory provides records of all changes to the state of a Workflow. 8944 See `strongdm.models.WorkflowHistory`. 8945 ''' 8946 def __init__(self, channel, client): 8947 self.parent = client 8948 self.stub = WorkflowsHistoryStub(channel) 8949 8950 def list(self, filter, *args, timeout=None): 8951 ''' 8952 List gets a list of WorkflowHistory records matching a given set of criteria. 8953 ''' 8954 deadline = None if timeout is None else time.time() + timeout 8955 req = WorkflowHistoryListRequest() 8956 req.meta.CopyFrom(ListRequestMetadata()) 8957 if self.parent.page_limit > 0: 8958 req.meta.limit = self.parent.page_limit 8959 if self.parent.snapshot_datetime is not None: 8960 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8961 8962 req.filter = plumbing.quote_filter_args(filter, *args) 8963 8964 def generator(svc, req): 8965 tries = 0 8966 while True: 8967 t = None if deadline is None else deadline - time.time() 8968 try: 8969 plumbing_response = svc.stub.List( 8970 req, 8971 metadata=svc.parent.get_metadata( 8972 'WorkflowsHistory.List', req), 8973 timeout=t) 8974 except Exception as e: 8975 if self.parent.shouldRetry(tries, e, deadline): 8976 tries += 1 8977 time.sleep( 8978 self.parent.exponentialBackoff(tries, deadline)) 8979 continue 8980 raise plumbing.convert_error_to_porcelain(e) from e 8981 tries = 0 8982 for plumbing_item in plumbing_response.history: 8983 yield plumbing.convert_workflow_history_to_porcelain( 8984 plumbing_item) 8985 if plumbing_response.meta.next_cursor == '': 8986 break 8987 req.meta.cursor = plumbing_response.meta.next_cursor 8988 8989 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.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
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.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)
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
Create registers a new Resource.
def
get(self, id, timeout=None)
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
Get reads one Resource by ID.
def
update(self, resource, timeout=None)
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
Update replaces all the fields of a Resource by ID.
def
delete(self, id, timeout=None)
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
Delete removes a Resource by ID.
def
list(self, filter, *args, timeout=None)
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)
List gets a list of Resources matching a given set of criteria.
def
healthcheck(self, id, timeout=None)
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
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:
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)
SnapshotResources exposes the read only methods of the Resources service for historical queries.
def
get(self, id, timeout=None)
7328 def get(self, id, timeout=None): 7329 ''' 7330 Get reads one Resource by ID. 7331 ''' 7332 return self.resources.get(id, timeout=timeout)
Get reads one Resource by ID.
def
list(self, filter, *args, timeout=None)
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)
List gets a list of Resources matching a given set of criteria.
class
ResourcesHistory:
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)
ResourcesHistory records all changes to the state of a Resource.
See strongdm.models.ResourceHistory.
def
list(self, filter, *args, timeout=None)
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)
List gets a list of ResourceHistory records matching a given set of criteria.
class
RoleResources:
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)
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)
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)
List gets a list of RoleResource records matching a given set of criteria.
class
SnapshotRoleResources:
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)
SnapshotRoleResources exposes the read only methods of the RoleResources service for historical queries.
def
list(self, filter, *args, timeout=None)
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)
List gets a list of RoleResource records matching a given set of criteria.
class
RoleResourcesHistory:
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)
RoleResourcesHistory records all changes to the state of a RoleResource.
See strongdm.models.RoleResourceHistory.
def
list(self, filter, *args, timeout=None)
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)
List gets a list of RoleResourceHistory records matching a given set of criteria.
class
RolesHistory:
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)
RolesHistory records all changes to the state of a Role.
See strongdm.models.RoleHistory.
def
list(self, filter, *args, timeout=None)
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)
List gets a list of RoleHistory records matching a given set of criteria.
class
SecretStores:
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.GCPStore` 7574 `strongdm.models.GCPCertX509Store` 7575 `strongdm.models.KeyfactorSSHStore` 7576 `strongdm.models.KeyfactorX509Store` 7577 `strongdm.models.StrongVaultStore` 7578 `strongdm.models.VaultAppRoleStore` 7579 `strongdm.models.VaultAppRoleCertSSHStore` 7580 `strongdm.models.VaultAppRoleCertX509Store` 7581 `strongdm.models.VaultAWSEC2Store` 7582 `strongdm.models.VaultAWSEC2CertSSHStore` 7583 `strongdm.models.VaultAWSEC2CertX509Store` 7584 `strongdm.models.VaultAWSIAMStore` 7585 `strongdm.models.VaultAWSIAMCertSSHStore` 7586 `strongdm.models.VaultAWSIAMCertX509Store` 7587 `strongdm.models.VaultTLSStore` 7588 `strongdm.models.VaultTLSCertSSHStore` 7589 `strongdm.models.VaultTLSCertX509Store` 7590 `strongdm.models.VaultTokenStore` 7591 `strongdm.models.VaultTokenCertSSHStore` 7592 `strongdm.models.VaultTokenCertX509Store` 7593 ''' 7594 def __init__(self, channel, client): 7595 self.parent = client 7596 self.stub = SecretStoresStub(channel) 7597 7598 def create(self, secret_store, timeout=None): 7599 deadline = None if timeout is None else time.time() + timeout 7600 req = SecretStoreCreateRequest() 7601 7602 if secret_store is not None: 7603 req.secret_store.CopyFrom( 7604 plumbing.convert_secret_store_to_plumbing(secret_store)) 7605 tries = 0 7606 plumbing_response = None 7607 while True: 7608 t = None if deadline is None else deadline - time.time() 7609 try: 7610 plumbing_response = self.stub.Create( 7611 req, 7612 metadata=self.parent.get_metadata('SecretStores.Create', 7613 req), 7614 timeout=t) 7615 except Exception as e: 7616 if self.parent.shouldRetry(tries, e, deadline): 7617 tries += 1 7618 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7619 continue 7620 raise plumbing.convert_error_to_porcelain(e) from e 7621 break 7622 7623 resp = models.SecretStoreCreateResponse() 7624 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 7625 plumbing_response.meta) 7626 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7627 plumbing_response.rate_limit) 7628 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 7629 plumbing_response.secret_store) 7630 return resp 7631 7632 def get(self, id, timeout=None): 7633 ''' 7634 Get reads one SecretStore by ID. 7635 ''' 7636 deadline = None if timeout is None else time.time() + timeout 7637 req = SecretStoreGetRequest() 7638 if self.parent.snapshot_datetime is not None: 7639 req.meta.CopyFrom(GetRequestMetadata()) 7640 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7641 7642 req.id = (id) 7643 tries = 0 7644 plumbing_response = None 7645 while True: 7646 t = None if deadline is None else deadline - time.time() 7647 try: 7648 plumbing_response = self.stub.Get( 7649 req, 7650 metadata=self.parent.get_metadata('SecretStores.Get', req), 7651 timeout=t) 7652 except Exception as e: 7653 if self.parent.shouldRetry(tries, e, deadline): 7654 tries += 1 7655 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7656 continue 7657 raise plumbing.convert_error_to_porcelain(e) from e 7658 break 7659 7660 resp = models.SecretStoreGetResponse() 7661 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 7662 plumbing_response.meta) 7663 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7664 plumbing_response.rate_limit) 7665 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 7666 plumbing_response.secret_store) 7667 return resp 7668 7669 def update(self, secret_store, timeout=None): 7670 ''' 7671 Update replaces all the fields of a SecretStore by ID. 7672 ''' 7673 deadline = None if timeout is None else time.time() + timeout 7674 req = SecretStoreUpdateRequest() 7675 7676 if secret_store is not None: 7677 req.secret_store.CopyFrom( 7678 plumbing.convert_secret_store_to_plumbing(secret_store)) 7679 tries = 0 7680 plumbing_response = None 7681 while True: 7682 t = None if deadline is None else deadline - time.time() 7683 try: 7684 plumbing_response = self.stub.Update( 7685 req, 7686 metadata=self.parent.get_metadata('SecretStores.Update', 7687 req), 7688 timeout=t) 7689 except Exception as e: 7690 if self.parent.shouldRetry(tries, e, deadline): 7691 tries += 1 7692 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7693 continue 7694 raise plumbing.convert_error_to_porcelain(e) from e 7695 break 7696 7697 resp = models.SecretStoreUpdateResponse() 7698 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 7699 plumbing_response.meta) 7700 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7701 plumbing_response.rate_limit) 7702 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 7703 plumbing_response.secret_store) 7704 return resp 7705 7706 def delete(self, id, timeout=None): 7707 ''' 7708 Delete removes a SecretStore by ID. 7709 ''' 7710 deadline = None if timeout is None else time.time() + timeout 7711 req = SecretStoreDeleteRequest() 7712 7713 req.id = (id) 7714 tries = 0 7715 plumbing_response = None 7716 while True: 7717 t = None if deadline is None else deadline - time.time() 7718 try: 7719 plumbing_response = self.stub.Delete( 7720 req, 7721 metadata=self.parent.get_metadata('SecretStores.Delete', 7722 req), 7723 timeout=t) 7724 except Exception as e: 7725 if self.parent.shouldRetry(tries, e, deadline): 7726 tries += 1 7727 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7728 continue 7729 raise plumbing.convert_error_to_porcelain(e) from e 7730 break 7731 7732 resp = models.SecretStoreDeleteResponse() 7733 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 7734 plumbing_response.meta) 7735 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7736 plumbing_response.rate_limit) 7737 return resp 7738 7739 def list(self, filter, *args, timeout=None): 7740 ''' 7741 List gets a list of SecretStores matching a given set of criteria. 7742 ''' 7743 deadline = None if timeout is None else time.time() + timeout 7744 req = SecretStoreListRequest() 7745 req.meta.CopyFrom(ListRequestMetadata()) 7746 if self.parent.page_limit > 0: 7747 req.meta.limit = self.parent.page_limit 7748 if self.parent.snapshot_datetime is not None: 7749 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7750 7751 req.filter = plumbing.quote_filter_args(filter, *args) 7752 7753 def generator(svc, req): 7754 tries = 0 7755 while True: 7756 t = None if deadline is None else deadline - time.time() 7757 try: 7758 plumbing_response = svc.stub.List( 7759 req, 7760 metadata=svc.parent.get_metadata( 7761 'SecretStores.List', req), 7762 timeout=t) 7763 except Exception as e: 7764 if self.parent.shouldRetry(tries, e, deadline): 7765 tries += 1 7766 time.sleep( 7767 self.parent.exponentialBackoff(tries, deadline)) 7768 continue 7769 raise plumbing.convert_error_to_porcelain(e) from e 7770 tries = 0 7771 for plumbing_item in plumbing_response.secret_stores: 7772 yield plumbing.convert_secret_store_to_porcelain( 7773 plumbing_item) 7774 if plumbing_response.meta.next_cursor == '': 7775 break 7776 req.meta.cursor = plumbing_response.meta.next_cursor 7777 7778 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.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)
7598 def create(self, secret_store, timeout=None): 7599 deadline = None if timeout is None else time.time() + timeout 7600 req = SecretStoreCreateRequest() 7601 7602 if secret_store is not None: 7603 req.secret_store.CopyFrom( 7604 plumbing.convert_secret_store_to_plumbing(secret_store)) 7605 tries = 0 7606 plumbing_response = None 7607 while True: 7608 t = None if deadline is None else deadline - time.time() 7609 try: 7610 plumbing_response = self.stub.Create( 7611 req, 7612 metadata=self.parent.get_metadata('SecretStores.Create', 7613 req), 7614 timeout=t) 7615 except Exception as e: 7616 if self.parent.shouldRetry(tries, e, deadline): 7617 tries += 1 7618 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7619 continue 7620 raise plumbing.convert_error_to_porcelain(e) from e 7621 break 7622 7623 resp = models.SecretStoreCreateResponse() 7624 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 7625 plumbing_response.meta) 7626 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7627 plumbing_response.rate_limit) 7628 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 7629 plumbing_response.secret_store) 7630 return resp
def
get(self, id, timeout=None)
7632 def get(self, id, timeout=None): 7633 ''' 7634 Get reads one SecretStore by ID. 7635 ''' 7636 deadline = None if timeout is None else time.time() + timeout 7637 req = SecretStoreGetRequest() 7638 if self.parent.snapshot_datetime is not None: 7639 req.meta.CopyFrom(GetRequestMetadata()) 7640 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7641 7642 req.id = (id) 7643 tries = 0 7644 plumbing_response = None 7645 while True: 7646 t = None if deadline is None else deadline - time.time() 7647 try: 7648 plumbing_response = self.stub.Get( 7649 req, 7650 metadata=self.parent.get_metadata('SecretStores.Get', req), 7651 timeout=t) 7652 except Exception as e: 7653 if self.parent.shouldRetry(tries, e, deadline): 7654 tries += 1 7655 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7656 continue 7657 raise plumbing.convert_error_to_porcelain(e) from e 7658 break 7659 7660 resp = models.SecretStoreGetResponse() 7661 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 7662 plumbing_response.meta) 7663 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7664 plumbing_response.rate_limit) 7665 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 7666 plumbing_response.secret_store) 7667 return resp
Get reads one SecretStore by ID.
def
update(self, secret_store, timeout=None)
7669 def update(self, secret_store, timeout=None): 7670 ''' 7671 Update replaces all the fields of a SecretStore by ID. 7672 ''' 7673 deadline = None if timeout is None else time.time() + timeout 7674 req = SecretStoreUpdateRequest() 7675 7676 if secret_store is not None: 7677 req.secret_store.CopyFrom( 7678 plumbing.convert_secret_store_to_plumbing(secret_store)) 7679 tries = 0 7680 plumbing_response = None 7681 while True: 7682 t = None if deadline is None else deadline - time.time() 7683 try: 7684 plumbing_response = self.stub.Update( 7685 req, 7686 metadata=self.parent.get_metadata('SecretStores.Update', 7687 req), 7688 timeout=t) 7689 except Exception as e: 7690 if self.parent.shouldRetry(tries, e, deadline): 7691 tries += 1 7692 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7693 continue 7694 raise plumbing.convert_error_to_porcelain(e) from e 7695 break 7696 7697 resp = models.SecretStoreUpdateResponse() 7698 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 7699 plumbing_response.meta) 7700 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7701 plumbing_response.rate_limit) 7702 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 7703 plumbing_response.secret_store) 7704 return resp
Update replaces all the fields of a SecretStore by ID.
def
delete(self, id, timeout=None)
7706 def delete(self, id, timeout=None): 7707 ''' 7708 Delete removes a SecretStore by ID. 7709 ''' 7710 deadline = None if timeout is None else time.time() + timeout 7711 req = SecretStoreDeleteRequest() 7712 7713 req.id = (id) 7714 tries = 0 7715 plumbing_response = None 7716 while True: 7717 t = None if deadline is None else deadline - time.time() 7718 try: 7719 plumbing_response = self.stub.Delete( 7720 req, 7721 metadata=self.parent.get_metadata('SecretStores.Delete', 7722 req), 7723 timeout=t) 7724 except Exception as e: 7725 if self.parent.shouldRetry(tries, e, deadline): 7726 tries += 1 7727 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7728 continue 7729 raise plumbing.convert_error_to_porcelain(e) from e 7730 break 7731 7732 resp = models.SecretStoreDeleteResponse() 7733 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 7734 plumbing_response.meta) 7735 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7736 plumbing_response.rate_limit) 7737 return resp
Delete removes a SecretStore by ID.
def
list(self, filter, *args, timeout=None)
7739 def list(self, filter, *args, timeout=None): 7740 ''' 7741 List gets a list of SecretStores matching a given set of criteria. 7742 ''' 7743 deadline = None if timeout is None else time.time() + timeout 7744 req = SecretStoreListRequest() 7745 req.meta.CopyFrom(ListRequestMetadata()) 7746 if self.parent.page_limit > 0: 7747 req.meta.limit = self.parent.page_limit 7748 if self.parent.snapshot_datetime is not None: 7749 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7750 7751 req.filter = plumbing.quote_filter_args(filter, *args) 7752 7753 def generator(svc, req): 7754 tries = 0 7755 while True: 7756 t = None if deadline is None else deadline - time.time() 7757 try: 7758 plumbing_response = svc.stub.List( 7759 req, 7760 metadata=svc.parent.get_metadata( 7761 'SecretStores.List', req), 7762 timeout=t) 7763 except Exception as e: 7764 if self.parent.shouldRetry(tries, e, deadline): 7765 tries += 1 7766 time.sleep( 7767 self.parent.exponentialBackoff(tries, deadline)) 7768 continue 7769 raise plumbing.convert_error_to_porcelain(e) from e 7770 tries = 0 7771 for plumbing_item in plumbing_response.secret_stores: 7772 yield plumbing.convert_secret_store_to_porcelain( 7773 plumbing_item) 7774 if plumbing_response.meta.next_cursor == '': 7775 break 7776 req.meta.cursor = plumbing_response.meta.next_cursor 7777 7778 return generator(self, req)
List gets a list of SecretStores matching a given set of criteria.
class
SnapshotSecretStores:
7781class SnapshotSecretStores: 7782 ''' 7783 SnapshotSecretStores exposes the read only methods of the SecretStores 7784 service for historical queries. 7785 ''' 7786 def __init__(self, secret_stores): 7787 self.secret_stores = secret_stores 7788 7789 def get(self, id, timeout=None): 7790 ''' 7791 Get reads one SecretStore by ID. 7792 ''' 7793 return self.secret_stores.get(id, timeout=timeout) 7794 7795 def list(self, filter, *args, timeout=None): 7796 ''' 7797 List gets a list of SecretStores matching a given set of criteria. 7798 ''' 7799 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)
7789 def get(self, id, timeout=None): 7790 ''' 7791 Get reads one SecretStore by ID. 7792 ''' 7793 return self.secret_stores.get(id, timeout=timeout)
Get reads one SecretStore by ID.
def
list(self, filter, *args, timeout=None)
7795 def list(self, filter, *args, timeout=None): 7796 ''' 7797 List gets a list of SecretStores matching a given set of criteria. 7798 ''' 7799 return self.secret_stores.list(filter, *args, timeout=timeout)
List gets a list of SecretStores matching a given set of criteria.
class
SecretEngines:
7802class SecretEngines: 7803 ''' 7804 7805 See: 7806 `strongdm.models.ActiveDirectoryEngine` 7807 `strongdm.models.KeyValueEngine` 7808 `strongdm.models.MysqlEngine` 7809 `strongdm.models.PostgresEngine` 7810 `strongdm.models.SqlserverEngine` 7811 ''' 7812 def __init__(self, channel, client): 7813 self.parent = client 7814 self.stub = SecretEnginesStub(channel) 7815 7816 def list(self, filter, *args, timeout=None): 7817 ''' 7818 List returns a list of Secret Engines 7819 ''' 7820 deadline = None if timeout is None else time.time() + timeout 7821 req = SecretEngineListRequest() 7822 req.meta.CopyFrom(ListRequestMetadata()) 7823 if self.parent.page_limit > 0: 7824 req.meta.limit = self.parent.page_limit 7825 if self.parent.snapshot_datetime is not None: 7826 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7827 7828 req.filter = plumbing.quote_filter_args(filter, *args) 7829 7830 def generator(svc, req): 7831 tries = 0 7832 while True: 7833 t = None if deadline is None else deadline - time.time() 7834 try: 7835 plumbing_response = svc.stub.List( 7836 req, 7837 metadata=svc.parent.get_metadata( 7838 'SecretEngines.List', req), 7839 timeout=t) 7840 except Exception as e: 7841 if self.parent.shouldRetry(tries, e, deadline): 7842 tries += 1 7843 time.sleep( 7844 self.parent.exponentialBackoff(tries, deadline)) 7845 continue 7846 raise plumbing.convert_error_to_porcelain(e) from e 7847 tries = 0 7848 for plumbing_item in plumbing_response.secret_engines: 7849 yield plumbing.convert_secret_engine_to_porcelain( 7850 plumbing_item) 7851 if plumbing_response.meta.next_cursor == '': 7852 break 7853 req.meta.cursor = plumbing_response.meta.next_cursor 7854 7855 return generator(self, req) 7856 7857 def get(self, id, timeout=None): 7858 ''' 7859 Get returns a secret engine details 7860 ''' 7861 deadline = None if timeout is None else time.time() + timeout 7862 req = SecretEngineGetRequest() 7863 if self.parent.snapshot_datetime is not None: 7864 req.meta.CopyFrom(GetRequestMetadata()) 7865 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7866 7867 req.id = (id) 7868 tries = 0 7869 plumbing_response = None 7870 while True: 7871 t = None if deadline is None else deadline - time.time() 7872 try: 7873 plumbing_response = self.stub.Get( 7874 req, 7875 metadata=self.parent.get_metadata('SecretEngines.Get', 7876 req), 7877 timeout=t) 7878 except Exception as e: 7879 if self.parent.shouldRetry(tries, e, deadline): 7880 tries += 1 7881 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7882 continue 7883 raise plumbing.convert_error_to_porcelain(e) from e 7884 break 7885 7886 resp = models.SecretEngineGetResponse() 7887 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 7888 plumbing_response.meta) 7889 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7890 plumbing_response.rate_limit) 7891 resp.secret_engine = plumbing.convert_secret_engine_to_porcelain( 7892 plumbing_response.secret_engine) 7893 return resp 7894 7895 def create(self, secret_engine, timeout=None): 7896 ''' 7897 Create creates a secret engine 7898 ''' 7899 deadline = None if timeout is None else time.time() + timeout 7900 req = SecretEngineCreateRequest() 7901 7902 if secret_engine is not None: 7903 req.secret_engine.CopyFrom( 7904 plumbing.convert_secret_engine_to_plumbing(secret_engine)) 7905 tries = 0 7906 plumbing_response = None 7907 while True: 7908 t = None if deadline is None else deadline - time.time() 7909 try: 7910 plumbing_response = self.stub.Create( 7911 req, 7912 metadata=self.parent.get_metadata('SecretEngines.Create', 7913 req), 7914 timeout=t) 7915 except Exception as e: 7916 if self.parent.shouldRetry(tries, e, deadline): 7917 tries += 1 7918 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7919 continue 7920 raise plumbing.convert_error_to_porcelain(e) from e 7921 break 7922 7923 resp = models.SecretEngineCreateResponse() 7924 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 7925 plumbing_response.meta) 7926 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7927 plumbing_response.rate_limit) 7928 resp.secret_engine = plumbing.convert_secret_engine_to_porcelain( 7929 plumbing_response.secret_engine) 7930 return resp 7931 7932 def update(self, secret_engine, timeout=None): 7933 ''' 7934 Update updates a secret engine 7935 ''' 7936 deadline = None if timeout is None else time.time() + timeout 7937 req = SecretEngineUpdateRequest() 7938 7939 if secret_engine is not None: 7940 req.secret_engine.CopyFrom( 7941 plumbing.convert_secret_engine_to_plumbing(secret_engine)) 7942 tries = 0 7943 plumbing_response = None 7944 while True: 7945 t = None if deadline is None else deadline - time.time() 7946 try: 7947 plumbing_response = self.stub.Update( 7948 req, 7949 metadata=self.parent.get_metadata('SecretEngines.Update', 7950 req), 7951 timeout=t) 7952 except Exception as e: 7953 if self.parent.shouldRetry(tries, e, deadline): 7954 tries += 1 7955 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7956 continue 7957 raise plumbing.convert_error_to_porcelain(e) from e 7958 break 7959 7960 resp = models.SecretEngineUpdateResponse() 7961 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 7962 plumbing_response.meta) 7963 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7964 plumbing_response.rate_limit) 7965 resp.secret_engine = plumbing.convert_secret_engine_to_porcelain( 7966 plumbing_response.secret_engine) 7967 return resp 7968 7969 def delete(self, id, timeout=None): 7970 ''' 7971 Delete deletes a secret engine 7972 ''' 7973 deadline = None if timeout is None else time.time() + timeout 7974 req = SecretEngineDeleteRequest() 7975 7976 req.id = (id) 7977 tries = 0 7978 plumbing_response = None 7979 while True: 7980 t = None if deadline is None else deadline - time.time() 7981 try: 7982 plumbing_response = self.stub.Delete( 7983 req, 7984 metadata=self.parent.get_metadata('SecretEngines.Delete', 7985 req), 7986 timeout=t) 7987 except Exception as e: 7988 if self.parent.shouldRetry(tries, e, deadline): 7989 tries += 1 7990 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7991 continue 7992 raise plumbing.convert_error_to_porcelain(e) from e 7993 break 7994 7995 resp = models.SecretEngineDeleteResponse() 7996 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7997 plumbing_response.rate_limit) 7998 return resp 7999 8000 def list_secret_stores(self, filter, *args, timeout=None): 8001 ''' 8002 ListSecretStores returns a list of Secret Stores that can be used as a backing store 8003 for Secret Engine 8004 ''' 8005 deadline = None if timeout is None else time.time() + timeout 8006 req = SecretStoreListRequest() 8007 req.meta.CopyFrom(ListRequestMetadata()) 8008 if self.parent.page_limit > 0: 8009 req.meta.limit = self.parent.page_limit 8010 if self.parent.snapshot_datetime is not None: 8011 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8012 8013 req.filter = plumbing.quote_filter_args(filter, *args) 8014 8015 def generator(svc, req): 8016 tries = 0 8017 while True: 8018 t = None if deadline is None else deadline - time.time() 8019 try: 8020 plumbing_response = svc.stub.ListSecretStores( 8021 req, 8022 metadata=svc.parent.get_metadata( 8023 'SecretEngines.ListSecretStores', req), 8024 timeout=t) 8025 except Exception as e: 8026 if self.parent.shouldRetry(tries, e, deadline): 8027 tries += 1 8028 time.sleep( 8029 self.parent.exponentialBackoff(tries, deadline)) 8030 continue 8031 raise plumbing.convert_error_to_porcelain(e) from e 8032 tries = 0 8033 for plumbing_item in plumbing_response.secret_stores: 8034 yield plumbing.convert_secret_store_to_porcelain( 8035 plumbing_item) 8036 if plumbing_response.meta.next_cursor == '': 8037 break 8038 req.meta.cursor = plumbing_response.meta.next_cursor 8039 8040 return generator(self, req) 8041 8042 def generate_keys(self, secret_engine_id, timeout=None): 8043 ''' 8044 GenerateKeys generates a private key, stores it in a secret store and stores a public key in a secret engine 8045 ''' 8046 deadline = None if timeout is None else time.time() + timeout 8047 req = GenerateKeysRequest() 8048 8049 req.secret_engine_id = (secret_engine_id) 8050 tries = 0 8051 plumbing_response = None 8052 while True: 8053 t = None if deadline is None else deadline - time.time() 8054 try: 8055 plumbing_response = self.stub.GenerateKeys( 8056 req, 8057 metadata=self.parent.get_metadata( 8058 'SecretEngines.GenerateKeys', req), 8059 timeout=t) 8060 except Exception as e: 8061 if self.parent.shouldRetry(tries, e, deadline): 8062 tries += 1 8063 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8064 continue 8065 raise plumbing.convert_error_to_porcelain(e) from e 8066 break 8067 8068 resp = models.GenerateKeysResponse() 8069 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8070 plumbing_response.rate_limit) 8071 return resp 8072 8073 def healthcheck(self, secret_engine_id, timeout=None): 8074 ''' 8075 Healthcheck triggers a healthcheck for all nodes serving a secret engine 8076 ''' 8077 deadline = None if timeout is None else time.time() + timeout 8078 req = HealthcheckRequest() 8079 8080 req.secret_engine_id = (secret_engine_id) 8081 tries = 0 8082 plumbing_response = None 8083 while True: 8084 t = None if deadline is None else deadline - time.time() 8085 try: 8086 plumbing_response = self.stub.Healthcheck( 8087 req, 8088 metadata=self.parent.get_metadata( 8089 'SecretEngines.Healthcheck', req), 8090 timeout=t) 8091 except Exception as e: 8092 if self.parent.shouldRetry(tries, e, deadline): 8093 tries += 1 8094 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8095 continue 8096 raise plumbing.convert_error_to_porcelain(e) from e 8097 break 8098 8099 resp = models.HealthcheckResponse() 8100 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8101 plumbing_response.rate_limit) 8102 resp.status = plumbing.convert_repeated_healthcheck_status_to_porcelain( 8103 plumbing_response.status) 8104 return resp 8105 8106 def rotate(self, id, password_policy, timeout=None): 8107 ''' 8108 Rotate rotates secret engine's credentials 8109 ''' 8110 deadline = None if timeout is None else time.time() + timeout 8111 req = SecretEngineRotateRequest() 8112 8113 req.id = (id) 8114 if password_policy is not None: 8115 req.password_policy.CopyFrom( 8116 plumbing.convert_secret_engine_password_policy_to_plumbing( 8117 password_policy)) 8118 tries = 0 8119 plumbing_response = None 8120 while True: 8121 t = None if deadline is None else deadline - time.time() 8122 try: 8123 plumbing_response = self.stub.Rotate( 8124 req, 8125 metadata=self.parent.get_metadata('SecretEngines.Rotate', 8126 req), 8127 timeout=t) 8128 except Exception as e: 8129 if self.parent.shouldRetry(tries, e, deadline): 8130 tries += 1 8131 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8132 continue 8133 raise plumbing.convert_error_to_porcelain(e) from e 8134 break 8135 8136 resp = models.SecretEngineRotateResponse() 8137 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8138 plumbing_response.rate_limit) 8139 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)
7816 def list(self, filter, *args, timeout=None): 7817 ''' 7818 List returns a list of Secret Engines 7819 ''' 7820 deadline = None if timeout is None else time.time() + timeout 7821 req = SecretEngineListRequest() 7822 req.meta.CopyFrom(ListRequestMetadata()) 7823 if self.parent.page_limit > 0: 7824 req.meta.limit = self.parent.page_limit 7825 if self.parent.snapshot_datetime is not None: 7826 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7827 7828 req.filter = plumbing.quote_filter_args(filter, *args) 7829 7830 def generator(svc, req): 7831 tries = 0 7832 while True: 7833 t = None if deadline is None else deadline - time.time() 7834 try: 7835 plumbing_response = svc.stub.List( 7836 req, 7837 metadata=svc.parent.get_metadata( 7838 'SecretEngines.List', req), 7839 timeout=t) 7840 except Exception as e: 7841 if self.parent.shouldRetry(tries, e, deadline): 7842 tries += 1 7843 time.sleep( 7844 self.parent.exponentialBackoff(tries, deadline)) 7845 continue 7846 raise plumbing.convert_error_to_porcelain(e) from e 7847 tries = 0 7848 for plumbing_item in plumbing_response.secret_engines: 7849 yield plumbing.convert_secret_engine_to_porcelain( 7850 plumbing_item) 7851 if plumbing_response.meta.next_cursor == '': 7852 break 7853 req.meta.cursor = plumbing_response.meta.next_cursor 7854 7855 return generator(self, req)
List returns a list of Secret Engines
def
get(self, id, timeout=None)
7857 def get(self, id, timeout=None): 7858 ''' 7859 Get returns a secret engine details 7860 ''' 7861 deadline = None if timeout is None else time.time() + timeout 7862 req = SecretEngineGetRequest() 7863 if self.parent.snapshot_datetime is not None: 7864 req.meta.CopyFrom(GetRequestMetadata()) 7865 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7866 7867 req.id = (id) 7868 tries = 0 7869 plumbing_response = None 7870 while True: 7871 t = None if deadline is None else deadline - time.time() 7872 try: 7873 plumbing_response = self.stub.Get( 7874 req, 7875 metadata=self.parent.get_metadata('SecretEngines.Get', 7876 req), 7877 timeout=t) 7878 except Exception as e: 7879 if self.parent.shouldRetry(tries, e, deadline): 7880 tries += 1 7881 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7882 continue 7883 raise plumbing.convert_error_to_porcelain(e) from e 7884 break 7885 7886 resp = models.SecretEngineGetResponse() 7887 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 7888 plumbing_response.meta) 7889 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7890 plumbing_response.rate_limit) 7891 resp.secret_engine = plumbing.convert_secret_engine_to_porcelain( 7892 plumbing_response.secret_engine) 7893 return resp
Get returns a secret engine details
def
create(self, secret_engine, timeout=None)
7895 def create(self, secret_engine, timeout=None): 7896 ''' 7897 Create creates a secret engine 7898 ''' 7899 deadline = None if timeout is None else time.time() + timeout 7900 req = SecretEngineCreateRequest() 7901 7902 if secret_engine is not None: 7903 req.secret_engine.CopyFrom( 7904 plumbing.convert_secret_engine_to_plumbing(secret_engine)) 7905 tries = 0 7906 plumbing_response = None 7907 while True: 7908 t = None if deadline is None else deadline - time.time() 7909 try: 7910 plumbing_response = self.stub.Create( 7911 req, 7912 metadata=self.parent.get_metadata('SecretEngines.Create', 7913 req), 7914 timeout=t) 7915 except Exception as e: 7916 if self.parent.shouldRetry(tries, e, deadline): 7917 tries += 1 7918 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7919 continue 7920 raise plumbing.convert_error_to_porcelain(e) from e 7921 break 7922 7923 resp = models.SecretEngineCreateResponse() 7924 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 7925 plumbing_response.meta) 7926 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7927 plumbing_response.rate_limit) 7928 resp.secret_engine = plumbing.convert_secret_engine_to_porcelain( 7929 plumbing_response.secret_engine) 7930 return resp
Create creates a secret engine
def
update(self, secret_engine, timeout=None)
7932 def update(self, secret_engine, timeout=None): 7933 ''' 7934 Update updates a secret engine 7935 ''' 7936 deadline = None if timeout is None else time.time() + timeout 7937 req = SecretEngineUpdateRequest() 7938 7939 if secret_engine is not None: 7940 req.secret_engine.CopyFrom( 7941 plumbing.convert_secret_engine_to_plumbing(secret_engine)) 7942 tries = 0 7943 plumbing_response = None 7944 while True: 7945 t = None if deadline is None else deadline - time.time() 7946 try: 7947 plumbing_response = self.stub.Update( 7948 req, 7949 metadata=self.parent.get_metadata('SecretEngines.Update', 7950 req), 7951 timeout=t) 7952 except Exception as e: 7953 if self.parent.shouldRetry(tries, e, deadline): 7954 tries += 1 7955 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7956 continue 7957 raise plumbing.convert_error_to_porcelain(e) from e 7958 break 7959 7960 resp = models.SecretEngineUpdateResponse() 7961 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 7962 plumbing_response.meta) 7963 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7964 plumbing_response.rate_limit) 7965 resp.secret_engine = plumbing.convert_secret_engine_to_porcelain( 7966 plumbing_response.secret_engine) 7967 return resp
Update updates a secret engine
def
delete(self, id, timeout=None)
7969 def delete(self, id, timeout=None): 7970 ''' 7971 Delete deletes a secret engine 7972 ''' 7973 deadline = None if timeout is None else time.time() + timeout 7974 req = SecretEngineDeleteRequest() 7975 7976 req.id = (id) 7977 tries = 0 7978 plumbing_response = None 7979 while True: 7980 t = None if deadline is None else deadline - time.time() 7981 try: 7982 plumbing_response = self.stub.Delete( 7983 req, 7984 metadata=self.parent.get_metadata('SecretEngines.Delete', 7985 req), 7986 timeout=t) 7987 except Exception as e: 7988 if self.parent.shouldRetry(tries, e, deadline): 7989 tries += 1 7990 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7991 continue 7992 raise plumbing.convert_error_to_porcelain(e) from e 7993 break 7994 7995 resp = models.SecretEngineDeleteResponse() 7996 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7997 plumbing_response.rate_limit) 7998 return resp
Delete deletes a secret engine
def
list_secret_stores(self, filter, *args, timeout=None)
8000 def list_secret_stores(self, filter, *args, timeout=None): 8001 ''' 8002 ListSecretStores returns a list of Secret Stores that can be used as a backing store 8003 for Secret Engine 8004 ''' 8005 deadline = None if timeout is None else time.time() + timeout 8006 req = SecretStoreListRequest() 8007 req.meta.CopyFrom(ListRequestMetadata()) 8008 if self.parent.page_limit > 0: 8009 req.meta.limit = self.parent.page_limit 8010 if self.parent.snapshot_datetime is not None: 8011 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8012 8013 req.filter = plumbing.quote_filter_args(filter, *args) 8014 8015 def generator(svc, req): 8016 tries = 0 8017 while True: 8018 t = None if deadline is None else deadline - time.time() 8019 try: 8020 plumbing_response = svc.stub.ListSecretStores( 8021 req, 8022 metadata=svc.parent.get_metadata( 8023 'SecretEngines.ListSecretStores', req), 8024 timeout=t) 8025 except Exception as e: 8026 if self.parent.shouldRetry(tries, e, deadline): 8027 tries += 1 8028 time.sleep( 8029 self.parent.exponentialBackoff(tries, deadline)) 8030 continue 8031 raise plumbing.convert_error_to_porcelain(e) from e 8032 tries = 0 8033 for plumbing_item in plumbing_response.secret_stores: 8034 yield plumbing.convert_secret_store_to_porcelain( 8035 plumbing_item) 8036 if plumbing_response.meta.next_cursor == '': 8037 break 8038 req.meta.cursor = plumbing_response.meta.next_cursor 8039 8040 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)
8042 def generate_keys(self, secret_engine_id, timeout=None): 8043 ''' 8044 GenerateKeys generates a private key, stores it in a secret store and stores a public key in a secret engine 8045 ''' 8046 deadline = None if timeout is None else time.time() + timeout 8047 req = GenerateKeysRequest() 8048 8049 req.secret_engine_id = (secret_engine_id) 8050 tries = 0 8051 plumbing_response = None 8052 while True: 8053 t = None if deadline is None else deadline - time.time() 8054 try: 8055 plumbing_response = self.stub.GenerateKeys( 8056 req, 8057 metadata=self.parent.get_metadata( 8058 'SecretEngines.GenerateKeys', req), 8059 timeout=t) 8060 except Exception as e: 8061 if self.parent.shouldRetry(tries, e, deadline): 8062 tries += 1 8063 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8064 continue 8065 raise plumbing.convert_error_to_porcelain(e) from e 8066 break 8067 8068 resp = models.GenerateKeysResponse() 8069 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8070 plumbing_response.rate_limit) 8071 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)
8073 def healthcheck(self, secret_engine_id, timeout=None): 8074 ''' 8075 Healthcheck triggers a healthcheck for all nodes serving a secret engine 8076 ''' 8077 deadline = None if timeout is None else time.time() + timeout 8078 req = HealthcheckRequest() 8079 8080 req.secret_engine_id = (secret_engine_id) 8081 tries = 0 8082 plumbing_response = None 8083 while True: 8084 t = None if deadline is None else deadline - time.time() 8085 try: 8086 plumbing_response = self.stub.Healthcheck( 8087 req, 8088 metadata=self.parent.get_metadata( 8089 'SecretEngines.Healthcheck', req), 8090 timeout=t) 8091 except Exception as e: 8092 if self.parent.shouldRetry(tries, e, deadline): 8093 tries += 1 8094 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8095 continue 8096 raise plumbing.convert_error_to_porcelain(e) from e 8097 break 8098 8099 resp = models.HealthcheckResponse() 8100 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8101 plumbing_response.rate_limit) 8102 resp.status = plumbing.convert_repeated_healthcheck_status_to_porcelain( 8103 plumbing_response.status) 8104 return resp
Healthcheck triggers a healthcheck for all nodes serving a secret engine
def
rotate(self, id, password_policy, timeout=None)
8106 def rotate(self, id, password_policy, timeout=None): 8107 ''' 8108 Rotate rotates secret engine's credentials 8109 ''' 8110 deadline = None if timeout is None else time.time() + timeout 8111 req = SecretEngineRotateRequest() 8112 8113 req.id = (id) 8114 if password_policy is not None: 8115 req.password_policy.CopyFrom( 8116 plumbing.convert_secret_engine_password_policy_to_plumbing( 8117 password_policy)) 8118 tries = 0 8119 plumbing_response = None 8120 while True: 8121 t = None if deadline is None else deadline - time.time() 8122 try: 8123 plumbing_response = self.stub.Rotate( 8124 req, 8125 metadata=self.parent.get_metadata('SecretEngines.Rotate', 8126 req), 8127 timeout=t) 8128 except Exception as e: 8129 if self.parent.shouldRetry(tries, e, deadline): 8130 tries += 1 8131 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8132 continue 8133 raise plumbing.convert_error_to_porcelain(e) from e 8134 break 8135 8136 resp = models.SecretEngineRotateResponse() 8137 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8138 plumbing_response.rate_limit) 8139 return resp
Rotate rotates secret engine's credentials
class
SecretStoreHealths:
8142class SecretStoreHealths: 8143 ''' 8144 SecretStoreHealths exposes health states for secret stores. 8145 See `strongdm.models.SecretStoreHealth`. 8146 ''' 8147 def __init__(self, channel, client): 8148 self.parent = client 8149 self.stub = SecretStoreHealthsStub(channel) 8150 8151 def list(self, filter, *args, timeout=None): 8152 ''' 8153 List reports the health status of node to secret store pairs. 8154 ''' 8155 deadline = None if timeout is None else time.time() + timeout 8156 req = SecretStoreHealthListRequest() 8157 req.meta.CopyFrom(ListRequestMetadata()) 8158 if self.parent.page_limit > 0: 8159 req.meta.limit = self.parent.page_limit 8160 if self.parent.snapshot_datetime is not None: 8161 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8162 8163 req.filter = plumbing.quote_filter_args(filter, *args) 8164 8165 def generator(svc, req): 8166 tries = 0 8167 while True: 8168 t = None if deadline is None else deadline - time.time() 8169 try: 8170 plumbing_response = svc.stub.List( 8171 req, 8172 metadata=svc.parent.get_metadata( 8173 'SecretStoreHealths.List', req), 8174 timeout=t) 8175 except Exception as e: 8176 if self.parent.shouldRetry(tries, e, deadline): 8177 tries += 1 8178 time.sleep( 8179 self.parent.exponentialBackoff(tries, deadline)) 8180 continue 8181 raise plumbing.convert_error_to_porcelain(e) from e 8182 tries = 0 8183 for plumbing_item in plumbing_response.secret_store_healths: 8184 yield plumbing.convert_secret_store_health_to_porcelain( 8185 plumbing_item) 8186 if plumbing_response.meta.next_cursor == '': 8187 break 8188 req.meta.cursor = plumbing_response.meta.next_cursor 8189 8190 return generator(self, req) 8191 8192 def healthcheck(self, secret_store_id, timeout=None): 8193 ''' 8194 Healthcheck triggers a remote healthcheck request for a secret store. It may take minutes 8195 to propagate across a large network of Nodes. The call will return immediately, and the 8196 updated health of the Secret Store can be retrieved via List. 8197 ''' 8198 deadline = None if timeout is None else time.time() + timeout 8199 req = SecretStoreHealthcheckRequest() 8200 8201 req.secret_store_id = (secret_store_id) 8202 tries = 0 8203 plumbing_response = None 8204 while True: 8205 t = None if deadline is None else deadline - time.time() 8206 try: 8207 plumbing_response = self.stub.Healthcheck( 8208 req, 8209 metadata=self.parent.get_metadata( 8210 'SecretStoreHealths.Healthcheck', req), 8211 timeout=t) 8212 except Exception as e: 8213 if self.parent.shouldRetry(tries, e, deadline): 8214 tries += 1 8215 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8216 continue 8217 raise plumbing.convert_error_to_porcelain(e) from e 8218 break 8219 8220 resp = models.SecretStoreHealthcheckResponse() 8221 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8222 plumbing_response.rate_limit) 8223 return resp
SecretStoreHealths exposes health states for secret stores.
See strongdm.models.SecretStoreHealth.
def
list(self, filter, *args, timeout=None)
8151 def list(self, filter, *args, timeout=None): 8152 ''' 8153 List reports the health status of node to secret store pairs. 8154 ''' 8155 deadline = None if timeout is None else time.time() + timeout 8156 req = SecretStoreHealthListRequest() 8157 req.meta.CopyFrom(ListRequestMetadata()) 8158 if self.parent.page_limit > 0: 8159 req.meta.limit = self.parent.page_limit 8160 if self.parent.snapshot_datetime is not None: 8161 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8162 8163 req.filter = plumbing.quote_filter_args(filter, *args) 8164 8165 def generator(svc, req): 8166 tries = 0 8167 while True: 8168 t = None if deadline is None else deadline - time.time() 8169 try: 8170 plumbing_response = svc.stub.List( 8171 req, 8172 metadata=svc.parent.get_metadata( 8173 'SecretStoreHealths.List', req), 8174 timeout=t) 8175 except Exception as e: 8176 if self.parent.shouldRetry(tries, e, deadline): 8177 tries += 1 8178 time.sleep( 8179 self.parent.exponentialBackoff(tries, deadline)) 8180 continue 8181 raise plumbing.convert_error_to_porcelain(e) from e 8182 tries = 0 8183 for plumbing_item in plumbing_response.secret_store_healths: 8184 yield plumbing.convert_secret_store_health_to_porcelain( 8185 plumbing_item) 8186 if plumbing_response.meta.next_cursor == '': 8187 break 8188 req.meta.cursor = plumbing_response.meta.next_cursor 8189 8190 return generator(self, req)
List reports the health status of node to secret store pairs.
def
healthcheck(self, secret_store_id, timeout=None)
8192 def healthcheck(self, secret_store_id, timeout=None): 8193 ''' 8194 Healthcheck triggers a remote healthcheck request for a secret store. It may take minutes 8195 to propagate across a large network of Nodes. The call will return immediately, and the 8196 updated health of the Secret Store can be retrieved via List. 8197 ''' 8198 deadline = None if timeout is None else time.time() + timeout 8199 req = SecretStoreHealthcheckRequest() 8200 8201 req.secret_store_id = (secret_store_id) 8202 tries = 0 8203 plumbing_response = None 8204 while True: 8205 t = None if deadline is None else deadline - time.time() 8206 try: 8207 plumbing_response = self.stub.Healthcheck( 8208 req, 8209 metadata=self.parent.get_metadata( 8210 'SecretStoreHealths.Healthcheck', req), 8211 timeout=t) 8212 except Exception as e: 8213 if self.parent.shouldRetry(tries, e, deadline): 8214 tries += 1 8215 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8216 continue 8217 raise plumbing.convert_error_to_porcelain(e) from e 8218 break 8219 8220 resp = models.SecretStoreHealthcheckResponse() 8221 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8222 plumbing_response.rate_limit) 8223 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:
8226class SecretStoresHistory: 8227 ''' 8228 SecretStoresHistory records all changes to the state of a SecretStore. 8229 See `strongdm.models.SecretStoreHistory`. 8230 ''' 8231 def __init__(self, channel, client): 8232 self.parent = client 8233 self.stub = SecretStoresHistoryStub(channel) 8234 8235 def list(self, filter, *args, timeout=None): 8236 ''' 8237 List gets a list of SecretStoreHistory records matching a given set of criteria. 8238 ''' 8239 deadline = None if timeout is None else time.time() + timeout 8240 req = SecretStoreHistoryListRequest() 8241 req.meta.CopyFrom(ListRequestMetadata()) 8242 if self.parent.page_limit > 0: 8243 req.meta.limit = self.parent.page_limit 8244 if self.parent.snapshot_datetime is not None: 8245 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8246 8247 req.filter = plumbing.quote_filter_args(filter, *args) 8248 8249 def generator(svc, req): 8250 tries = 0 8251 while True: 8252 t = None if deadline is None else deadline - time.time() 8253 try: 8254 plumbing_response = svc.stub.List( 8255 req, 8256 metadata=svc.parent.get_metadata( 8257 'SecretStoresHistory.List', req), 8258 timeout=t) 8259 except Exception as e: 8260 if self.parent.shouldRetry(tries, e, deadline): 8261 tries += 1 8262 time.sleep( 8263 self.parent.exponentialBackoff(tries, deadline)) 8264 continue 8265 raise plumbing.convert_error_to_porcelain(e) from e 8266 tries = 0 8267 for plumbing_item in plumbing_response.history: 8268 yield plumbing.convert_secret_store_history_to_porcelain( 8269 plumbing_item) 8270 if plumbing_response.meta.next_cursor == '': 8271 break 8272 req.meta.cursor = plumbing_response.meta.next_cursor 8273 8274 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)
8235 def list(self, filter, *args, timeout=None): 8236 ''' 8237 List gets a list of SecretStoreHistory records matching a given set of criteria. 8238 ''' 8239 deadline = None if timeout is None else time.time() + timeout 8240 req = SecretStoreHistoryListRequest() 8241 req.meta.CopyFrom(ListRequestMetadata()) 8242 if self.parent.page_limit > 0: 8243 req.meta.limit = self.parent.page_limit 8244 if self.parent.snapshot_datetime is not None: 8245 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8246 8247 req.filter = plumbing.quote_filter_args(filter, *args) 8248 8249 def generator(svc, req): 8250 tries = 0 8251 while True: 8252 t = None if deadline is None else deadline - time.time() 8253 try: 8254 plumbing_response = svc.stub.List( 8255 req, 8256 metadata=svc.parent.get_metadata( 8257 'SecretStoresHistory.List', req), 8258 timeout=t) 8259 except Exception as e: 8260 if self.parent.shouldRetry(tries, e, deadline): 8261 tries += 1 8262 time.sleep( 8263 self.parent.exponentialBackoff(tries, deadline)) 8264 continue 8265 raise plumbing.convert_error_to_porcelain(e) from e 8266 tries = 0 8267 for plumbing_item in plumbing_response.history: 8268 yield plumbing.convert_secret_store_history_to_porcelain( 8269 plumbing_item) 8270 if plumbing_response.meta.next_cursor == '': 8271 break 8272 req.meta.cursor = plumbing_response.meta.next_cursor 8273 8274 return generator(self, req)
List gets a list of SecretStoreHistory records matching a given set of criteria.
class
WorkflowApprovers:
8277class WorkflowApprovers: 8278 ''' 8279 WorkflowApprovers is an account or a role with the ability to approve requests bound to a workflow. 8280 See `strongdm.models.WorkflowApprover`. 8281 ''' 8282 def __init__(self, channel, client): 8283 self.parent = client 8284 self.stub = WorkflowApproversStub(channel) 8285 8286 def create(self, workflow_approver, timeout=None): 8287 ''' 8288 Create creates a new workflow approver 8289 ''' 8290 deadline = None if timeout is None else time.time() + timeout 8291 req = WorkflowApproversCreateRequest() 8292 8293 if workflow_approver is not None: 8294 req.workflow_approver.CopyFrom( 8295 plumbing.convert_workflow_approver_to_plumbing( 8296 workflow_approver)) 8297 tries = 0 8298 plumbing_response = None 8299 while True: 8300 t = None if deadline is None else deadline - time.time() 8301 try: 8302 plumbing_response = self.stub.Create( 8303 req, 8304 metadata=self.parent.get_metadata( 8305 'WorkflowApprovers.Create', req), 8306 timeout=t) 8307 except Exception as e: 8308 if self.parent.shouldRetry(tries, e, deadline): 8309 tries += 1 8310 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8311 continue 8312 raise plumbing.convert_error_to_porcelain(e) from e 8313 break 8314 8315 resp = models.WorkflowApproversCreateResponse() 8316 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8317 plumbing_response.rate_limit) 8318 resp.workflow_approver = plumbing.convert_workflow_approver_to_porcelain( 8319 plumbing_response.workflow_approver) 8320 return resp 8321 8322 def get(self, id, timeout=None): 8323 ''' 8324 Get reads one workflow approver by ID. 8325 ''' 8326 deadline = None if timeout is None else time.time() + timeout 8327 req = WorkflowApproverGetRequest() 8328 if self.parent.snapshot_datetime is not None: 8329 req.meta.CopyFrom(GetRequestMetadata()) 8330 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8331 8332 req.id = (id) 8333 tries = 0 8334 plumbing_response = None 8335 while True: 8336 t = None if deadline is None else deadline - time.time() 8337 try: 8338 plumbing_response = self.stub.Get( 8339 req, 8340 metadata=self.parent.get_metadata('WorkflowApprovers.Get', 8341 req), 8342 timeout=t) 8343 except Exception as e: 8344 if self.parent.shouldRetry(tries, e, deadline): 8345 tries += 1 8346 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8347 continue 8348 raise plumbing.convert_error_to_porcelain(e) from e 8349 break 8350 8351 resp = models.WorkflowApproverGetResponse() 8352 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 8353 plumbing_response.meta) 8354 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8355 plumbing_response.rate_limit) 8356 resp.workflow_approver = plumbing.convert_workflow_approver_to_porcelain( 8357 plumbing_response.workflow_approver) 8358 return resp 8359 8360 def delete(self, id, timeout=None): 8361 ''' 8362 Delete deletes a workflow approver 8363 ''' 8364 deadline = None if timeout is None else time.time() + timeout 8365 req = WorkflowApproversDeleteRequest() 8366 8367 req.id = (id) 8368 tries = 0 8369 plumbing_response = None 8370 while True: 8371 t = None if deadline is None else deadline - time.time() 8372 try: 8373 plumbing_response = self.stub.Delete( 8374 req, 8375 metadata=self.parent.get_metadata( 8376 'WorkflowApprovers.Delete', req), 8377 timeout=t) 8378 except Exception as e: 8379 if self.parent.shouldRetry(tries, e, deadline): 8380 tries += 1 8381 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8382 continue 8383 raise plumbing.convert_error_to_porcelain(e) from e 8384 break 8385 8386 resp = models.WorkflowApproversDeleteResponse() 8387 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8388 plumbing_response.rate_limit) 8389 return resp 8390 8391 def list(self, filter, *args, timeout=None): 8392 ''' 8393 Lists existing workflow approvers. 8394 ''' 8395 deadline = None if timeout is None else time.time() + timeout 8396 req = WorkflowApproversListRequest() 8397 req.meta.CopyFrom(ListRequestMetadata()) 8398 if self.parent.page_limit > 0: 8399 req.meta.limit = self.parent.page_limit 8400 if self.parent.snapshot_datetime is not None: 8401 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8402 8403 req.filter = plumbing.quote_filter_args(filter, *args) 8404 8405 def generator(svc, req): 8406 tries = 0 8407 while True: 8408 t = None if deadline is None else deadline - time.time() 8409 try: 8410 plumbing_response = svc.stub.List( 8411 req, 8412 metadata=svc.parent.get_metadata( 8413 'WorkflowApprovers.List', req), 8414 timeout=t) 8415 except Exception as e: 8416 if self.parent.shouldRetry(tries, e, deadline): 8417 tries += 1 8418 time.sleep( 8419 self.parent.exponentialBackoff(tries, deadline)) 8420 continue 8421 raise plumbing.convert_error_to_porcelain(e) from e 8422 tries = 0 8423 for plumbing_item in plumbing_response.workflow_approvers: 8424 yield plumbing.convert_workflow_approver_to_porcelain( 8425 plumbing_item) 8426 if plumbing_response.meta.next_cursor == '': 8427 break 8428 req.meta.cursor = plumbing_response.meta.next_cursor 8429 8430 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)
8286 def create(self, workflow_approver, timeout=None): 8287 ''' 8288 Create creates a new workflow approver 8289 ''' 8290 deadline = None if timeout is None else time.time() + timeout 8291 req = WorkflowApproversCreateRequest() 8292 8293 if workflow_approver is not None: 8294 req.workflow_approver.CopyFrom( 8295 plumbing.convert_workflow_approver_to_plumbing( 8296 workflow_approver)) 8297 tries = 0 8298 plumbing_response = None 8299 while True: 8300 t = None if deadline is None else deadline - time.time() 8301 try: 8302 plumbing_response = self.stub.Create( 8303 req, 8304 metadata=self.parent.get_metadata( 8305 'WorkflowApprovers.Create', req), 8306 timeout=t) 8307 except Exception as e: 8308 if self.parent.shouldRetry(tries, e, deadline): 8309 tries += 1 8310 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8311 continue 8312 raise plumbing.convert_error_to_porcelain(e) from e 8313 break 8314 8315 resp = models.WorkflowApproversCreateResponse() 8316 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8317 plumbing_response.rate_limit) 8318 resp.workflow_approver = plumbing.convert_workflow_approver_to_porcelain( 8319 plumbing_response.workflow_approver) 8320 return resp
Create creates a new workflow approver
def
get(self, id, timeout=None)
8322 def get(self, id, timeout=None): 8323 ''' 8324 Get reads one workflow approver by ID. 8325 ''' 8326 deadline = None if timeout is None else time.time() + timeout 8327 req = WorkflowApproverGetRequest() 8328 if self.parent.snapshot_datetime is not None: 8329 req.meta.CopyFrom(GetRequestMetadata()) 8330 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8331 8332 req.id = (id) 8333 tries = 0 8334 plumbing_response = None 8335 while True: 8336 t = None if deadline is None else deadline - time.time() 8337 try: 8338 plumbing_response = self.stub.Get( 8339 req, 8340 metadata=self.parent.get_metadata('WorkflowApprovers.Get', 8341 req), 8342 timeout=t) 8343 except Exception as e: 8344 if self.parent.shouldRetry(tries, e, deadline): 8345 tries += 1 8346 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8347 continue 8348 raise plumbing.convert_error_to_porcelain(e) from e 8349 break 8350 8351 resp = models.WorkflowApproverGetResponse() 8352 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 8353 plumbing_response.meta) 8354 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8355 plumbing_response.rate_limit) 8356 resp.workflow_approver = plumbing.convert_workflow_approver_to_porcelain( 8357 plumbing_response.workflow_approver) 8358 return resp
Get reads one workflow approver by ID.
def
delete(self, id, timeout=None)
8360 def delete(self, id, timeout=None): 8361 ''' 8362 Delete deletes a workflow approver 8363 ''' 8364 deadline = None if timeout is None else time.time() + timeout 8365 req = WorkflowApproversDeleteRequest() 8366 8367 req.id = (id) 8368 tries = 0 8369 plumbing_response = None 8370 while True: 8371 t = None if deadline is None else deadline - time.time() 8372 try: 8373 plumbing_response = self.stub.Delete( 8374 req, 8375 metadata=self.parent.get_metadata( 8376 'WorkflowApprovers.Delete', req), 8377 timeout=t) 8378 except Exception as e: 8379 if self.parent.shouldRetry(tries, e, deadline): 8380 tries += 1 8381 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8382 continue 8383 raise plumbing.convert_error_to_porcelain(e) from e 8384 break 8385 8386 resp = models.WorkflowApproversDeleteResponse() 8387 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8388 plumbing_response.rate_limit) 8389 return resp
Delete deletes a workflow approver
def
list(self, filter, *args, timeout=None)
8391 def list(self, filter, *args, timeout=None): 8392 ''' 8393 Lists existing workflow approvers. 8394 ''' 8395 deadline = None if timeout is None else time.time() + timeout 8396 req = WorkflowApproversListRequest() 8397 req.meta.CopyFrom(ListRequestMetadata()) 8398 if self.parent.page_limit > 0: 8399 req.meta.limit = self.parent.page_limit 8400 if self.parent.snapshot_datetime is not None: 8401 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8402 8403 req.filter = plumbing.quote_filter_args(filter, *args) 8404 8405 def generator(svc, req): 8406 tries = 0 8407 while True: 8408 t = None if deadline is None else deadline - time.time() 8409 try: 8410 plumbing_response = svc.stub.List( 8411 req, 8412 metadata=svc.parent.get_metadata( 8413 'WorkflowApprovers.List', req), 8414 timeout=t) 8415 except Exception as e: 8416 if self.parent.shouldRetry(tries, e, deadline): 8417 tries += 1 8418 time.sleep( 8419 self.parent.exponentialBackoff(tries, deadline)) 8420 continue 8421 raise plumbing.convert_error_to_porcelain(e) from e 8422 tries = 0 8423 for plumbing_item in plumbing_response.workflow_approvers: 8424 yield plumbing.convert_workflow_approver_to_porcelain( 8425 plumbing_item) 8426 if plumbing_response.meta.next_cursor == '': 8427 break 8428 req.meta.cursor = plumbing_response.meta.next_cursor 8429 8430 return generator(self, req)
Lists existing workflow approvers.
class
SnapshotWorkflowApprovers:
8433class SnapshotWorkflowApprovers: 8434 ''' 8435 SnapshotWorkflowApprovers exposes the read only methods of the WorkflowApprovers 8436 service for historical queries. 8437 ''' 8438 def __init__(self, workflow_approvers): 8439 self.workflow_approvers = workflow_approvers 8440 8441 def get(self, id, timeout=None): 8442 ''' 8443 Get reads one workflow approver by ID. 8444 ''' 8445 return self.workflow_approvers.get(id, timeout=timeout) 8446 8447 def list(self, filter, *args, timeout=None): 8448 ''' 8449 Lists existing workflow approvers. 8450 ''' 8451 return self.workflow_approvers.list(filter, *args, timeout=timeout)
SnapshotWorkflowApprovers exposes the read only methods of the WorkflowApprovers service for historical queries.
class
WorkflowApproversHistory:
8454class WorkflowApproversHistory: 8455 ''' 8456 WorkflowApproversHistory provides records of all changes to the state of a WorkflowApprover. 8457 See `strongdm.models.WorkflowApproverHistory`. 8458 ''' 8459 def __init__(self, channel, client): 8460 self.parent = client 8461 self.stub = WorkflowApproversHistoryStub(channel) 8462 8463 def list(self, filter, *args, timeout=None): 8464 ''' 8465 List gets a list of WorkflowApproversHistory records matching a given set of criteria. 8466 ''' 8467 deadline = None if timeout is None else time.time() + timeout 8468 req = WorkflowApproversHistoryListRequest() 8469 req.meta.CopyFrom(ListRequestMetadata()) 8470 if self.parent.page_limit > 0: 8471 req.meta.limit = self.parent.page_limit 8472 if self.parent.snapshot_datetime is not None: 8473 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8474 8475 req.filter = plumbing.quote_filter_args(filter, *args) 8476 8477 def generator(svc, req): 8478 tries = 0 8479 while True: 8480 t = None if deadline is None else deadline - time.time() 8481 try: 8482 plumbing_response = svc.stub.List( 8483 req, 8484 metadata=svc.parent.get_metadata( 8485 'WorkflowApproversHistory.List', req), 8486 timeout=t) 8487 except Exception as e: 8488 if self.parent.shouldRetry(tries, e, deadline): 8489 tries += 1 8490 time.sleep( 8491 self.parent.exponentialBackoff(tries, deadline)) 8492 continue 8493 raise plumbing.convert_error_to_porcelain(e) from e 8494 tries = 0 8495 for plumbing_item in plumbing_response.history: 8496 yield plumbing.convert_workflow_approver_history_to_porcelain( 8497 plumbing_item) 8498 if plumbing_response.meta.next_cursor == '': 8499 break 8500 req.meta.cursor = plumbing_response.meta.next_cursor 8501 8502 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)
8463 def list(self, filter, *args, timeout=None): 8464 ''' 8465 List gets a list of WorkflowApproversHistory records matching a given set of criteria. 8466 ''' 8467 deadline = None if timeout is None else time.time() + timeout 8468 req = WorkflowApproversHistoryListRequest() 8469 req.meta.CopyFrom(ListRequestMetadata()) 8470 if self.parent.page_limit > 0: 8471 req.meta.limit = self.parent.page_limit 8472 if self.parent.snapshot_datetime is not None: 8473 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8474 8475 req.filter = plumbing.quote_filter_args(filter, *args) 8476 8477 def generator(svc, req): 8478 tries = 0 8479 while True: 8480 t = None if deadline is None else deadline - time.time() 8481 try: 8482 plumbing_response = svc.stub.List( 8483 req, 8484 metadata=svc.parent.get_metadata( 8485 'WorkflowApproversHistory.List', req), 8486 timeout=t) 8487 except Exception as e: 8488 if self.parent.shouldRetry(tries, e, deadline): 8489 tries += 1 8490 time.sleep( 8491 self.parent.exponentialBackoff(tries, deadline)) 8492 continue 8493 raise plumbing.convert_error_to_porcelain(e) from e 8494 tries = 0 8495 for plumbing_item in plumbing_response.history: 8496 yield plumbing.convert_workflow_approver_history_to_porcelain( 8497 plumbing_item) 8498 if plumbing_response.meta.next_cursor == '': 8499 break 8500 req.meta.cursor = plumbing_response.meta.next_cursor 8501 8502 return generator(self, req)
List gets a list of WorkflowApproversHistory records matching a given set of criteria.
class
WorkflowRoles:
8505class WorkflowRoles: 8506 ''' 8507 WorkflowRole links a role to a workflow. The linked roles indicate which roles a user must be a part of 8508 to request access to a resource via the workflow. 8509 See `strongdm.models.WorkflowRole`. 8510 ''' 8511 def __init__(self, channel, client): 8512 self.parent = client 8513 self.stub = WorkflowRolesStub(channel) 8514 8515 def create(self, workflow_role, timeout=None): 8516 ''' 8517 Create creates a new workflow role 8518 ''' 8519 deadline = None if timeout is None else time.time() + timeout 8520 req = WorkflowRolesCreateRequest() 8521 8522 if workflow_role is not None: 8523 req.workflow_role.CopyFrom( 8524 plumbing.convert_workflow_role_to_plumbing(workflow_role)) 8525 tries = 0 8526 plumbing_response = None 8527 while True: 8528 t = None if deadline is None else deadline - time.time() 8529 try: 8530 plumbing_response = self.stub.Create( 8531 req, 8532 metadata=self.parent.get_metadata('WorkflowRoles.Create', 8533 req), 8534 timeout=t) 8535 except Exception as e: 8536 if self.parent.shouldRetry(tries, e, deadline): 8537 tries += 1 8538 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8539 continue 8540 raise plumbing.convert_error_to_porcelain(e) from e 8541 break 8542 8543 resp = models.WorkflowRolesCreateResponse() 8544 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8545 plumbing_response.rate_limit) 8546 resp.workflow_role = plumbing.convert_workflow_role_to_porcelain( 8547 plumbing_response.workflow_role) 8548 return resp 8549 8550 def get(self, id, timeout=None): 8551 ''' 8552 Get reads one workflow role by ID. 8553 ''' 8554 deadline = None if timeout is None else time.time() + timeout 8555 req = WorkflowRoleGetRequest() 8556 if self.parent.snapshot_datetime is not None: 8557 req.meta.CopyFrom(GetRequestMetadata()) 8558 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8559 8560 req.id = (id) 8561 tries = 0 8562 plumbing_response = None 8563 while True: 8564 t = None if deadline is None else deadline - time.time() 8565 try: 8566 plumbing_response = self.stub.Get( 8567 req, 8568 metadata=self.parent.get_metadata('WorkflowRoles.Get', 8569 req), 8570 timeout=t) 8571 except Exception as e: 8572 if self.parent.shouldRetry(tries, e, deadline): 8573 tries += 1 8574 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8575 continue 8576 raise plumbing.convert_error_to_porcelain(e) from e 8577 break 8578 8579 resp = models.WorkflowRoleGetResponse() 8580 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 8581 plumbing_response.meta) 8582 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8583 plumbing_response.rate_limit) 8584 resp.workflow_role = plumbing.convert_workflow_role_to_porcelain( 8585 plumbing_response.workflow_role) 8586 return resp 8587 8588 def delete(self, id, timeout=None): 8589 ''' 8590 Delete deletes a workflow role 8591 ''' 8592 deadline = None if timeout is None else time.time() + timeout 8593 req = WorkflowRolesDeleteRequest() 8594 8595 req.id = (id) 8596 tries = 0 8597 plumbing_response = None 8598 while True: 8599 t = None if deadline is None else deadline - time.time() 8600 try: 8601 plumbing_response = self.stub.Delete( 8602 req, 8603 metadata=self.parent.get_metadata('WorkflowRoles.Delete', 8604 req), 8605 timeout=t) 8606 except Exception as e: 8607 if self.parent.shouldRetry(tries, e, deadline): 8608 tries += 1 8609 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8610 continue 8611 raise plumbing.convert_error_to_porcelain(e) from e 8612 break 8613 8614 resp = models.WorkflowRolesDeleteResponse() 8615 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8616 plumbing_response.rate_limit) 8617 return resp 8618 8619 def list(self, filter, *args, timeout=None): 8620 ''' 8621 Lists existing workflow roles. 8622 ''' 8623 deadline = None if timeout is None else time.time() + timeout 8624 req = WorkflowRolesListRequest() 8625 req.meta.CopyFrom(ListRequestMetadata()) 8626 if self.parent.page_limit > 0: 8627 req.meta.limit = self.parent.page_limit 8628 if self.parent.snapshot_datetime is not None: 8629 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8630 8631 req.filter = plumbing.quote_filter_args(filter, *args) 8632 8633 def generator(svc, req): 8634 tries = 0 8635 while True: 8636 t = None if deadline is None else deadline - time.time() 8637 try: 8638 plumbing_response = svc.stub.List( 8639 req, 8640 metadata=svc.parent.get_metadata( 8641 'WorkflowRoles.List', req), 8642 timeout=t) 8643 except Exception as e: 8644 if self.parent.shouldRetry(tries, e, deadline): 8645 tries += 1 8646 time.sleep( 8647 self.parent.exponentialBackoff(tries, deadline)) 8648 continue 8649 raise plumbing.convert_error_to_porcelain(e) from e 8650 tries = 0 8651 for plumbing_item in plumbing_response.workflow_role: 8652 yield plumbing.convert_workflow_role_to_porcelain( 8653 plumbing_item) 8654 if plumbing_response.meta.next_cursor == '': 8655 break 8656 req.meta.cursor = plumbing_response.meta.next_cursor 8657 8658 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)
8515 def create(self, workflow_role, timeout=None): 8516 ''' 8517 Create creates a new workflow role 8518 ''' 8519 deadline = None if timeout is None else time.time() + timeout 8520 req = WorkflowRolesCreateRequest() 8521 8522 if workflow_role is not None: 8523 req.workflow_role.CopyFrom( 8524 plumbing.convert_workflow_role_to_plumbing(workflow_role)) 8525 tries = 0 8526 plumbing_response = None 8527 while True: 8528 t = None if deadline is None else deadline - time.time() 8529 try: 8530 plumbing_response = self.stub.Create( 8531 req, 8532 metadata=self.parent.get_metadata('WorkflowRoles.Create', 8533 req), 8534 timeout=t) 8535 except Exception as e: 8536 if self.parent.shouldRetry(tries, e, deadline): 8537 tries += 1 8538 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8539 continue 8540 raise plumbing.convert_error_to_porcelain(e) from e 8541 break 8542 8543 resp = models.WorkflowRolesCreateResponse() 8544 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8545 plumbing_response.rate_limit) 8546 resp.workflow_role = plumbing.convert_workflow_role_to_porcelain( 8547 plumbing_response.workflow_role) 8548 return resp
Create creates a new workflow role
def
get(self, id, timeout=None)
8550 def get(self, id, timeout=None): 8551 ''' 8552 Get reads one workflow role by ID. 8553 ''' 8554 deadline = None if timeout is None else time.time() + timeout 8555 req = WorkflowRoleGetRequest() 8556 if self.parent.snapshot_datetime is not None: 8557 req.meta.CopyFrom(GetRequestMetadata()) 8558 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8559 8560 req.id = (id) 8561 tries = 0 8562 plumbing_response = None 8563 while True: 8564 t = None if deadline is None else deadline - time.time() 8565 try: 8566 plumbing_response = self.stub.Get( 8567 req, 8568 metadata=self.parent.get_metadata('WorkflowRoles.Get', 8569 req), 8570 timeout=t) 8571 except Exception as e: 8572 if self.parent.shouldRetry(tries, e, deadline): 8573 tries += 1 8574 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8575 continue 8576 raise plumbing.convert_error_to_porcelain(e) from e 8577 break 8578 8579 resp = models.WorkflowRoleGetResponse() 8580 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 8581 plumbing_response.meta) 8582 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8583 plumbing_response.rate_limit) 8584 resp.workflow_role = plumbing.convert_workflow_role_to_porcelain( 8585 plumbing_response.workflow_role) 8586 return resp
Get reads one workflow role by ID.
def
delete(self, id, timeout=None)
8588 def delete(self, id, timeout=None): 8589 ''' 8590 Delete deletes a workflow role 8591 ''' 8592 deadline = None if timeout is None else time.time() + timeout 8593 req = WorkflowRolesDeleteRequest() 8594 8595 req.id = (id) 8596 tries = 0 8597 plumbing_response = None 8598 while True: 8599 t = None if deadline is None else deadline - time.time() 8600 try: 8601 plumbing_response = self.stub.Delete( 8602 req, 8603 metadata=self.parent.get_metadata('WorkflowRoles.Delete', 8604 req), 8605 timeout=t) 8606 except Exception as e: 8607 if self.parent.shouldRetry(tries, e, deadline): 8608 tries += 1 8609 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8610 continue 8611 raise plumbing.convert_error_to_porcelain(e) from e 8612 break 8613 8614 resp = models.WorkflowRolesDeleteResponse() 8615 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8616 plumbing_response.rate_limit) 8617 return resp
Delete deletes a workflow role
def
list(self, filter, *args, timeout=None)
8619 def list(self, filter, *args, timeout=None): 8620 ''' 8621 Lists existing workflow roles. 8622 ''' 8623 deadline = None if timeout is None else time.time() + timeout 8624 req = WorkflowRolesListRequest() 8625 req.meta.CopyFrom(ListRequestMetadata()) 8626 if self.parent.page_limit > 0: 8627 req.meta.limit = self.parent.page_limit 8628 if self.parent.snapshot_datetime is not None: 8629 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8630 8631 req.filter = plumbing.quote_filter_args(filter, *args) 8632 8633 def generator(svc, req): 8634 tries = 0 8635 while True: 8636 t = None if deadline is None else deadline - time.time() 8637 try: 8638 plumbing_response = svc.stub.List( 8639 req, 8640 metadata=svc.parent.get_metadata( 8641 'WorkflowRoles.List', req), 8642 timeout=t) 8643 except Exception as e: 8644 if self.parent.shouldRetry(tries, e, deadline): 8645 tries += 1 8646 time.sleep( 8647 self.parent.exponentialBackoff(tries, deadline)) 8648 continue 8649 raise plumbing.convert_error_to_porcelain(e) from e 8650 tries = 0 8651 for plumbing_item in plumbing_response.workflow_role: 8652 yield plumbing.convert_workflow_role_to_porcelain( 8653 plumbing_item) 8654 if plumbing_response.meta.next_cursor == '': 8655 break 8656 req.meta.cursor = plumbing_response.meta.next_cursor 8657 8658 return generator(self, req)
Lists existing workflow roles.
class
SnapshotWorkflowRoles:
8661class SnapshotWorkflowRoles: 8662 ''' 8663 SnapshotWorkflowRoles exposes the read only methods of the WorkflowRoles 8664 service for historical queries. 8665 ''' 8666 def __init__(self, workflow_roles): 8667 self.workflow_roles = workflow_roles 8668 8669 def get(self, id, timeout=None): 8670 ''' 8671 Get reads one workflow role by ID. 8672 ''' 8673 return self.workflow_roles.get(id, timeout=timeout) 8674 8675 def list(self, filter, *args, timeout=None): 8676 ''' 8677 Lists existing workflow roles. 8678 ''' 8679 return self.workflow_roles.list(filter, *args, timeout=timeout)
SnapshotWorkflowRoles exposes the read only methods of the WorkflowRoles service for historical queries.
class
WorkflowRolesHistory:
8682class WorkflowRolesHistory: 8683 ''' 8684 WorkflowRolesHistory provides records of all changes to the state of a WorkflowRole 8685 See `strongdm.models.WorkflowRoleHistory`. 8686 ''' 8687 def __init__(self, channel, client): 8688 self.parent = client 8689 self.stub = WorkflowRolesHistoryStub(channel) 8690 8691 def list(self, filter, *args, timeout=None): 8692 ''' 8693 List gets a list of WorkflowRolesHistory records matching a given set of criteria. 8694 ''' 8695 deadline = None if timeout is None else time.time() + timeout 8696 req = WorkflowRolesHistoryListRequest() 8697 req.meta.CopyFrom(ListRequestMetadata()) 8698 if self.parent.page_limit > 0: 8699 req.meta.limit = self.parent.page_limit 8700 if self.parent.snapshot_datetime is not None: 8701 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8702 8703 req.filter = plumbing.quote_filter_args(filter, *args) 8704 8705 def generator(svc, req): 8706 tries = 0 8707 while True: 8708 t = None if deadline is None else deadline - time.time() 8709 try: 8710 plumbing_response = svc.stub.List( 8711 req, 8712 metadata=svc.parent.get_metadata( 8713 'WorkflowRolesHistory.List', req), 8714 timeout=t) 8715 except Exception as e: 8716 if self.parent.shouldRetry(tries, e, deadline): 8717 tries += 1 8718 time.sleep( 8719 self.parent.exponentialBackoff(tries, deadline)) 8720 continue 8721 raise plumbing.convert_error_to_porcelain(e) from e 8722 tries = 0 8723 for plumbing_item in plumbing_response.history: 8724 yield plumbing.convert_workflow_role_history_to_porcelain( 8725 plumbing_item) 8726 if plumbing_response.meta.next_cursor == '': 8727 break 8728 req.meta.cursor = plumbing_response.meta.next_cursor 8729 8730 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)
8691 def list(self, filter, *args, timeout=None): 8692 ''' 8693 List gets a list of WorkflowRolesHistory records matching a given set of criteria. 8694 ''' 8695 deadline = None if timeout is None else time.time() + timeout 8696 req = WorkflowRolesHistoryListRequest() 8697 req.meta.CopyFrom(ListRequestMetadata()) 8698 if self.parent.page_limit > 0: 8699 req.meta.limit = self.parent.page_limit 8700 if self.parent.snapshot_datetime is not None: 8701 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8702 8703 req.filter = plumbing.quote_filter_args(filter, *args) 8704 8705 def generator(svc, req): 8706 tries = 0 8707 while True: 8708 t = None if deadline is None else deadline - time.time() 8709 try: 8710 plumbing_response = svc.stub.List( 8711 req, 8712 metadata=svc.parent.get_metadata( 8713 'WorkflowRolesHistory.List', req), 8714 timeout=t) 8715 except Exception as e: 8716 if self.parent.shouldRetry(tries, e, deadline): 8717 tries += 1 8718 time.sleep( 8719 self.parent.exponentialBackoff(tries, deadline)) 8720 continue 8721 raise plumbing.convert_error_to_porcelain(e) from e 8722 tries = 0 8723 for plumbing_item in plumbing_response.history: 8724 yield plumbing.convert_workflow_role_history_to_porcelain( 8725 plumbing_item) 8726 if plumbing_response.meta.next_cursor == '': 8727 break 8728 req.meta.cursor = plumbing_response.meta.next_cursor 8729 8730 return generator(self, req)
List gets a list of WorkflowRolesHistory records matching a given set of criteria.
class
Workflows:
8733class Workflows: 8734 ''' 8735 Workflows are the collection of rules that define the resources to which access can be requested, 8736 the users that can request that access, and the mechanism for approving those requests which can either 8737 be automatic approval or a set of users authorized to approve the requests. 8738 See `strongdm.models.Workflow`. 8739 ''' 8740 def __init__(self, channel, client): 8741 self.parent = client 8742 self.stub = WorkflowsStub(channel) 8743 8744 def create(self, workflow, timeout=None): 8745 ''' 8746 Create creates a new workflow and requires a name for the workflow. 8747 ''' 8748 deadline = None if timeout is None else time.time() + timeout 8749 req = WorkflowCreateRequest() 8750 8751 if workflow is not None: 8752 req.workflow.CopyFrom( 8753 plumbing.convert_workflow_to_plumbing(workflow)) 8754 tries = 0 8755 plumbing_response = None 8756 while True: 8757 t = None if deadline is None else deadline - time.time() 8758 try: 8759 plumbing_response = self.stub.Create( 8760 req, 8761 metadata=self.parent.get_metadata('Workflows.Create', req), 8762 timeout=t) 8763 except Exception as e: 8764 if self.parent.shouldRetry(tries, e, deadline): 8765 tries += 1 8766 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8767 continue 8768 raise plumbing.convert_error_to_porcelain(e) from e 8769 break 8770 8771 resp = models.WorkflowCreateResponse() 8772 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8773 plumbing_response.rate_limit) 8774 resp.workflow = plumbing.convert_workflow_to_porcelain( 8775 plumbing_response.workflow) 8776 return resp 8777 8778 def get(self, id, timeout=None): 8779 ''' 8780 Get reads one workflow by ID. 8781 ''' 8782 deadline = None if timeout is None else time.time() + timeout 8783 req = WorkflowGetRequest() 8784 if self.parent.snapshot_datetime is not None: 8785 req.meta.CopyFrom(GetRequestMetadata()) 8786 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8787 8788 req.id = (id) 8789 tries = 0 8790 plumbing_response = None 8791 while True: 8792 t = None if deadline is None else deadline - time.time() 8793 try: 8794 plumbing_response = self.stub.Get( 8795 req, 8796 metadata=self.parent.get_metadata('Workflows.Get', req), 8797 timeout=t) 8798 except Exception as e: 8799 if self.parent.shouldRetry(tries, e, deadline): 8800 tries += 1 8801 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8802 continue 8803 raise plumbing.convert_error_to_porcelain(e) from e 8804 break 8805 8806 resp = models.WorkflowGetResponse() 8807 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 8808 plumbing_response.meta) 8809 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8810 plumbing_response.rate_limit) 8811 resp.workflow = plumbing.convert_workflow_to_porcelain( 8812 plumbing_response.workflow) 8813 return resp 8814 8815 def delete(self, id, timeout=None): 8816 ''' 8817 Delete deletes an existing workflow. 8818 ''' 8819 deadline = None if timeout is None else time.time() + timeout 8820 req = WorkflowDeleteRequest() 8821 8822 req.id = (id) 8823 tries = 0 8824 plumbing_response = None 8825 while True: 8826 t = None if deadline is None else deadline - time.time() 8827 try: 8828 plumbing_response = self.stub.Delete( 8829 req, 8830 metadata=self.parent.get_metadata('Workflows.Delete', req), 8831 timeout=t) 8832 except Exception as e: 8833 if self.parent.shouldRetry(tries, e, deadline): 8834 tries += 1 8835 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8836 continue 8837 raise plumbing.convert_error_to_porcelain(e) from e 8838 break 8839 8840 resp = models.WorkflowDeleteResponse() 8841 resp.id = (plumbing_response.id) 8842 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8843 plumbing_response.rate_limit) 8844 return resp 8845 8846 def update(self, workflow, timeout=None): 8847 ''' 8848 Update updates an existing workflow. 8849 ''' 8850 deadline = None if timeout is None else time.time() + timeout 8851 req = WorkflowUpdateRequest() 8852 8853 if workflow is not None: 8854 req.workflow.CopyFrom( 8855 plumbing.convert_workflow_to_plumbing(workflow)) 8856 tries = 0 8857 plumbing_response = None 8858 while True: 8859 t = None if deadline is None else deadline - time.time() 8860 try: 8861 plumbing_response = self.stub.Update( 8862 req, 8863 metadata=self.parent.get_metadata('Workflows.Update', req), 8864 timeout=t) 8865 except Exception as e: 8866 if self.parent.shouldRetry(tries, e, deadline): 8867 tries += 1 8868 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8869 continue 8870 raise plumbing.convert_error_to_porcelain(e) from e 8871 break 8872 8873 resp = models.WorkflowUpdateResponse() 8874 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8875 plumbing_response.rate_limit) 8876 resp.workflow = plumbing.convert_workflow_to_porcelain( 8877 plumbing_response.workflow) 8878 return resp 8879 8880 def list(self, filter, *args, timeout=None): 8881 ''' 8882 Lists existing workflows. 8883 ''' 8884 deadline = None if timeout is None else time.time() + timeout 8885 req = WorkflowListRequest() 8886 req.meta.CopyFrom(ListRequestMetadata()) 8887 if self.parent.page_limit > 0: 8888 req.meta.limit = self.parent.page_limit 8889 if self.parent.snapshot_datetime is not None: 8890 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8891 8892 req.filter = plumbing.quote_filter_args(filter, *args) 8893 8894 def generator(svc, req): 8895 tries = 0 8896 while True: 8897 t = None if deadline is None else deadline - time.time() 8898 try: 8899 plumbing_response = svc.stub.List( 8900 req, 8901 metadata=svc.parent.get_metadata( 8902 'Workflows.List', req), 8903 timeout=t) 8904 except Exception as e: 8905 if self.parent.shouldRetry(tries, e, deadline): 8906 tries += 1 8907 time.sleep( 8908 self.parent.exponentialBackoff(tries, deadline)) 8909 continue 8910 raise plumbing.convert_error_to_porcelain(e) from e 8911 tries = 0 8912 for plumbing_item in plumbing_response.workflows: 8913 yield plumbing.convert_workflow_to_porcelain(plumbing_item) 8914 if plumbing_response.meta.next_cursor == '': 8915 break 8916 req.meta.cursor = plumbing_response.meta.next_cursor 8917 8918 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)
8744 def create(self, workflow, timeout=None): 8745 ''' 8746 Create creates a new workflow and requires a name for the workflow. 8747 ''' 8748 deadline = None if timeout is None else time.time() + timeout 8749 req = WorkflowCreateRequest() 8750 8751 if workflow is not None: 8752 req.workflow.CopyFrom( 8753 plumbing.convert_workflow_to_plumbing(workflow)) 8754 tries = 0 8755 plumbing_response = None 8756 while True: 8757 t = None if deadline is None else deadline - time.time() 8758 try: 8759 plumbing_response = self.stub.Create( 8760 req, 8761 metadata=self.parent.get_metadata('Workflows.Create', req), 8762 timeout=t) 8763 except Exception as e: 8764 if self.parent.shouldRetry(tries, e, deadline): 8765 tries += 1 8766 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8767 continue 8768 raise plumbing.convert_error_to_porcelain(e) from e 8769 break 8770 8771 resp = models.WorkflowCreateResponse() 8772 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8773 plumbing_response.rate_limit) 8774 resp.workflow = plumbing.convert_workflow_to_porcelain( 8775 plumbing_response.workflow) 8776 return resp
Create creates a new workflow and requires a name for the workflow.
def
get(self, id, timeout=None)
8778 def get(self, id, timeout=None): 8779 ''' 8780 Get reads one workflow by ID. 8781 ''' 8782 deadline = None if timeout is None else time.time() + timeout 8783 req = WorkflowGetRequest() 8784 if self.parent.snapshot_datetime is not None: 8785 req.meta.CopyFrom(GetRequestMetadata()) 8786 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8787 8788 req.id = (id) 8789 tries = 0 8790 plumbing_response = None 8791 while True: 8792 t = None if deadline is None else deadline - time.time() 8793 try: 8794 plumbing_response = self.stub.Get( 8795 req, 8796 metadata=self.parent.get_metadata('Workflows.Get', req), 8797 timeout=t) 8798 except Exception as e: 8799 if self.parent.shouldRetry(tries, e, deadline): 8800 tries += 1 8801 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8802 continue 8803 raise plumbing.convert_error_to_porcelain(e) from e 8804 break 8805 8806 resp = models.WorkflowGetResponse() 8807 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 8808 plumbing_response.meta) 8809 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8810 plumbing_response.rate_limit) 8811 resp.workflow = plumbing.convert_workflow_to_porcelain( 8812 plumbing_response.workflow) 8813 return resp
Get reads one workflow by ID.
def
delete(self, id, timeout=None)
8815 def delete(self, id, timeout=None): 8816 ''' 8817 Delete deletes an existing workflow. 8818 ''' 8819 deadline = None if timeout is None else time.time() + timeout 8820 req = WorkflowDeleteRequest() 8821 8822 req.id = (id) 8823 tries = 0 8824 plumbing_response = None 8825 while True: 8826 t = None if deadline is None else deadline - time.time() 8827 try: 8828 plumbing_response = self.stub.Delete( 8829 req, 8830 metadata=self.parent.get_metadata('Workflows.Delete', req), 8831 timeout=t) 8832 except Exception as e: 8833 if self.parent.shouldRetry(tries, e, deadline): 8834 tries += 1 8835 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8836 continue 8837 raise plumbing.convert_error_to_porcelain(e) from e 8838 break 8839 8840 resp = models.WorkflowDeleteResponse() 8841 resp.id = (plumbing_response.id) 8842 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8843 plumbing_response.rate_limit) 8844 return resp
Delete deletes an existing workflow.
def
update(self, workflow, timeout=None)
8846 def update(self, workflow, timeout=None): 8847 ''' 8848 Update updates an existing workflow. 8849 ''' 8850 deadline = None if timeout is None else time.time() + timeout 8851 req = WorkflowUpdateRequest() 8852 8853 if workflow is not None: 8854 req.workflow.CopyFrom( 8855 plumbing.convert_workflow_to_plumbing(workflow)) 8856 tries = 0 8857 plumbing_response = None 8858 while True: 8859 t = None if deadline is None else deadline - time.time() 8860 try: 8861 plumbing_response = self.stub.Update( 8862 req, 8863 metadata=self.parent.get_metadata('Workflows.Update', req), 8864 timeout=t) 8865 except Exception as e: 8866 if self.parent.shouldRetry(tries, e, deadline): 8867 tries += 1 8868 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8869 continue 8870 raise plumbing.convert_error_to_porcelain(e) from e 8871 break 8872 8873 resp = models.WorkflowUpdateResponse() 8874 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8875 plumbing_response.rate_limit) 8876 resp.workflow = plumbing.convert_workflow_to_porcelain( 8877 plumbing_response.workflow) 8878 return resp
Update updates an existing workflow.
def
list(self, filter, *args, timeout=None)
8880 def list(self, filter, *args, timeout=None): 8881 ''' 8882 Lists existing workflows. 8883 ''' 8884 deadline = None if timeout is None else time.time() + timeout 8885 req = WorkflowListRequest() 8886 req.meta.CopyFrom(ListRequestMetadata()) 8887 if self.parent.page_limit > 0: 8888 req.meta.limit = self.parent.page_limit 8889 if self.parent.snapshot_datetime is not None: 8890 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8891 8892 req.filter = plumbing.quote_filter_args(filter, *args) 8893 8894 def generator(svc, req): 8895 tries = 0 8896 while True: 8897 t = None if deadline is None else deadline - time.time() 8898 try: 8899 plumbing_response = svc.stub.List( 8900 req, 8901 metadata=svc.parent.get_metadata( 8902 'Workflows.List', req), 8903 timeout=t) 8904 except Exception as e: 8905 if self.parent.shouldRetry(tries, e, deadline): 8906 tries += 1 8907 time.sleep( 8908 self.parent.exponentialBackoff(tries, deadline)) 8909 continue 8910 raise plumbing.convert_error_to_porcelain(e) from e 8911 tries = 0 8912 for plumbing_item in plumbing_response.workflows: 8913 yield plumbing.convert_workflow_to_porcelain(plumbing_item) 8914 if plumbing_response.meta.next_cursor == '': 8915 break 8916 req.meta.cursor = plumbing_response.meta.next_cursor 8917 8918 return generator(self, req)
Lists existing workflows.
class
SnapshotWorkflows:
8921class SnapshotWorkflows: 8922 ''' 8923 SnapshotWorkflows exposes the read only methods of the Workflows 8924 service for historical queries. 8925 ''' 8926 def __init__(self, workflows): 8927 self.workflows = workflows 8928 8929 def get(self, id, timeout=None): 8930 ''' 8931 Get reads one workflow by ID. 8932 ''' 8933 return self.workflows.get(id, timeout=timeout) 8934 8935 def list(self, filter, *args, timeout=None): 8936 ''' 8937 Lists existing workflows. 8938 ''' 8939 return self.workflows.list(filter, *args, timeout=timeout)
SnapshotWorkflows exposes the read only methods of the Workflows service for historical queries.
class
WorkflowsHistory:
8942class WorkflowsHistory: 8943 ''' 8944 WorkflowsHistory provides records of all changes to the state of a Workflow. 8945 See `strongdm.models.WorkflowHistory`. 8946 ''' 8947 def __init__(self, channel, client): 8948 self.parent = client 8949 self.stub = WorkflowsHistoryStub(channel) 8950 8951 def list(self, filter, *args, timeout=None): 8952 ''' 8953 List gets a list of WorkflowHistory records matching a given set of criteria. 8954 ''' 8955 deadline = None if timeout is None else time.time() + timeout 8956 req = WorkflowHistoryListRequest() 8957 req.meta.CopyFrom(ListRequestMetadata()) 8958 if self.parent.page_limit > 0: 8959 req.meta.limit = self.parent.page_limit 8960 if self.parent.snapshot_datetime is not None: 8961 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8962 8963 req.filter = plumbing.quote_filter_args(filter, *args) 8964 8965 def generator(svc, req): 8966 tries = 0 8967 while True: 8968 t = None if deadline is None else deadline - time.time() 8969 try: 8970 plumbing_response = svc.stub.List( 8971 req, 8972 metadata=svc.parent.get_metadata( 8973 'WorkflowsHistory.List', req), 8974 timeout=t) 8975 except Exception as e: 8976 if self.parent.shouldRetry(tries, e, deadline): 8977 tries += 1 8978 time.sleep( 8979 self.parent.exponentialBackoff(tries, deadline)) 8980 continue 8981 raise plumbing.convert_error_to_porcelain(e) from e 8982 tries = 0 8983 for plumbing_item in plumbing_response.history: 8984 yield plumbing.convert_workflow_history_to_porcelain( 8985 plumbing_item) 8986 if plumbing_response.meta.next_cursor == '': 8987 break 8988 req.meta.cursor = plumbing_response.meta.next_cursor 8989 8990 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)
8951 def list(self, filter, *args, timeout=None): 8952 ''' 8953 List gets a list of WorkflowHistory records matching a given set of criteria. 8954 ''' 8955 deadline = None if timeout is None else time.time() + timeout 8956 req = WorkflowHistoryListRequest() 8957 req.meta.CopyFrom(ListRequestMetadata()) 8958 if self.parent.page_limit > 0: 8959 req.meta.limit = self.parent.page_limit 8960 if self.parent.snapshot_datetime is not None: 8961 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8962 8963 req.filter = plumbing.quote_filter_args(filter, *args) 8964 8965 def generator(svc, req): 8966 tries = 0 8967 while True: 8968 t = None if deadline is None else deadline - time.time() 8969 try: 8970 plumbing_response = svc.stub.List( 8971 req, 8972 metadata=svc.parent.get_metadata( 8973 'WorkflowsHistory.List', req), 8974 timeout=t) 8975 except Exception as e: 8976 if self.parent.shouldRetry(tries, e, deadline): 8977 tries += 1 8978 time.sleep( 8979 self.parent.exponentialBackoff(tries, deadline)) 8980 continue 8981 raise plumbing.convert_error_to_porcelain(e) from e 8982 tries = 0 8983 for plumbing_item in plumbing_response.history: 8984 yield plumbing.convert_workflow_history_to_porcelain( 8985 plumbing_item) 8986 if plumbing_response.meta.next_cursor == '': 8987 break 8988 req.meta.cursor = plumbing_response.meta.next_cursor 8989 8990 return generator(self, req)
List gets a list of WorkflowHistory records matching a given set of criteria.