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 .peering_group_nodes_pb2 import * 118from .peering_group_nodes_pb2_grpc import * 119from .peering_group_peers_pb2 import * 120from .peering_group_peers_pb2_grpc import * 121from .peering_group_resources_pb2 import * 122from .peering_group_resources_pb2_grpc import * 123from .peering_groups_pb2 import * 124from .peering_groups_pb2_grpc import * 125from .policies_pb2 import * 126from .policies_pb2_grpc import * 127from .policies_history_pb2 import * 128from .policies_history_pb2_grpc import * 129from .proxy_cluster_keys_pb2 import * 130from .proxy_cluster_keys_pb2_grpc import * 131from .queries_pb2 import * 132from .queries_pb2_grpc import * 133from .remote_identities_pb2 import * 134from .remote_identities_pb2_grpc import * 135from .remote_identities_history_pb2 import * 136from .remote_identities_history_pb2_grpc import * 137from .remote_identity_groups_pb2 import * 138from .remote_identity_groups_pb2_grpc import * 139from .remote_identity_groups_history_pb2 import * 140from .remote_identity_groups_history_pb2_grpc import * 141from .replays_pb2 import * 142from .replays_pb2_grpc import * 143from .requestable_account_entitlements_pb2 import * 144from .requestable_account_entitlements_pb2_grpc import * 145from .requestable_resource_entitlements_pb2 import * 146from .requestable_resource_entitlements_pb2_grpc import * 147from .requestable_role_entitlements_pb2 import * 148from .requestable_role_entitlements_pb2_grpc import * 149from .resources_pb2 import * 150from .resources_pb2_grpc import * 151from .resources_history_pb2 import * 152from .resources_history_pb2_grpc import * 153from .role_resources_pb2 import * 154from .role_resources_pb2_grpc import * 155from .role_resources_history_pb2 import * 156from .role_resources_history_pb2_grpc import * 157from .roles_history_pb2 import * 158from .roles_history_pb2_grpc import * 159from .secret_engine_policy_pb2 import * 160from .secret_engine_policy_pb2_grpc import * 161from .secret_engine_types_pb2 import * 162from .secret_engine_types_pb2_grpc import * 163from .secret_store_types_pb2 import * 164from .secret_store_types_pb2_grpc import * 165from .secret_stores_pb2 import * 166from .secret_stores_pb2_grpc import * 167from .secret_engines_pb2 import * 168from .secret_engines_pb2_grpc import * 169from .secret_store_healths_pb2 import * 170from .secret_store_healths_pb2_grpc import * 171from .secret_stores_history_pb2 import * 172from .secret_stores_history_pb2_grpc import * 173from .workflow_approvers_pb2 import * 174from .workflow_approvers_pb2_grpc import * 175from .workflow_approvers_history_pb2 import * 176from .workflow_approvers_history_pb2_grpc import * 177from .workflow_roles_pb2 import * 178from .workflow_roles_pb2_grpc import * 179from .workflow_roles_history_pb2 import * 180from .workflow_roles_history_pb2_grpc import * 181from .workflows_pb2 import * 182from .workflows_pb2_grpc import * 183from .workflows_history_pb2 import * 184from .workflows_history_pb2_grpc import * 185import warnings 186import functools 187import time 188 189 190def deprecated(func): 191 """This is a decorator which can be used to mark functions 192 as deprecated. It will result in a warning being emitted 193 when the function is used.""" 194 @functools.wraps(func) 195 def new_func(*args, **kwargs): 196 warnings.warn("Call to deprecated function {}.".format(func.__name__), 197 category=DeprecationWarning, 198 stacklevel=2) 199 return func(*args, **kwargs) 200 201 return new_func 202 203 204class AccessRequests: 205 ''' 206 AccessRequests are requests for access to a resource that may match a Workflow. 207 See `strongdm.models.AccessRequest`. 208 ''' 209 def __init__(self, channel, client): 210 self.parent = client 211 self.stub = AccessRequestsStub(channel) 212 213 def list(self, filter, *args, timeout=None): 214 ''' 215 Lists existing access requests. 216 ''' 217 deadline = None if timeout is None else time.time() + timeout 218 req = AccessRequestListRequest() 219 req.meta.CopyFrom(ListRequestMetadata()) 220 if self.parent.page_limit > 0: 221 req.meta.limit = self.parent.page_limit 222 if self.parent.snapshot_datetime is not None: 223 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 224 225 req.filter = plumbing.quote_filter_args(filter, *args) 226 227 def generator(svc, req): 228 tries = 0 229 while True: 230 t = None if deadline is None else deadline - time.time() 231 try: 232 plumbing_response = svc.stub.List( 233 req, 234 metadata=svc.parent.get_metadata( 235 'AccessRequests.List', req), 236 timeout=t) 237 except Exception as e: 238 if self.parent.shouldRetry(tries, e, deadline): 239 tries += 1 240 time.sleep( 241 self.parent.exponentialBackoff(tries, deadline)) 242 continue 243 raise plumbing.convert_error_to_porcelain(e) from e 244 tries = 0 245 for plumbing_item in plumbing_response.access_requests: 246 yield plumbing.convert_access_request_to_porcelain( 247 plumbing_item) 248 if plumbing_response.meta.next_cursor == '': 249 break 250 req.meta.cursor = plumbing_response.meta.next_cursor 251 252 return generator(self, req) 253 254 255class SnapshotAccessRequests: 256 ''' 257 SnapshotAccessRequests exposes the read only methods of the AccessRequests 258 service for historical queries. 259 ''' 260 def __init__(self, access_requests): 261 self.access_requests = access_requests 262 263 def list(self, filter, *args, timeout=None): 264 ''' 265 Lists existing access requests. 266 ''' 267 return self.access_requests.list(filter, *args, timeout=timeout) 268 269 270class AccessRequestEventsHistory: 271 ''' 272 AccessRequestEventsHistory provides records of all changes to the state of an AccessRequest. 273 See `strongdm.models.AccessRequestEventHistory`. 274 ''' 275 def __init__(self, channel, client): 276 self.parent = client 277 self.stub = AccessRequestEventsHistoryStub(channel) 278 279 def list(self, filter, *args, timeout=None): 280 ''' 281 List gets a list of AccessRequestEventHistory records matching a given set of criteria. 282 ''' 283 deadline = None if timeout is None else time.time() + timeout 284 req = AccessRequestEventHistoryListRequest() 285 req.meta.CopyFrom(ListRequestMetadata()) 286 if self.parent.page_limit > 0: 287 req.meta.limit = self.parent.page_limit 288 if self.parent.snapshot_datetime is not None: 289 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 290 291 req.filter = plumbing.quote_filter_args(filter, *args) 292 293 def generator(svc, req): 294 tries = 0 295 while True: 296 t = None if deadline is None else deadline - time.time() 297 try: 298 plumbing_response = svc.stub.List( 299 req, 300 metadata=svc.parent.get_metadata( 301 'AccessRequestEventsHistory.List', req), 302 timeout=t) 303 except Exception as e: 304 if self.parent.shouldRetry(tries, e, deadline): 305 tries += 1 306 time.sleep( 307 self.parent.exponentialBackoff(tries, deadline)) 308 continue 309 raise plumbing.convert_error_to_porcelain(e) from e 310 tries = 0 311 for plumbing_item in plumbing_response.history: 312 yield plumbing.convert_access_request_event_history_to_porcelain( 313 plumbing_item) 314 if plumbing_response.meta.next_cursor == '': 315 break 316 req.meta.cursor = plumbing_response.meta.next_cursor 317 318 return generator(self, req) 319 320 321class AccessRequestsHistory: 322 ''' 323 AccessRequestsHistory provides records of all changes to the state of an AccessRequest. 324 See `strongdm.models.AccessRequestHistory`. 325 ''' 326 def __init__(self, channel, client): 327 self.parent = client 328 self.stub = AccessRequestsHistoryStub(channel) 329 330 def list(self, filter, *args, timeout=None): 331 ''' 332 List gets a list of AccessRequestHistory records matching a given set of criteria. 333 ''' 334 deadline = None if timeout is None else time.time() + timeout 335 req = AccessRequestHistoryListRequest() 336 req.meta.CopyFrom(ListRequestMetadata()) 337 if self.parent.page_limit > 0: 338 req.meta.limit = self.parent.page_limit 339 if self.parent.snapshot_datetime is not None: 340 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 341 342 req.filter = plumbing.quote_filter_args(filter, *args) 343 344 def generator(svc, req): 345 tries = 0 346 while True: 347 t = None if deadline is None else deadline - time.time() 348 try: 349 plumbing_response = svc.stub.List( 350 req, 351 metadata=svc.parent.get_metadata( 352 'AccessRequestsHistory.List', req), 353 timeout=t) 354 except Exception as e: 355 if self.parent.shouldRetry(tries, e, deadline): 356 tries += 1 357 time.sleep( 358 self.parent.exponentialBackoff(tries, deadline)) 359 continue 360 raise plumbing.convert_error_to_porcelain(e) from e 361 tries = 0 362 for plumbing_item in plumbing_response.history: 363 yield plumbing.convert_access_request_history_to_porcelain( 364 plumbing_item) 365 if plumbing_response.meta.next_cursor == '': 366 break 367 req.meta.cursor = plumbing_response.meta.next_cursor 368 369 return generator(self, req) 370 371 372class AccountAttachments: 373 ''' 374 AccountAttachments assign an account to a role. 375 See `strongdm.models.AccountAttachment`. 376 ''' 377 def __init__(self, channel, client): 378 self.parent = client 379 self.stub = AccountAttachmentsStub(channel) 380 381 def create(self, account_attachment, timeout=None): 382 ''' 383 Create registers a new AccountAttachment. 384 ''' 385 deadline = None if timeout is None else time.time() + timeout 386 req = AccountAttachmentCreateRequest() 387 388 if account_attachment is not None: 389 req.account_attachment.CopyFrom( 390 plumbing.convert_account_attachment_to_plumbing( 391 account_attachment)) 392 tries = 0 393 plumbing_response = None 394 while True: 395 t = None if deadline is None else deadline - time.time() 396 try: 397 plumbing_response = self.stub.Create( 398 req, 399 metadata=self.parent.get_metadata( 400 'AccountAttachments.Create', req), 401 timeout=t) 402 except Exception as e: 403 if self.parent.shouldRetry(tries, e, deadline): 404 tries += 1 405 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 406 continue 407 raise plumbing.convert_error_to_porcelain(e) from e 408 break 409 410 resp = models.AccountAttachmentCreateResponse() 411 resp.account_attachment = plumbing.convert_account_attachment_to_porcelain( 412 plumbing_response.account_attachment) 413 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 414 plumbing_response.meta) 415 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 416 plumbing_response.rate_limit) 417 return resp 418 419 def get(self, id, timeout=None): 420 ''' 421 Get reads one AccountAttachment by ID. 422 ''' 423 deadline = None if timeout is None else time.time() + timeout 424 req = AccountAttachmentGetRequest() 425 if self.parent.snapshot_datetime is not None: 426 req.meta.CopyFrom(GetRequestMetadata()) 427 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 428 429 req.id = (id) 430 tries = 0 431 plumbing_response = None 432 while True: 433 t = None if deadline is None else deadline - time.time() 434 try: 435 plumbing_response = self.stub.Get( 436 req, 437 metadata=self.parent.get_metadata('AccountAttachments.Get', 438 req), 439 timeout=t) 440 except Exception as e: 441 if self.parent.shouldRetry(tries, e, deadline): 442 tries += 1 443 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 444 continue 445 raise plumbing.convert_error_to_porcelain(e) from e 446 break 447 448 resp = models.AccountAttachmentGetResponse() 449 resp.account_attachment = plumbing.convert_account_attachment_to_porcelain( 450 plumbing_response.account_attachment) 451 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 452 plumbing_response.meta) 453 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 454 plumbing_response.rate_limit) 455 return resp 456 457 def delete(self, id, timeout=None): 458 ''' 459 Delete removes a AccountAttachment by ID. 460 ''' 461 deadline = None if timeout is None else time.time() + timeout 462 req = AccountAttachmentDeleteRequest() 463 464 req.id = (id) 465 tries = 0 466 plumbing_response = None 467 while True: 468 t = None if deadline is None else deadline - time.time() 469 try: 470 plumbing_response = self.stub.Delete( 471 req, 472 metadata=self.parent.get_metadata( 473 'AccountAttachments.Delete', req), 474 timeout=t) 475 except Exception as e: 476 if self.parent.shouldRetry(tries, e, deadline): 477 tries += 1 478 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 479 continue 480 raise plumbing.convert_error_to_porcelain(e) from e 481 break 482 483 resp = models.AccountAttachmentDeleteResponse() 484 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 485 plumbing_response.meta) 486 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 487 plumbing_response.rate_limit) 488 return resp 489 490 def list(self, filter, *args, timeout=None): 491 ''' 492 List gets a list of AccountAttachments matching a given set of criteria. 493 ''' 494 deadline = None if timeout is None else time.time() + timeout 495 req = AccountAttachmentListRequest() 496 req.meta.CopyFrom(ListRequestMetadata()) 497 if self.parent.page_limit > 0: 498 req.meta.limit = self.parent.page_limit 499 if self.parent.snapshot_datetime is not None: 500 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 501 502 req.filter = plumbing.quote_filter_args(filter, *args) 503 504 def generator(svc, req): 505 tries = 0 506 while True: 507 t = None if deadline is None else deadline - time.time() 508 try: 509 plumbing_response = svc.stub.List( 510 req, 511 metadata=svc.parent.get_metadata( 512 'AccountAttachments.List', req), 513 timeout=t) 514 except Exception as e: 515 if self.parent.shouldRetry(tries, e, deadline): 516 tries += 1 517 time.sleep( 518 self.parent.exponentialBackoff(tries, deadline)) 519 continue 520 raise plumbing.convert_error_to_porcelain(e) from e 521 tries = 0 522 for plumbing_item in plumbing_response.account_attachments: 523 yield plumbing.convert_account_attachment_to_porcelain( 524 plumbing_item) 525 if plumbing_response.meta.next_cursor == '': 526 break 527 req.meta.cursor = plumbing_response.meta.next_cursor 528 529 return generator(self, req) 530 531 532class SnapshotAccountAttachments: 533 ''' 534 SnapshotAccountAttachments exposes the read only methods of the AccountAttachments 535 service for historical queries. 536 ''' 537 def __init__(self, account_attachments): 538 self.account_attachments = account_attachments 539 540 def get(self, id, timeout=None): 541 ''' 542 Get reads one AccountAttachment by ID. 543 ''' 544 return self.account_attachments.get(id, timeout=timeout) 545 546 def list(self, filter, *args, timeout=None): 547 ''' 548 List gets a list of AccountAttachments matching a given set of criteria. 549 ''' 550 return self.account_attachments.list(filter, *args, timeout=timeout) 551 552 553class AccountAttachmentsHistory: 554 ''' 555 AccountAttachmentsHistory records all changes to the state of an AccountAttachment. 556 See `strongdm.models.AccountAttachmentHistory`. 557 ''' 558 def __init__(self, channel, client): 559 self.parent = client 560 self.stub = AccountAttachmentsHistoryStub(channel) 561 562 def list(self, filter, *args, timeout=None): 563 ''' 564 List gets a list of AccountAttachmentHistory records matching a given set of criteria. 565 ''' 566 deadline = None if timeout is None else time.time() + timeout 567 req = AccountAttachmentHistoryListRequest() 568 req.meta.CopyFrom(ListRequestMetadata()) 569 if self.parent.page_limit > 0: 570 req.meta.limit = self.parent.page_limit 571 if self.parent.snapshot_datetime is not None: 572 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 573 574 req.filter = plumbing.quote_filter_args(filter, *args) 575 576 def generator(svc, req): 577 tries = 0 578 while True: 579 t = None if deadline is None else deadline - time.time() 580 try: 581 plumbing_response = svc.stub.List( 582 req, 583 metadata=svc.parent.get_metadata( 584 'AccountAttachmentsHistory.List', req), 585 timeout=t) 586 except Exception as e: 587 if self.parent.shouldRetry(tries, e, deadline): 588 tries += 1 589 time.sleep( 590 self.parent.exponentialBackoff(tries, deadline)) 591 continue 592 raise plumbing.convert_error_to_porcelain(e) from e 593 tries = 0 594 for plumbing_item in plumbing_response.history: 595 yield plumbing.convert_account_attachment_history_to_porcelain( 596 plumbing_item) 597 if plumbing_response.meta.next_cursor == '': 598 break 599 req.meta.cursor = plumbing_response.meta.next_cursor 600 601 return generator(self, req) 602 603 604class AccountGrants: 605 ''' 606 AccountGrants assign a resource directly to an account, giving the account the permission to connect to that resource. 607 See `strongdm.models.AccountGrant`. 608 ''' 609 def __init__(self, channel, client): 610 self.parent = client 611 self.stub = AccountGrantsStub(channel) 612 613 def create(self, account_grant, timeout=None): 614 ''' 615 Create registers a new AccountGrant. 616 ''' 617 deadline = None if timeout is None else time.time() + timeout 618 req = AccountGrantCreateRequest() 619 620 if account_grant is not None: 621 req.account_grant.CopyFrom( 622 plumbing.convert_account_grant_to_plumbing(account_grant)) 623 tries = 0 624 plumbing_response = None 625 while True: 626 t = None if deadline is None else deadline - time.time() 627 try: 628 plumbing_response = self.stub.Create( 629 req, 630 metadata=self.parent.get_metadata('AccountGrants.Create', 631 req), 632 timeout=t) 633 except Exception as e: 634 if self.parent.shouldRetry(tries, e, deadline): 635 tries += 1 636 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 637 continue 638 raise plumbing.convert_error_to_porcelain(e) from e 639 break 640 641 resp = models.AccountGrantCreateResponse() 642 resp.account_grant = plumbing.convert_account_grant_to_porcelain( 643 plumbing_response.account_grant) 644 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 645 plumbing_response.meta) 646 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 647 plumbing_response.rate_limit) 648 return resp 649 650 def get(self, id, timeout=None): 651 ''' 652 Get reads one AccountGrant by ID. 653 ''' 654 deadline = None if timeout is None else time.time() + timeout 655 req = AccountGrantGetRequest() 656 if self.parent.snapshot_datetime is not None: 657 req.meta.CopyFrom(GetRequestMetadata()) 658 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 659 660 req.id = (id) 661 tries = 0 662 plumbing_response = None 663 while True: 664 t = None if deadline is None else deadline - time.time() 665 try: 666 plumbing_response = self.stub.Get( 667 req, 668 metadata=self.parent.get_metadata('AccountGrants.Get', 669 req), 670 timeout=t) 671 except Exception as e: 672 if self.parent.shouldRetry(tries, e, deadline): 673 tries += 1 674 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 675 continue 676 raise plumbing.convert_error_to_porcelain(e) from e 677 break 678 679 resp = models.AccountGrantGetResponse() 680 resp.account_grant = plumbing.convert_account_grant_to_porcelain( 681 plumbing_response.account_grant) 682 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 683 plumbing_response.meta) 684 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 685 plumbing_response.rate_limit) 686 return resp 687 688 def delete(self, id, timeout=None): 689 ''' 690 Delete removes a AccountGrant by ID. 691 ''' 692 deadline = None if timeout is None else time.time() + timeout 693 req = AccountGrantDeleteRequest() 694 695 req.id = (id) 696 tries = 0 697 plumbing_response = None 698 while True: 699 t = None if deadline is None else deadline - time.time() 700 try: 701 plumbing_response = self.stub.Delete( 702 req, 703 metadata=self.parent.get_metadata('AccountGrants.Delete', 704 req), 705 timeout=t) 706 except Exception as e: 707 if self.parent.shouldRetry(tries, e, deadline): 708 tries += 1 709 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 710 continue 711 raise plumbing.convert_error_to_porcelain(e) from e 712 break 713 714 resp = models.AccountGrantDeleteResponse() 715 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 716 plumbing_response.meta) 717 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 718 plumbing_response.rate_limit) 719 return resp 720 721 def list(self, filter, *args, timeout=None): 722 ''' 723 List gets a list of AccountGrants matching a given set of criteria. 724 ''' 725 deadline = None if timeout is None else time.time() + timeout 726 req = AccountGrantListRequest() 727 req.meta.CopyFrom(ListRequestMetadata()) 728 if self.parent.page_limit > 0: 729 req.meta.limit = self.parent.page_limit 730 if self.parent.snapshot_datetime is not None: 731 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 732 733 req.filter = plumbing.quote_filter_args(filter, *args) 734 735 def generator(svc, req): 736 tries = 0 737 while True: 738 t = None if deadline is None else deadline - time.time() 739 try: 740 plumbing_response = svc.stub.List( 741 req, 742 metadata=svc.parent.get_metadata( 743 'AccountGrants.List', req), 744 timeout=t) 745 except Exception as e: 746 if self.parent.shouldRetry(tries, e, deadline): 747 tries += 1 748 time.sleep( 749 self.parent.exponentialBackoff(tries, deadline)) 750 continue 751 raise plumbing.convert_error_to_porcelain(e) from e 752 tries = 0 753 for plumbing_item in plumbing_response.account_grants: 754 yield plumbing.convert_account_grant_to_porcelain( 755 plumbing_item) 756 if plumbing_response.meta.next_cursor == '': 757 break 758 req.meta.cursor = plumbing_response.meta.next_cursor 759 760 return generator(self, req) 761 762 763class SnapshotAccountGrants: 764 ''' 765 SnapshotAccountGrants exposes the read only methods of the AccountGrants 766 service for historical queries. 767 ''' 768 def __init__(self, account_grants): 769 self.account_grants = account_grants 770 771 def get(self, id, timeout=None): 772 ''' 773 Get reads one AccountGrant by ID. 774 ''' 775 return self.account_grants.get(id, timeout=timeout) 776 777 def list(self, filter, *args, timeout=None): 778 ''' 779 List gets a list of AccountGrants matching a given set of criteria. 780 ''' 781 return self.account_grants.list(filter, *args, timeout=timeout) 782 783 784class AccountGrantsHistory: 785 ''' 786 AccountGrantsHistory records all changes to the state of an AccountGrant. 787 See `strongdm.models.AccountGrantHistory`. 788 ''' 789 def __init__(self, channel, client): 790 self.parent = client 791 self.stub = AccountGrantsHistoryStub(channel) 792 793 def list(self, filter, *args, timeout=None): 794 ''' 795 List gets a list of AccountGrantHistory records matching a given set of criteria. 796 ''' 797 deadline = None if timeout is None else time.time() + timeout 798 req = AccountGrantHistoryListRequest() 799 req.meta.CopyFrom(ListRequestMetadata()) 800 if self.parent.page_limit > 0: 801 req.meta.limit = self.parent.page_limit 802 if self.parent.snapshot_datetime is not None: 803 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 804 805 req.filter = plumbing.quote_filter_args(filter, *args) 806 807 def generator(svc, req): 808 tries = 0 809 while True: 810 t = None if deadline is None else deadline - time.time() 811 try: 812 plumbing_response = svc.stub.List( 813 req, 814 metadata=svc.parent.get_metadata( 815 'AccountGrantsHistory.List', req), 816 timeout=t) 817 except Exception as e: 818 if self.parent.shouldRetry(tries, e, deadline): 819 tries += 1 820 time.sleep( 821 self.parent.exponentialBackoff(tries, deadline)) 822 continue 823 raise plumbing.convert_error_to_porcelain(e) from e 824 tries = 0 825 for plumbing_item in plumbing_response.history: 826 yield plumbing.convert_account_grant_history_to_porcelain( 827 plumbing_item) 828 if plumbing_response.meta.next_cursor == '': 829 break 830 req.meta.cursor = plumbing_response.meta.next_cursor 831 832 return generator(self, req) 833 834 835class AccountPermissions: 836 ''' 837 AccountPermissions records the granular permissions accounts have, allowing them to execute 838 relevant commands via StrongDM's APIs. 839 See `strongdm.models.AccountPermission`. 840 ''' 841 def __init__(self, channel, client): 842 self.parent = client 843 self.stub = AccountPermissionsStub(channel) 844 845 def list(self, filter, *args, timeout=None): 846 ''' 847 List gets a list of Permission records matching a given set of criteria. 848 ''' 849 deadline = None if timeout is None else time.time() + timeout 850 req = AccountPermissionListRequest() 851 req.meta.CopyFrom(ListRequestMetadata()) 852 if self.parent.page_limit > 0: 853 req.meta.limit = self.parent.page_limit 854 if self.parent.snapshot_datetime is not None: 855 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 856 857 req.filter = plumbing.quote_filter_args(filter, *args) 858 859 def generator(svc, req): 860 tries = 0 861 while True: 862 t = None if deadline is None else deadline - time.time() 863 try: 864 plumbing_response = svc.stub.List( 865 req, 866 metadata=svc.parent.get_metadata( 867 'AccountPermissions.List', req), 868 timeout=t) 869 except Exception as e: 870 if self.parent.shouldRetry(tries, e, deadline): 871 tries += 1 872 time.sleep( 873 self.parent.exponentialBackoff(tries, deadline)) 874 continue 875 raise plumbing.convert_error_to_porcelain(e) from e 876 tries = 0 877 for plumbing_item in plumbing_response.permissions: 878 yield plumbing.convert_account_permission_to_porcelain( 879 plumbing_item) 880 if plumbing_response.meta.next_cursor == '': 881 break 882 req.meta.cursor = plumbing_response.meta.next_cursor 883 884 return generator(self, req) 885 886 887class SnapshotAccountPermissions: 888 ''' 889 SnapshotAccountPermissions exposes the read only methods of the AccountPermissions 890 service for historical queries. 891 ''' 892 def __init__(self, account_permissions): 893 self.account_permissions = account_permissions 894 895 def list(self, filter, *args, timeout=None): 896 ''' 897 List gets a list of Permission records matching a given set of criteria. 898 ''' 899 return self.account_permissions.list(filter, *args, timeout=timeout) 900 901 902class AccountResources: 903 ''' 904 AccountResources enumerates the resources to which accounts have access. 905 The AccountResources service is read-only. 906 See `strongdm.models.AccountResource`. 907 ''' 908 def __init__(self, channel, client): 909 self.parent = client 910 self.stub = AccountResourcesStub(channel) 911 912 def list(self, filter, *args, timeout=None): 913 ''' 914 List gets a list of AccountResource records matching a given set of criteria. 915 ''' 916 deadline = None if timeout is None else time.time() + timeout 917 req = AccountResourceListRequest() 918 req.meta.CopyFrom(ListRequestMetadata()) 919 if self.parent.page_limit > 0: 920 req.meta.limit = self.parent.page_limit 921 if self.parent.snapshot_datetime is not None: 922 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 923 924 req.filter = plumbing.quote_filter_args(filter, *args) 925 926 def generator(svc, req): 927 tries = 0 928 while True: 929 t = None if deadline is None else deadline - time.time() 930 try: 931 plumbing_response = svc.stub.List( 932 req, 933 metadata=svc.parent.get_metadata( 934 'AccountResources.List', req), 935 timeout=t) 936 except Exception as e: 937 if self.parent.shouldRetry(tries, e, deadline): 938 tries += 1 939 time.sleep( 940 self.parent.exponentialBackoff(tries, deadline)) 941 continue 942 raise plumbing.convert_error_to_porcelain(e) from e 943 tries = 0 944 for plumbing_item in plumbing_response.account_resources: 945 yield plumbing.convert_account_resource_to_porcelain( 946 plumbing_item) 947 if plumbing_response.meta.next_cursor == '': 948 break 949 req.meta.cursor = plumbing_response.meta.next_cursor 950 951 return generator(self, req) 952 953 954class SnapshotAccountResources: 955 ''' 956 SnapshotAccountResources exposes the read only methods of the AccountResources 957 service for historical queries. 958 ''' 959 def __init__(self, account_resources): 960 self.account_resources = account_resources 961 962 def list(self, filter, *args, timeout=None): 963 ''' 964 List gets a list of AccountResource records matching a given set of criteria. 965 ''' 966 return self.account_resources.list(filter, *args, timeout=timeout) 967 968 969class AccountResourcesHistory: 970 ''' 971 AccountResourcesHistory records all changes to the state of a AccountResource. 972 See `strongdm.models.AccountResourceHistory`. 973 ''' 974 def __init__(self, channel, client): 975 self.parent = client 976 self.stub = AccountResourcesHistoryStub(channel) 977 978 def list(self, filter, *args, timeout=None): 979 ''' 980 List gets a list of AccountResourceHistory records matching a given set of criteria. 981 ''' 982 deadline = None if timeout is None else time.time() + timeout 983 req = AccountResourceHistoryListRequest() 984 req.meta.CopyFrom(ListRequestMetadata()) 985 if self.parent.page_limit > 0: 986 req.meta.limit = self.parent.page_limit 987 if self.parent.snapshot_datetime is not None: 988 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 989 990 req.filter = plumbing.quote_filter_args(filter, *args) 991 992 def generator(svc, req): 993 tries = 0 994 while True: 995 t = None if deadline is None else deadline - time.time() 996 try: 997 plumbing_response = svc.stub.List( 998 req, 999 metadata=svc.parent.get_metadata( 1000 'AccountResourcesHistory.List', req), 1001 timeout=t) 1002 except Exception as e: 1003 if self.parent.shouldRetry(tries, e, deadline): 1004 tries += 1 1005 time.sleep( 1006 self.parent.exponentialBackoff(tries, deadline)) 1007 continue 1008 raise plumbing.convert_error_to_porcelain(e) from e 1009 tries = 0 1010 for plumbing_item in plumbing_response.history: 1011 yield plumbing.convert_account_resource_history_to_porcelain( 1012 plumbing_item) 1013 if plumbing_response.meta.next_cursor == '': 1014 break 1015 req.meta.cursor = plumbing_response.meta.next_cursor 1016 1017 return generator(self, req) 1018 1019 1020class Accounts: 1021 ''' 1022 Accounts are users that have access to strongDM. There are two types of accounts: 1023 1. **Users:** humans who are authenticated through username and password or SSO. 1024 2. **Service Accounts:** machines that are authenticated using a service token. 1025 3. **Tokens** are access keys with permissions that can be used for authentication. 1026 See: 1027 `strongdm.models.Service` 1028 `strongdm.models.Token` 1029 `strongdm.models.User` 1030 ''' 1031 def __init__(self, channel, client): 1032 self.parent = client 1033 self.stub = AccountsStub(channel) 1034 1035 def create(self, account, timeout=None): 1036 ''' 1037 Create registers a new Account. 1038 ''' 1039 deadline = None if timeout is None else time.time() + timeout 1040 req = AccountCreateRequest() 1041 1042 if account is not None: 1043 req.account.CopyFrom(plumbing.convert_account_to_plumbing(account)) 1044 tries = 0 1045 plumbing_response = None 1046 while True: 1047 t = None if deadline is None else deadline - time.time() 1048 try: 1049 plumbing_response = self.stub.Create( 1050 req, 1051 metadata=self.parent.get_metadata('Accounts.Create', req), 1052 timeout=t) 1053 except Exception as e: 1054 if self.parent.shouldRetry(tries, e, deadline): 1055 tries += 1 1056 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1057 continue 1058 raise plumbing.convert_error_to_porcelain(e) from e 1059 break 1060 1061 resp = models.AccountCreateResponse() 1062 resp.access_key = (plumbing_response.access_key) 1063 resp.account = plumbing.convert_account_to_porcelain( 1064 plumbing_response.account) 1065 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 1066 plumbing_response.meta) 1067 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1068 plumbing_response.rate_limit) 1069 resp.secret_key = (plumbing_response.secret_key) 1070 resp.token = (plumbing_response.token) 1071 return resp 1072 1073 def get(self, id, timeout=None): 1074 ''' 1075 Get reads one Account by ID. 1076 ''' 1077 deadline = None if timeout is None else time.time() + timeout 1078 req = AccountGetRequest() 1079 if self.parent.snapshot_datetime is not None: 1080 req.meta.CopyFrom(GetRequestMetadata()) 1081 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1082 1083 req.id = (id) 1084 tries = 0 1085 plumbing_response = None 1086 while True: 1087 t = None if deadline is None else deadline - time.time() 1088 try: 1089 plumbing_response = self.stub.Get( 1090 req, 1091 metadata=self.parent.get_metadata('Accounts.Get', req), 1092 timeout=t) 1093 except Exception as e: 1094 if self.parent.shouldRetry(tries, e, deadline): 1095 tries += 1 1096 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1097 continue 1098 raise plumbing.convert_error_to_porcelain(e) from e 1099 break 1100 1101 resp = models.AccountGetResponse() 1102 resp.account = plumbing.convert_account_to_porcelain( 1103 plumbing_response.account) 1104 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1105 plumbing_response.meta) 1106 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1107 plumbing_response.rate_limit) 1108 return resp 1109 1110 def update(self, account, timeout=None): 1111 ''' 1112 Update replaces all the fields of an Account by ID. 1113 ''' 1114 deadline = None if timeout is None else time.time() + timeout 1115 req = AccountUpdateRequest() 1116 1117 if account is not None: 1118 req.account.CopyFrom(plumbing.convert_account_to_plumbing(account)) 1119 tries = 0 1120 plumbing_response = None 1121 while True: 1122 t = None if deadline is None else deadline - time.time() 1123 try: 1124 plumbing_response = self.stub.Update( 1125 req, 1126 metadata=self.parent.get_metadata('Accounts.Update', req), 1127 timeout=t) 1128 except Exception as e: 1129 if self.parent.shouldRetry(tries, e, deadline): 1130 tries += 1 1131 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1132 continue 1133 raise plumbing.convert_error_to_porcelain(e) from e 1134 break 1135 1136 resp = models.AccountUpdateResponse() 1137 resp.account = plumbing.convert_account_to_porcelain( 1138 plumbing_response.account) 1139 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 1140 plumbing_response.meta) 1141 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1142 plumbing_response.rate_limit) 1143 return resp 1144 1145 def delete(self, id, timeout=None): 1146 ''' 1147 Delete removes an Account by ID. 1148 ''' 1149 deadline = None if timeout is None else time.time() + timeout 1150 req = AccountDeleteRequest() 1151 1152 req.id = (id) 1153 tries = 0 1154 plumbing_response = None 1155 while True: 1156 t = None if deadline is None else deadline - time.time() 1157 try: 1158 plumbing_response = self.stub.Delete( 1159 req, 1160 metadata=self.parent.get_metadata('Accounts.Delete', req), 1161 timeout=t) 1162 except Exception as e: 1163 if self.parent.shouldRetry(tries, e, deadline): 1164 tries += 1 1165 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1166 continue 1167 raise plumbing.convert_error_to_porcelain(e) from e 1168 break 1169 1170 resp = models.AccountDeleteResponse() 1171 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 1172 plumbing_response.meta) 1173 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1174 plumbing_response.rate_limit) 1175 return resp 1176 1177 def list(self, filter, *args, timeout=None): 1178 ''' 1179 List gets a list of Accounts matching a given set of criteria. 1180 ''' 1181 deadline = None if timeout is None else time.time() + timeout 1182 req = AccountListRequest() 1183 req.meta.CopyFrom(ListRequestMetadata()) 1184 if self.parent.page_limit > 0: 1185 req.meta.limit = self.parent.page_limit 1186 if self.parent.snapshot_datetime is not None: 1187 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1188 1189 req.filter = plumbing.quote_filter_args(filter, *args) 1190 1191 def generator(svc, req): 1192 tries = 0 1193 while True: 1194 t = None if deadline is None else deadline - time.time() 1195 try: 1196 plumbing_response = svc.stub.List( 1197 req, 1198 metadata=svc.parent.get_metadata('Accounts.List', req), 1199 timeout=t) 1200 except Exception as e: 1201 if self.parent.shouldRetry(tries, e, deadline): 1202 tries += 1 1203 time.sleep( 1204 self.parent.exponentialBackoff(tries, deadline)) 1205 continue 1206 raise plumbing.convert_error_to_porcelain(e) from e 1207 tries = 0 1208 for plumbing_item in plumbing_response.accounts: 1209 yield plumbing.convert_account_to_porcelain(plumbing_item) 1210 if plumbing_response.meta.next_cursor == '': 1211 break 1212 req.meta.cursor = plumbing_response.meta.next_cursor 1213 1214 return generator(self, req) 1215 1216 1217class SnapshotAccounts: 1218 ''' 1219 SnapshotAccounts exposes the read only methods of the Accounts 1220 service for historical queries. 1221 ''' 1222 def __init__(self, accounts): 1223 self.accounts = accounts 1224 1225 def get(self, id, timeout=None): 1226 ''' 1227 Get reads one Account by ID. 1228 ''' 1229 return self.accounts.get(id, timeout=timeout) 1230 1231 def list(self, filter, *args, timeout=None): 1232 ''' 1233 List gets a list of Accounts matching a given set of criteria. 1234 ''' 1235 return self.accounts.list(filter, *args, timeout=timeout) 1236 1237 1238class AccountsGroups: 1239 ''' 1240 An AccountGroup links an account and a group. 1241 See `strongdm.models.AccountGroup`. 1242 ''' 1243 def __init__(self, channel, client): 1244 self.parent = client 1245 self.stub = AccountsGroupsStub(channel) 1246 1247 def create(self, account_group, timeout=None): 1248 ''' 1249 Create create a new AccountGroup. 1250 ''' 1251 deadline = None if timeout is None else time.time() + timeout 1252 req = AccountGroupCreateRequest() 1253 1254 if account_group is not None: 1255 req.account_group.CopyFrom( 1256 plumbing.convert_account_group_to_plumbing(account_group)) 1257 tries = 0 1258 plumbing_response = None 1259 while True: 1260 t = None if deadline is None else deadline - time.time() 1261 try: 1262 plumbing_response = self.stub.Create( 1263 req, 1264 metadata=self.parent.get_metadata('AccountsGroups.Create', 1265 req), 1266 timeout=t) 1267 except Exception as e: 1268 if self.parent.shouldRetry(tries, e, deadline): 1269 tries += 1 1270 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1271 continue 1272 raise plumbing.convert_error_to_porcelain(e) from e 1273 break 1274 1275 resp = models.AccountGroupCreateResponse() 1276 resp.account_group = plumbing.convert_account_group_to_porcelain( 1277 plumbing_response.account_group) 1278 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1279 plumbing_response.rate_limit) 1280 return resp 1281 1282 def get(self, id, timeout=None): 1283 ''' 1284 Get reads one AccountGroup by ID. 1285 ''' 1286 deadline = None if timeout is None else time.time() + timeout 1287 req = AccountGroupGetRequest() 1288 if self.parent.snapshot_datetime is not None: 1289 req.meta.CopyFrom(GetRequestMetadata()) 1290 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1291 1292 req.id = (id) 1293 tries = 0 1294 plumbing_response = None 1295 while True: 1296 t = None if deadline is None else deadline - time.time() 1297 try: 1298 plumbing_response = self.stub.Get( 1299 req, 1300 metadata=self.parent.get_metadata('AccountsGroups.Get', 1301 req), 1302 timeout=t) 1303 except Exception as e: 1304 if self.parent.shouldRetry(tries, e, deadline): 1305 tries += 1 1306 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1307 continue 1308 raise plumbing.convert_error_to_porcelain(e) from e 1309 break 1310 1311 resp = models.AccountGroupGetResponse() 1312 resp.account_group = plumbing.convert_account_group_to_porcelain( 1313 plumbing_response.account_group) 1314 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1315 plumbing_response.meta) 1316 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1317 plumbing_response.rate_limit) 1318 return resp 1319 1320 def delete(self, id, timeout=None): 1321 ''' 1322 Delete removes an AccountGroup by ID. 1323 ''' 1324 deadline = None if timeout is None else time.time() + timeout 1325 req = AccountGroupDeleteRequest() 1326 1327 req.id = (id) 1328 tries = 0 1329 plumbing_response = None 1330 while True: 1331 t = None if deadline is None else deadline - time.time() 1332 try: 1333 plumbing_response = self.stub.Delete( 1334 req, 1335 metadata=self.parent.get_metadata('AccountsGroups.Delete', 1336 req), 1337 timeout=t) 1338 except Exception as e: 1339 if self.parent.shouldRetry(tries, e, deadline): 1340 tries += 1 1341 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1342 continue 1343 raise plumbing.convert_error_to_porcelain(e) from e 1344 break 1345 1346 resp = models.AccountGroupDeleteResponse() 1347 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 1348 plumbing_response.meta) 1349 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1350 plumbing_response.rate_limit) 1351 return resp 1352 1353 def list(self, filter, *args, timeout=None): 1354 ''' 1355 List gets a list of AccountGroups matching a given set of criteria. 1356 ''' 1357 deadline = None if timeout is None else time.time() + timeout 1358 req = AccountGroupListRequest() 1359 req.meta.CopyFrom(ListRequestMetadata()) 1360 if self.parent.page_limit > 0: 1361 req.meta.limit = self.parent.page_limit 1362 if self.parent.snapshot_datetime is not None: 1363 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1364 1365 req.filter = plumbing.quote_filter_args(filter, *args) 1366 1367 def generator(svc, req): 1368 tries = 0 1369 while True: 1370 t = None if deadline is None else deadline - time.time() 1371 try: 1372 plumbing_response = svc.stub.List( 1373 req, 1374 metadata=svc.parent.get_metadata( 1375 'AccountsGroups.List', req), 1376 timeout=t) 1377 except Exception as e: 1378 if self.parent.shouldRetry(tries, e, deadline): 1379 tries += 1 1380 time.sleep( 1381 self.parent.exponentialBackoff(tries, deadline)) 1382 continue 1383 raise plumbing.convert_error_to_porcelain(e) from e 1384 tries = 0 1385 for plumbing_item in plumbing_response.account_groups: 1386 yield plumbing.convert_account_group_to_porcelain( 1387 plumbing_item) 1388 if plumbing_response.meta.next_cursor == '': 1389 break 1390 req.meta.cursor = plumbing_response.meta.next_cursor 1391 1392 return generator(self, req) 1393 1394 1395class SnapshotAccountsGroups: 1396 ''' 1397 SnapshotAccountsGroups exposes the read only methods of the AccountsGroups 1398 service for historical queries. 1399 ''' 1400 def __init__(self, accounts_groups): 1401 self.accounts_groups = accounts_groups 1402 1403 def get(self, id, timeout=None): 1404 ''' 1405 Get reads one AccountGroup by ID. 1406 ''' 1407 return self.accounts_groups.get(id, timeout=timeout) 1408 1409 def list(self, filter, *args, timeout=None): 1410 ''' 1411 List gets a list of AccountGroups matching a given set of criteria. 1412 ''' 1413 return self.accounts_groups.list(filter, *args, timeout=timeout) 1414 1415 1416class AccountsGroupsHistory: 1417 ''' 1418 AccountsGroupsHistory records all changes to the state of an AccountGroup. 1419 See `strongdm.models.AccountGroupHistory`. 1420 ''' 1421 def __init__(self, channel, client): 1422 self.parent = client 1423 self.stub = AccountsGroupsHistoryStub(channel) 1424 1425 def list(self, filter, *args, timeout=None): 1426 ''' 1427 List gets a list of AccountGroupHistory records matching a given set of criteria. 1428 ''' 1429 deadline = None if timeout is None else time.time() + timeout 1430 req = AccountGroupHistoryListRequest() 1431 req.meta.CopyFrom(ListRequestMetadata()) 1432 if self.parent.page_limit > 0: 1433 req.meta.limit = self.parent.page_limit 1434 if self.parent.snapshot_datetime is not None: 1435 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1436 1437 req.filter = plumbing.quote_filter_args(filter, *args) 1438 1439 def generator(svc, req): 1440 tries = 0 1441 while True: 1442 t = None if deadline is None else deadline - time.time() 1443 try: 1444 plumbing_response = svc.stub.List( 1445 req, 1446 metadata=svc.parent.get_metadata( 1447 'AccountsGroupsHistory.List', req), 1448 timeout=t) 1449 except Exception as e: 1450 if self.parent.shouldRetry(tries, e, deadline): 1451 tries += 1 1452 time.sleep( 1453 self.parent.exponentialBackoff(tries, deadline)) 1454 continue 1455 raise plumbing.convert_error_to_porcelain(e) from e 1456 tries = 0 1457 for plumbing_item in plumbing_response.history: 1458 yield plumbing.convert_account_group_history_to_porcelain( 1459 plumbing_item) 1460 if plumbing_response.meta.next_cursor == '': 1461 break 1462 req.meta.cursor = plumbing_response.meta.next_cursor 1463 1464 return generator(self, req) 1465 1466 1467class AccountsHistory: 1468 ''' 1469 AccountsHistory records all changes to the state of an Account. 1470 See `strongdm.models.AccountHistory`. 1471 ''' 1472 def __init__(self, channel, client): 1473 self.parent = client 1474 self.stub = AccountsHistoryStub(channel) 1475 1476 def list(self, filter, *args, timeout=None): 1477 ''' 1478 List gets a list of AccountHistory records matching a given set of criteria. 1479 ''' 1480 deadline = None if timeout is None else time.time() + timeout 1481 req = AccountHistoryListRequest() 1482 req.meta.CopyFrom(ListRequestMetadata()) 1483 if self.parent.page_limit > 0: 1484 req.meta.limit = self.parent.page_limit 1485 if self.parent.snapshot_datetime is not None: 1486 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1487 1488 req.filter = plumbing.quote_filter_args(filter, *args) 1489 1490 def generator(svc, req): 1491 tries = 0 1492 while True: 1493 t = None if deadline is None else deadline - time.time() 1494 try: 1495 plumbing_response = svc.stub.List( 1496 req, 1497 metadata=svc.parent.get_metadata( 1498 'AccountsHistory.List', req), 1499 timeout=t) 1500 except Exception as e: 1501 if self.parent.shouldRetry(tries, e, deadline): 1502 tries += 1 1503 time.sleep( 1504 self.parent.exponentialBackoff(tries, deadline)) 1505 continue 1506 raise plumbing.convert_error_to_porcelain(e) from e 1507 tries = 0 1508 for plumbing_item in plumbing_response.history: 1509 yield plumbing.convert_account_history_to_porcelain( 1510 plumbing_item) 1511 if plumbing_response.meta.next_cursor == '': 1512 break 1513 req.meta.cursor = plumbing_response.meta.next_cursor 1514 1515 return generator(self, req) 1516 1517 1518class Activities: 1519 ''' 1520 An Activity is a record of an action taken against a strongDM deployment, e.g. 1521 a user creation, resource deletion, sso configuration change, etc. The Activities 1522 service is read-only. 1523 See `strongdm.models.Activity`. 1524 ''' 1525 def __init__(self, channel, client): 1526 self.parent = client 1527 self.stub = ActivitiesStub(channel) 1528 1529 def get(self, id, timeout=None): 1530 ''' 1531 Get reads one Activity by ID. 1532 ''' 1533 deadline = None if timeout is None else time.time() + timeout 1534 req = ActivityGetRequest() 1535 if self.parent.snapshot_datetime is not None: 1536 req.meta.CopyFrom(GetRequestMetadata()) 1537 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1538 1539 req.id = (id) 1540 tries = 0 1541 plumbing_response = None 1542 while True: 1543 t = None if deadline is None else deadline - time.time() 1544 try: 1545 plumbing_response = self.stub.Get( 1546 req, 1547 metadata=self.parent.get_metadata('Activities.Get', req), 1548 timeout=t) 1549 except Exception as e: 1550 if self.parent.shouldRetry(tries, e, deadline): 1551 tries += 1 1552 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1553 continue 1554 raise plumbing.convert_error_to_porcelain(e) from e 1555 break 1556 1557 resp = models.ActivityGetResponse() 1558 resp.activity = plumbing.convert_activity_to_porcelain( 1559 plumbing_response.activity) 1560 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1561 plumbing_response.meta) 1562 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1563 plumbing_response.rate_limit) 1564 return resp 1565 1566 def list(self, filter, *args, timeout=None): 1567 ''' 1568 List gets a list of Activities matching a given set of criteria. 1569 The 'before' and 'after' filters can be used to control the time 1570 range of the output activities. If not provided, one week of back 1571 of activities will be returned. 1572 ''' 1573 deadline = None if timeout is None else time.time() + timeout 1574 req = ActivityListRequest() 1575 req.meta.CopyFrom(ListRequestMetadata()) 1576 if self.parent.page_limit > 0: 1577 req.meta.limit = self.parent.page_limit 1578 if self.parent.snapshot_datetime is not None: 1579 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1580 1581 req.filter = plumbing.quote_filter_args(filter, *args) 1582 1583 def generator(svc, req): 1584 tries = 0 1585 while True: 1586 t = None if deadline is None else deadline - time.time() 1587 try: 1588 plumbing_response = svc.stub.List( 1589 req, 1590 metadata=svc.parent.get_metadata( 1591 'Activities.List', req), 1592 timeout=t) 1593 except Exception as e: 1594 if self.parent.shouldRetry(tries, e, deadline): 1595 tries += 1 1596 time.sleep( 1597 self.parent.exponentialBackoff(tries, deadline)) 1598 continue 1599 raise plumbing.convert_error_to_porcelain(e) from e 1600 tries = 0 1601 for plumbing_item in plumbing_response.activities: 1602 yield plumbing.convert_activity_to_porcelain(plumbing_item) 1603 if plumbing_response.meta.next_cursor == '': 1604 break 1605 req.meta.cursor = plumbing_response.meta.next_cursor 1606 1607 return generator(self, req) 1608 1609 1610class ApprovalWorkflowApprovers: 1611 ''' 1612 ApprovalWorkflowApprovers link approval workflow approvers to an ApprovalWorkflowStep 1613 See `strongdm.models.ApprovalWorkflowApprover`. 1614 ''' 1615 def __init__(self, channel, client): 1616 self.parent = client 1617 self.stub = ApprovalWorkflowApproversStub(channel) 1618 1619 def create(self, approval_workflow_approver, timeout=None): 1620 ''' 1621 Deprecated: Create creates a new approval workflow approver. 1622 ''' 1623 deadline = None if timeout is None else time.time() + timeout 1624 req = ApprovalWorkflowApproverCreateRequest() 1625 1626 if approval_workflow_approver is not None: 1627 req.approval_workflow_approver.CopyFrom( 1628 plumbing.convert_approval_workflow_approver_to_plumbing( 1629 approval_workflow_approver)) 1630 tries = 0 1631 plumbing_response = None 1632 while True: 1633 t = None if deadline is None else deadline - time.time() 1634 try: 1635 plumbing_response = self.stub.Create( 1636 req, 1637 metadata=self.parent.get_metadata( 1638 'ApprovalWorkflowApprovers.Create', req), 1639 timeout=t) 1640 except Exception as e: 1641 if self.parent.shouldRetry(tries, e, deadline): 1642 tries += 1 1643 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1644 continue 1645 raise plumbing.convert_error_to_porcelain(e) from e 1646 break 1647 1648 resp = models.ApprovalWorkflowApproverCreateResponse() 1649 resp.approval_workflow_approver = plumbing.convert_approval_workflow_approver_to_porcelain( 1650 plumbing_response.approval_workflow_approver) 1651 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1652 plumbing_response.rate_limit) 1653 return resp 1654 1655 def get(self, id, timeout=None): 1656 ''' 1657 Deprecated: Get reads one approval workflow approver by ID. 1658 ''' 1659 deadline = None if timeout is None else time.time() + timeout 1660 req = ApprovalWorkflowApproverGetRequest() 1661 if self.parent.snapshot_datetime is not None: 1662 req.meta.CopyFrom(GetRequestMetadata()) 1663 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1664 1665 req.id = (id) 1666 tries = 0 1667 plumbing_response = None 1668 while True: 1669 t = None if deadline is None else deadline - time.time() 1670 try: 1671 plumbing_response = self.stub.Get( 1672 req, 1673 metadata=self.parent.get_metadata( 1674 'ApprovalWorkflowApprovers.Get', req), 1675 timeout=t) 1676 except Exception as e: 1677 if self.parent.shouldRetry(tries, e, deadline): 1678 tries += 1 1679 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1680 continue 1681 raise plumbing.convert_error_to_porcelain(e) from e 1682 break 1683 1684 resp = models.ApprovalWorkflowApproverGetResponse() 1685 resp.approval_workflow_approver = plumbing.convert_approval_workflow_approver_to_porcelain( 1686 plumbing_response.approval_workflow_approver) 1687 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1688 plumbing_response.meta) 1689 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1690 plumbing_response.rate_limit) 1691 return resp 1692 1693 def delete(self, id, timeout=None): 1694 ''' 1695 Deprecated: Delete deletes an existing approval workflow approver. 1696 ''' 1697 deadline = None if timeout is None else time.time() + timeout 1698 req = ApprovalWorkflowApproverDeleteRequest() 1699 1700 req.id = (id) 1701 tries = 0 1702 plumbing_response = None 1703 while True: 1704 t = None if deadline is None else deadline - time.time() 1705 try: 1706 plumbing_response = self.stub.Delete( 1707 req, 1708 metadata=self.parent.get_metadata( 1709 'ApprovalWorkflowApprovers.Delete', req), 1710 timeout=t) 1711 except Exception as e: 1712 if self.parent.shouldRetry(tries, e, deadline): 1713 tries += 1 1714 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1715 continue 1716 raise plumbing.convert_error_to_porcelain(e) from e 1717 break 1718 1719 resp = models.ApprovalWorkflowApproverDeleteResponse() 1720 resp.id = (plumbing_response.id) 1721 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1722 plumbing_response.rate_limit) 1723 return resp 1724 1725 def list(self, filter, *args, timeout=None): 1726 ''' 1727 Deprecated: Lists existing approval workflow approvers. 1728 ''' 1729 deadline = None if timeout is None else time.time() + timeout 1730 req = ApprovalWorkflowApproverListRequest() 1731 req.meta.CopyFrom(ListRequestMetadata()) 1732 if self.parent.page_limit > 0: 1733 req.meta.limit = self.parent.page_limit 1734 if self.parent.snapshot_datetime is not None: 1735 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1736 1737 req.filter = plumbing.quote_filter_args(filter, *args) 1738 1739 def generator(svc, req): 1740 tries = 0 1741 while True: 1742 t = None if deadline is None else deadline - time.time() 1743 try: 1744 plumbing_response = svc.stub.List( 1745 req, 1746 metadata=svc.parent.get_metadata( 1747 'ApprovalWorkflowApprovers.List', req), 1748 timeout=t) 1749 except Exception as e: 1750 if self.parent.shouldRetry(tries, e, deadline): 1751 tries += 1 1752 time.sleep( 1753 self.parent.exponentialBackoff(tries, deadline)) 1754 continue 1755 raise plumbing.convert_error_to_porcelain(e) from e 1756 tries = 0 1757 for plumbing_item in plumbing_response.approval_workflow_approvers: 1758 yield plumbing.convert_approval_workflow_approver_to_porcelain( 1759 plumbing_item) 1760 if plumbing_response.meta.next_cursor == '': 1761 break 1762 req.meta.cursor = plumbing_response.meta.next_cursor 1763 1764 return generator(self, req) 1765 1766 1767class SnapshotApprovalWorkflowApprovers: 1768 ''' 1769 SnapshotApprovalWorkflowApprovers exposes the read only methods of the ApprovalWorkflowApprovers 1770 service for historical queries. 1771 ''' 1772 def __init__(self, approval_workflow_approvers): 1773 self.approval_workflow_approvers = approval_workflow_approvers 1774 1775 def get(self, id, timeout=None): 1776 ''' 1777 Deprecated: Get reads one approval workflow approver by ID. 1778 ''' 1779 return self.approval_workflow_approvers.get(id, timeout=timeout) 1780 1781 def list(self, filter, *args, timeout=None): 1782 ''' 1783 Deprecated: Lists existing approval workflow approvers. 1784 ''' 1785 return self.approval_workflow_approvers.list(filter, 1786 *args, 1787 timeout=timeout) 1788 1789 1790class ApprovalWorkflowApproversHistory: 1791 ''' 1792 ApprovalWorkflowApproversHistory records all changes to the state of an ApprovalWorkflowApprover. 1793 See `strongdm.models.ApprovalWorkflowApproverHistory`. 1794 ''' 1795 def __init__(self, channel, client): 1796 self.parent = client 1797 self.stub = ApprovalWorkflowApproversHistoryStub(channel) 1798 1799 def list(self, filter, *args, timeout=None): 1800 ''' 1801 List gets a list of ApprovalWorkflowApproverHistory records matching a given set of criteria. 1802 ''' 1803 deadline = None if timeout is None else time.time() + timeout 1804 req = ApprovalWorkflowApproverHistoryListRequest() 1805 req.meta.CopyFrom(ListRequestMetadata()) 1806 if self.parent.page_limit > 0: 1807 req.meta.limit = self.parent.page_limit 1808 if self.parent.snapshot_datetime is not None: 1809 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1810 1811 req.filter = plumbing.quote_filter_args(filter, *args) 1812 1813 def generator(svc, req): 1814 tries = 0 1815 while True: 1816 t = None if deadline is None else deadline - time.time() 1817 try: 1818 plumbing_response = svc.stub.List( 1819 req, 1820 metadata=svc.parent.get_metadata( 1821 'ApprovalWorkflowApproversHistory.List', req), 1822 timeout=t) 1823 except Exception as e: 1824 if self.parent.shouldRetry(tries, e, deadline): 1825 tries += 1 1826 time.sleep( 1827 self.parent.exponentialBackoff(tries, deadline)) 1828 continue 1829 raise plumbing.convert_error_to_porcelain(e) from e 1830 tries = 0 1831 for plumbing_item in plumbing_response.history: 1832 yield plumbing.convert_approval_workflow_approver_history_to_porcelain( 1833 plumbing_item) 1834 if plumbing_response.meta.next_cursor == '': 1835 break 1836 req.meta.cursor = plumbing_response.meta.next_cursor 1837 1838 return generator(self, req) 1839 1840 1841class ApprovalWorkflowSteps: 1842 ''' 1843 ApprovalWorkflowSteps link approval workflow steps to an ApprovalWorkflow 1844 See `strongdm.models.ApprovalWorkflowStep`. 1845 ''' 1846 def __init__(self, channel, client): 1847 self.parent = client 1848 self.stub = ApprovalWorkflowStepsStub(channel) 1849 1850 def create(self, approval_workflow_step, timeout=None): 1851 ''' 1852 Deprecated: Create creates a new approval workflow step. 1853 ''' 1854 deadline = None if timeout is None else time.time() + timeout 1855 req = ApprovalWorkflowStepCreateRequest() 1856 1857 if approval_workflow_step is not None: 1858 req.approval_workflow_step.CopyFrom( 1859 plumbing.convert_approval_workflow_step_to_plumbing( 1860 approval_workflow_step)) 1861 tries = 0 1862 plumbing_response = None 1863 while True: 1864 t = None if deadline is None else deadline - time.time() 1865 try: 1866 plumbing_response = self.stub.Create( 1867 req, 1868 metadata=self.parent.get_metadata( 1869 'ApprovalWorkflowSteps.Create', req), 1870 timeout=t) 1871 except Exception as e: 1872 if self.parent.shouldRetry(tries, e, deadline): 1873 tries += 1 1874 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1875 continue 1876 raise plumbing.convert_error_to_porcelain(e) from e 1877 break 1878 1879 resp = models.ApprovalWorkflowStepCreateResponse() 1880 resp.approval_workflow_step = plumbing.convert_approval_workflow_step_to_porcelain( 1881 plumbing_response.approval_workflow_step) 1882 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1883 plumbing_response.rate_limit) 1884 return resp 1885 1886 def get(self, id, timeout=None): 1887 ''' 1888 Deprecated: Get reads one approval workflow step by ID. 1889 ''' 1890 deadline = None if timeout is None else time.time() + timeout 1891 req = ApprovalWorkflowStepGetRequest() 1892 if self.parent.snapshot_datetime is not None: 1893 req.meta.CopyFrom(GetRequestMetadata()) 1894 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1895 1896 req.id = (id) 1897 tries = 0 1898 plumbing_response = None 1899 while True: 1900 t = None if deadline is None else deadline - time.time() 1901 try: 1902 plumbing_response = self.stub.Get( 1903 req, 1904 metadata=self.parent.get_metadata( 1905 'ApprovalWorkflowSteps.Get', req), 1906 timeout=t) 1907 except Exception as e: 1908 if self.parent.shouldRetry(tries, e, deadline): 1909 tries += 1 1910 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1911 continue 1912 raise plumbing.convert_error_to_porcelain(e) from e 1913 break 1914 1915 resp = models.ApprovalWorkflowStepGetResponse() 1916 resp.approval_workflow_step = plumbing.convert_approval_workflow_step_to_porcelain( 1917 plumbing_response.approval_workflow_step) 1918 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1919 plumbing_response.meta) 1920 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1921 plumbing_response.rate_limit) 1922 return resp 1923 1924 def delete(self, id, timeout=None): 1925 ''' 1926 Deprecated: Delete deletes an existing approval workflow step. 1927 ''' 1928 deadline = None if timeout is None else time.time() + timeout 1929 req = ApprovalWorkflowStepDeleteRequest() 1930 1931 req.id = (id) 1932 tries = 0 1933 plumbing_response = None 1934 while True: 1935 t = None if deadline is None else deadline - time.time() 1936 try: 1937 plumbing_response = self.stub.Delete( 1938 req, 1939 metadata=self.parent.get_metadata( 1940 'ApprovalWorkflowSteps.Delete', req), 1941 timeout=t) 1942 except Exception as e: 1943 if self.parent.shouldRetry(tries, e, deadline): 1944 tries += 1 1945 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1946 continue 1947 raise plumbing.convert_error_to_porcelain(e) from e 1948 break 1949 1950 resp = models.ApprovalWorkflowStepDeleteResponse() 1951 resp.id = (plumbing_response.id) 1952 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1953 plumbing_response.rate_limit) 1954 return resp 1955 1956 def list(self, filter, *args, timeout=None): 1957 ''' 1958 Deprecated: Lists existing approval workflow steps. 1959 ''' 1960 deadline = None if timeout is None else time.time() + timeout 1961 req = ApprovalWorkflowStepListRequest() 1962 req.meta.CopyFrom(ListRequestMetadata()) 1963 if self.parent.page_limit > 0: 1964 req.meta.limit = self.parent.page_limit 1965 if self.parent.snapshot_datetime is not None: 1966 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1967 1968 req.filter = plumbing.quote_filter_args(filter, *args) 1969 1970 def generator(svc, req): 1971 tries = 0 1972 while True: 1973 t = None if deadline is None else deadline - time.time() 1974 try: 1975 plumbing_response = svc.stub.List( 1976 req, 1977 metadata=svc.parent.get_metadata( 1978 'ApprovalWorkflowSteps.List', req), 1979 timeout=t) 1980 except Exception as e: 1981 if self.parent.shouldRetry(tries, e, deadline): 1982 tries += 1 1983 time.sleep( 1984 self.parent.exponentialBackoff(tries, deadline)) 1985 continue 1986 raise plumbing.convert_error_to_porcelain(e) from e 1987 tries = 0 1988 for plumbing_item in plumbing_response.approval_workflow_steps: 1989 yield plumbing.convert_approval_workflow_step_to_porcelain( 1990 plumbing_item) 1991 if plumbing_response.meta.next_cursor == '': 1992 break 1993 req.meta.cursor = plumbing_response.meta.next_cursor 1994 1995 return generator(self, req) 1996 1997 1998class SnapshotApprovalWorkflowSteps: 1999 ''' 2000 SnapshotApprovalWorkflowSteps exposes the read only methods of the ApprovalWorkflowSteps 2001 service for historical queries. 2002 ''' 2003 def __init__(self, approval_workflow_steps): 2004 self.approval_workflow_steps = approval_workflow_steps 2005 2006 def get(self, id, timeout=None): 2007 ''' 2008 Deprecated: Get reads one approval workflow step by ID. 2009 ''' 2010 return self.approval_workflow_steps.get(id, timeout=timeout) 2011 2012 def list(self, filter, *args, timeout=None): 2013 ''' 2014 Deprecated: Lists existing approval workflow steps. 2015 ''' 2016 return self.approval_workflow_steps.list(filter, 2017 *args, 2018 timeout=timeout) 2019 2020 2021class ApprovalWorkflowStepsHistory: 2022 ''' 2023 ApprovalWorkflowStepsHistory records all changes to the state of an ApprovalWorkflowStep. 2024 See `strongdm.models.ApprovalWorkflowStepHistory`. 2025 ''' 2026 def __init__(self, channel, client): 2027 self.parent = client 2028 self.stub = ApprovalWorkflowStepsHistoryStub(channel) 2029 2030 def list(self, filter, *args, timeout=None): 2031 ''' 2032 List gets a list of ApprovalWorkflowStepHistory records matching a given set of criteria. 2033 ''' 2034 deadline = None if timeout is None else time.time() + timeout 2035 req = ApprovalWorkflowStepHistoryListRequest() 2036 req.meta.CopyFrom(ListRequestMetadata()) 2037 if self.parent.page_limit > 0: 2038 req.meta.limit = self.parent.page_limit 2039 if self.parent.snapshot_datetime is not None: 2040 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2041 2042 req.filter = plumbing.quote_filter_args(filter, *args) 2043 2044 def generator(svc, req): 2045 tries = 0 2046 while True: 2047 t = None if deadline is None else deadline - time.time() 2048 try: 2049 plumbing_response = svc.stub.List( 2050 req, 2051 metadata=svc.parent.get_metadata( 2052 'ApprovalWorkflowStepsHistory.List', req), 2053 timeout=t) 2054 except Exception as e: 2055 if self.parent.shouldRetry(tries, e, deadline): 2056 tries += 1 2057 time.sleep( 2058 self.parent.exponentialBackoff(tries, deadline)) 2059 continue 2060 raise plumbing.convert_error_to_porcelain(e) from e 2061 tries = 0 2062 for plumbing_item in plumbing_response.history: 2063 yield plumbing.convert_approval_workflow_step_history_to_porcelain( 2064 plumbing_item) 2065 if plumbing_response.meta.next_cursor == '': 2066 break 2067 req.meta.cursor = plumbing_response.meta.next_cursor 2068 2069 return generator(self, req) 2070 2071 2072class ApprovalWorkflows: 2073 ''' 2074 ApprovalWorkflows are the mechanism by which requests for access can be viewed by authorized 2075 approvers and be approved or denied. 2076 See `strongdm.models.ApprovalWorkflow`. 2077 ''' 2078 def __init__(self, channel, client): 2079 self.parent = client 2080 self.stub = ApprovalWorkflowsStub(channel) 2081 2082 def create(self, approval_workflow, timeout=None): 2083 ''' 2084 Create creates a new approval workflow and requires a name and approval mode for the approval workflow. 2085 ''' 2086 deadline = None if timeout is None else time.time() + timeout 2087 req = ApprovalWorkflowCreateRequest() 2088 2089 if approval_workflow is not None: 2090 req.approval_workflow.CopyFrom( 2091 plumbing.convert_approval_workflow_to_plumbing( 2092 approval_workflow)) 2093 tries = 0 2094 plumbing_response = None 2095 while True: 2096 t = None if deadline is None else deadline - time.time() 2097 try: 2098 plumbing_response = self.stub.Create( 2099 req, 2100 metadata=self.parent.get_metadata( 2101 'ApprovalWorkflows.Create', req), 2102 timeout=t) 2103 except Exception as e: 2104 if self.parent.shouldRetry(tries, e, deadline): 2105 tries += 1 2106 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2107 continue 2108 raise plumbing.convert_error_to_porcelain(e) from e 2109 break 2110 2111 resp = models.ApprovalWorkflowCreateResponse() 2112 resp.approval_workflow = plumbing.convert_approval_workflow_to_porcelain( 2113 plumbing_response.approval_workflow) 2114 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2115 plumbing_response.rate_limit) 2116 return resp 2117 2118 def get(self, id, timeout=None): 2119 ''' 2120 Get reads one approval workflow by ID. 2121 ''' 2122 deadline = None if timeout is None else time.time() + timeout 2123 req = ApprovalWorkflowGetRequest() 2124 if self.parent.snapshot_datetime is not None: 2125 req.meta.CopyFrom(GetRequestMetadata()) 2126 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2127 2128 req.id = (id) 2129 tries = 0 2130 plumbing_response = None 2131 while True: 2132 t = None if deadline is None else deadline - time.time() 2133 try: 2134 plumbing_response = self.stub.Get( 2135 req, 2136 metadata=self.parent.get_metadata('ApprovalWorkflows.Get', 2137 req), 2138 timeout=t) 2139 except Exception as e: 2140 if self.parent.shouldRetry(tries, e, deadline): 2141 tries += 1 2142 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2143 continue 2144 raise plumbing.convert_error_to_porcelain(e) from e 2145 break 2146 2147 resp = models.ApprovalWorkflowGetResponse() 2148 resp.approval_workflow = plumbing.convert_approval_workflow_to_porcelain( 2149 plumbing_response.approval_workflow) 2150 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2151 plumbing_response.meta) 2152 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2153 plumbing_response.rate_limit) 2154 return resp 2155 2156 def delete(self, id, timeout=None): 2157 ''' 2158 Delete deletes an existing approval workflow. 2159 ''' 2160 deadline = None if timeout is None else time.time() + timeout 2161 req = ApprovalWorkflowDeleteRequest() 2162 2163 req.id = (id) 2164 tries = 0 2165 plumbing_response = None 2166 while True: 2167 t = None if deadline is None else deadline - time.time() 2168 try: 2169 plumbing_response = self.stub.Delete( 2170 req, 2171 metadata=self.parent.get_metadata( 2172 'ApprovalWorkflows.Delete', req), 2173 timeout=t) 2174 except Exception as e: 2175 if self.parent.shouldRetry(tries, e, deadline): 2176 tries += 1 2177 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2178 continue 2179 raise plumbing.convert_error_to_porcelain(e) from e 2180 break 2181 2182 resp = models.ApprovalWorkflowDeleteResponse() 2183 resp.id = (plumbing_response.id) 2184 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2185 plumbing_response.rate_limit) 2186 return resp 2187 2188 def update(self, approval_workflow, timeout=None): 2189 ''' 2190 Update updates an existing approval workflow. 2191 ''' 2192 deadline = None if timeout is None else time.time() + timeout 2193 req = ApprovalWorkflowUpdateRequest() 2194 2195 if approval_workflow is not None: 2196 req.approval_workflow.CopyFrom( 2197 plumbing.convert_approval_workflow_to_plumbing( 2198 approval_workflow)) 2199 tries = 0 2200 plumbing_response = None 2201 while True: 2202 t = None if deadline is None else deadline - time.time() 2203 try: 2204 plumbing_response = self.stub.Update( 2205 req, 2206 metadata=self.parent.get_metadata( 2207 'ApprovalWorkflows.Update', req), 2208 timeout=t) 2209 except Exception as e: 2210 if self.parent.shouldRetry(tries, e, deadline): 2211 tries += 1 2212 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2213 continue 2214 raise plumbing.convert_error_to_porcelain(e) from e 2215 break 2216 2217 resp = models.ApprovalWorkflowUpdateResponse() 2218 resp.approval_workflow = plumbing.convert_approval_workflow_to_porcelain( 2219 plumbing_response.approval_workflow) 2220 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2221 plumbing_response.rate_limit) 2222 return resp 2223 2224 def list(self, filter, *args, timeout=None): 2225 ''' 2226 Lists existing approval workflows. 2227 ''' 2228 deadline = None if timeout is None else time.time() + timeout 2229 req = ApprovalWorkflowListRequest() 2230 req.meta.CopyFrom(ListRequestMetadata()) 2231 if self.parent.page_limit > 0: 2232 req.meta.limit = self.parent.page_limit 2233 if self.parent.snapshot_datetime is not None: 2234 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2235 2236 req.filter = plumbing.quote_filter_args(filter, *args) 2237 2238 def generator(svc, req): 2239 tries = 0 2240 while True: 2241 t = None if deadline is None else deadline - time.time() 2242 try: 2243 plumbing_response = svc.stub.List( 2244 req, 2245 metadata=svc.parent.get_metadata( 2246 'ApprovalWorkflows.List', req), 2247 timeout=t) 2248 except Exception as e: 2249 if self.parent.shouldRetry(tries, e, deadline): 2250 tries += 1 2251 time.sleep( 2252 self.parent.exponentialBackoff(tries, deadline)) 2253 continue 2254 raise plumbing.convert_error_to_porcelain(e) from e 2255 tries = 0 2256 for plumbing_item in plumbing_response.approval_workflows: 2257 yield plumbing.convert_approval_workflow_to_porcelain( 2258 plumbing_item) 2259 if plumbing_response.meta.next_cursor == '': 2260 break 2261 req.meta.cursor = plumbing_response.meta.next_cursor 2262 2263 return generator(self, req) 2264 2265 2266class SnapshotApprovalWorkflows: 2267 ''' 2268 SnapshotApprovalWorkflows exposes the read only methods of the ApprovalWorkflows 2269 service for historical queries. 2270 ''' 2271 def __init__(self, approval_workflows): 2272 self.approval_workflows = approval_workflows 2273 2274 def get(self, id, timeout=None): 2275 ''' 2276 Get reads one approval workflow by ID. 2277 ''' 2278 return self.approval_workflows.get(id, timeout=timeout) 2279 2280 def list(self, filter, *args, timeout=None): 2281 ''' 2282 Lists existing approval workflows. 2283 ''' 2284 return self.approval_workflows.list(filter, *args, timeout=timeout) 2285 2286 2287class ApprovalWorkflowsHistory: 2288 ''' 2289 ApprovalWorkflowsHistory records all changes to the state of an ApprovalWorkflow. 2290 See `strongdm.models.ApprovalWorkflowHistory`. 2291 ''' 2292 def __init__(self, channel, client): 2293 self.parent = client 2294 self.stub = ApprovalWorkflowsHistoryStub(channel) 2295 2296 def list(self, filter, *args, timeout=None): 2297 ''' 2298 List gets a list of ApprovalWorkflowHistory records matching a given set of criteria. 2299 ''' 2300 deadline = None if timeout is None else time.time() + timeout 2301 req = ApprovalWorkflowHistoryListRequest() 2302 req.meta.CopyFrom(ListRequestMetadata()) 2303 if self.parent.page_limit > 0: 2304 req.meta.limit = self.parent.page_limit 2305 if self.parent.snapshot_datetime is not None: 2306 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2307 2308 req.filter = plumbing.quote_filter_args(filter, *args) 2309 2310 def generator(svc, req): 2311 tries = 0 2312 while True: 2313 t = None if deadline is None else deadline - time.time() 2314 try: 2315 plumbing_response = svc.stub.List( 2316 req, 2317 metadata=svc.parent.get_metadata( 2318 'ApprovalWorkflowsHistory.List', req), 2319 timeout=t) 2320 except Exception as e: 2321 if self.parent.shouldRetry(tries, e, deadline): 2322 tries += 1 2323 time.sleep( 2324 self.parent.exponentialBackoff(tries, deadline)) 2325 continue 2326 raise plumbing.convert_error_to_porcelain(e) from e 2327 tries = 0 2328 for plumbing_item in plumbing_response.history: 2329 yield plumbing.convert_approval_workflow_history_to_porcelain( 2330 plumbing_item) 2331 if plumbing_response.meta.next_cursor == '': 2332 break 2333 req.meta.cursor = plumbing_response.meta.next_cursor 2334 2335 return generator(self, req) 2336 2337 2338class ControlPanel: 2339 ''' 2340 ControlPanel contains all administrative controls. 2341 ''' 2342 def __init__(self, channel, client): 2343 self.parent = client 2344 self.stub = ControlPanelStub(channel) 2345 2346 def get_sshca_public_key(self, timeout=None): 2347 ''' 2348 GetSSHCAPublicKey retrieves the SSH CA public key. 2349 ''' 2350 deadline = None if timeout is None else time.time() + timeout 2351 req = ControlPanelGetSSHCAPublicKeyRequest() 2352 2353 tries = 0 2354 plumbing_response = None 2355 while True: 2356 t = None if deadline is None else deadline - time.time() 2357 try: 2358 plumbing_response = self.stub.GetSSHCAPublicKey( 2359 req, 2360 metadata=self.parent.get_metadata( 2361 'ControlPanel.GetSSHCAPublicKey', req), 2362 timeout=t) 2363 except Exception as e: 2364 if self.parent.shouldRetry(tries, e, deadline): 2365 tries += 1 2366 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2367 continue 2368 raise plumbing.convert_error_to_porcelain(e) from e 2369 break 2370 2371 resp = models.ControlPanelGetSSHCAPublicKeyResponse() 2372 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2373 plumbing_response.meta) 2374 resp.public_key = (plumbing_response.public_key) 2375 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2376 plumbing_response.rate_limit) 2377 return resp 2378 2379 def get_rdpca_public_key(self, timeout=None): 2380 ''' 2381 GetRDPCAPublicKey retrieves the RDP CA public key. 2382 ''' 2383 deadline = None if timeout is None else time.time() + timeout 2384 req = ControlPanelGetRDPCAPublicKeyRequest() 2385 2386 tries = 0 2387 plumbing_response = None 2388 while True: 2389 t = None if deadline is None else deadline - time.time() 2390 try: 2391 plumbing_response = self.stub.GetRDPCAPublicKey( 2392 req, 2393 metadata=self.parent.get_metadata( 2394 'ControlPanel.GetRDPCAPublicKey', req), 2395 timeout=t) 2396 except Exception as e: 2397 if self.parent.shouldRetry(tries, e, deadline): 2398 tries += 1 2399 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2400 continue 2401 raise plumbing.convert_error_to_porcelain(e) from e 2402 break 2403 2404 resp = models.ControlPanelGetRDPCAPublicKeyResponse() 2405 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2406 plumbing_response.meta) 2407 resp.public_key = (plumbing_response.public_key) 2408 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2409 plumbing_response.rate_limit) 2410 return resp 2411 2412 def get_org_url_info(self, timeout=None): 2413 ''' 2414 GetOrgURLInfo retrieves URL configuration for the organization. 2415 This includes the base URL, website subdomain, OIDC issuer URL, and SAML metadata URL. 2416 ''' 2417 deadline = None if timeout is None else time.time() + timeout 2418 req = ControlPanelGetOrgURLInfoRequest() 2419 2420 tries = 0 2421 plumbing_response = None 2422 while True: 2423 t = None if deadline is None else deadline - time.time() 2424 try: 2425 plumbing_response = self.stub.GetOrgURLInfo( 2426 req, 2427 metadata=self.parent.get_metadata( 2428 'ControlPanel.GetOrgURLInfo', req), 2429 timeout=t) 2430 except Exception as e: 2431 if self.parent.shouldRetry(tries, e, deadline): 2432 tries += 1 2433 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2434 continue 2435 raise plumbing.convert_error_to_porcelain(e) from e 2436 break 2437 2438 resp = models.ControlPanelGetOrgURLInfoResponse() 2439 resp.base_url = (plumbing_response.base_url) 2440 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2441 plumbing_response.meta) 2442 resp.oidc_issuer_url = (plumbing_response.oidc_issuer_url) 2443 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2444 plumbing_response.rate_limit) 2445 resp.saml_metadata_url = (plumbing_response.saml_metadata_url) 2446 resp.websites_subdomain = (plumbing_response.websites_subdomain) 2447 return resp 2448 2449 def verify_jwt(self, token, timeout=None): 2450 ''' 2451 VerifyJWT reports whether the given JWT token (x-sdm-token) is valid. 2452 ''' 2453 deadline = None if timeout is None else time.time() + timeout 2454 req = ControlPanelVerifyJWTRequest() 2455 2456 req.token = (token) 2457 tries = 0 2458 plumbing_response = None 2459 while True: 2460 t = None if deadline is None else deadline - time.time() 2461 try: 2462 plumbing_response = self.stub.VerifyJWT( 2463 req, 2464 metadata=self.parent.get_metadata('ControlPanel.VerifyJWT', 2465 req), 2466 timeout=t) 2467 except Exception as e: 2468 if self.parent.shouldRetry(tries, e, deadline): 2469 tries += 1 2470 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2471 continue 2472 raise plumbing.convert_error_to_porcelain(e) from e 2473 break 2474 2475 resp = models.ControlPanelVerifyJWTResponse() 2476 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2477 plumbing_response.meta) 2478 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2479 plumbing_response.rate_limit) 2480 resp.valid = (plumbing_response.valid) 2481 return resp 2482 2483 2484class DiscoveryConnectors: 2485 ''' 2486 A Discovery Connector is a configuration object for performing Resource 2487 Scans in remote systems such as AWS, GCP, Azure, and other systems. 2488 See: 2489 `strongdm.models.AWSConnector` 2490 `strongdm.models.AzureConnector` 2491 `strongdm.models.GCPConnector` 2492 ''' 2493 def __init__(self, channel, client): 2494 self.parent = client 2495 self.stub = DiscoveryConnectorsStub(channel) 2496 2497 def create(self, connector, timeout=None): 2498 ''' 2499 Create adds a new Connector. 2500 ''' 2501 deadline = None if timeout is None else time.time() + timeout 2502 req = ConnectorCreateRequest() 2503 2504 if connector is not None: 2505 req.connector.CopyFrom( 2506 plumbing.convert_connector_to_plumbing(connector)) 2507 tries = 0 2508 plumbing_response = None 2509 while True: 2510 t = None if deadline is None else deadline - time.time() 2511 try: 2512 plumbing_response = self.stub.Create( 2513 req, 2514 metadata=self.parent.get_metadata( 2515 'DiscoveryConnectors.Create', req), 2516 timeout=t) 2517 except Exception as e: 2518 if self.parent.shouldRetry(tries, e, deadline): 2519 tries += 1 2520 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2521 continue 2522 raise plumbing.convert_error_to_porcelain(e) from e 2523 break 2524 2525 resp = models.ConnectorCreateResponse() 2526 resp.connector = plumbing.convert_connector_to_porcelain( 2527 plumbing_response.connector) 2528 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2529 plumbing_response.rate_limit) 2530 return resp 2531 2532 def get(self, id, timeout=None): 2533 ''' 2534 Get reads one Connector by ID 2535 ''' 2536 deadline = None if timeout is None else time.time() + timeout 2537 req = ConnectorGetRequest() 2538 if self.parent.snapshot_datetime is not None: 2539 req.meta.CopyFrom(GetRequestMetadata()) 2540 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2541 2542 req.id = (id) 2543 tries = 0 2544 plumbing_response = None 2545 while True: 2546 t = None if deadline is None else deadline - time.time() 2547 try: 2548 plumbing_response = self.stub.Get( 2549 req, 2550 metadata=self.parent.get_metadata( 2551 'DiscoveryConnectors.Get', req), 2552 timeout=t) 2553 except Exception as e: 2554 if self.parent.shouldRetry(tries, e, deadline): 2555 tries += 1 2556 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2557 continue 2558 raise plumbing.convert_error_to_porcelain(e) from e 2559 break 2560 2561 resp = models.ConnectorGetResponse() 2562 resp.connector = plumbing.convert_connector_to_porcelain( 2563 plumbing_response.connector) 2564 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2565 plumbing_response.meta) 2566 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2567 plumbing_response.rate_limit) 2568 return resp 2569 2570 def update(self, connector, timeout=None): 2571 ''' 2572 Update replaces all the fields of a Connector by ID. 2573 ''' 2574 deadline = None if timeout is None else time.time() + timeout 2575 req = ConnectorUpdateRequest() 2576 2577 if connector is not None: 2578 req.connector.CopyFrom( 2579 plumbing.convert_connector_to_plumbing(connector)) 2580 tries = 0 2581 plumbing_response = None 2582 while True: 2583 t = None if deadline is None else deadline - time.time() 2584 try: 2585 plumbing_response = self.stub.Update( 2586 req, 2587 metadata=self.parent.get_metadata( 2588 'DiscoveryConnectors.Update', req), 2589 timeout=t) 2590 except Exception as e: 2591 if self.parent.shouldRetry(tries, e, deadline): 2592 tries += 1 2593 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2594 continue 2595 raise plumbing.convert_error_to_porcelain(e) from e 2596 break 2597 2598 resp = models.ConnectorUpdateResponse() 2599 resp.connector = plumbing.convert_connector_to_porcelain( 2600 plumbing_response.connector) 2601 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2602 plumbing_response.rate_limit) 2603 return resp 2604 2605 def delete(self, id, timeout=None): 2606 ''' 2607 Delete removes a Connector by ID. 2608 ''' 2609 deadline = None if timeout is None else time.time() + timeout 2610 req = ConnectorDeleteRequest() 2611 2612 req.id = (id) 2613 tries = 0 2614 plumbing_response = None 2615 while True: 2616 t = None if deadline is None else deadline - time.time() 2617 try: 2618 plumbing_response = self.stub.Delete( 2619 req, 2620 metadata=self.parent.get_metadata( 2621 'DiscoveryConnectors.Delete', req), 2622 timeout=t) 2623 except Exception as e: 2624 if self.parent.shouldRetry(tries, e, deadline): 2625 tries += 1 2626 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2627 continue 2628 raise plumbing.convert_error_to_porcelain(e) from e 2629 break 2630 2631 resp = models.ConnectorDeleteResponse() 2632 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 2633 plumbing_response.meta) 2634 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2635 plumbing_response.rate_limit) 2636 return resp 2637 2638 def list(self, filter, *args, timeout=None): 2639 ''' 2640 List gets a list of Connectors matching a given set of criteria. 2641 ''' 2642 deadline = None if timeout is None else time.time() + timeout 2643 req = ConnectorListRequest() 2644 req.meta.CopyFrom(ListRequestMetadata()) 2645 if self.parent.page_limit > 0: 2646 req.meta.limit = self.parent.page_limit 2647 if self.parent.snapshot_datetime is not None: 2648 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2649 2650 req.filter = plumbing.quote_filter_args(filter, *args) 2651 2652 def generator(svc, req): 2653 tries = 0 2654 while True: 2655 t = None if deadline is None else deadline - time.time() 2656 try: 2657 plumbing_response = svc.stub.List( 2658 req, 2659 metadata=svc.parent.get_metadata( 2660 'DiscoveryConnectors.List', req), 2661 timeout=t) 2662 except Exception as e: 2663 if self.parent.shouldRetry(tries, e, deadline): 2664 tries += 1 2665 time.sleep( 2666 self.parent.exponentialBackoff(tries, deadline)) 2667 continue 2668 raise plumbing.convert_error_to_porcelain(e) from e 2669 tries = 0 2670 for plumbing_item in plumbing_response.connectors: 2671 yield plumbing.convert_connector_to_porcelain( 2672 plumbing_item) 2673 if plumbing_response.meta.next_cursor == '': 2674 break 2675 req.meta.cursor = plumbing_response.meta.next_cursor 2676 2677 return generator(self, req) 2678 2679 2680class SnapshotDiscoveryConnectors: 2681 ''' 2682 SnapshotDiscoveryConnectors exposes the read only methods of the DiscoveryConnectors 2683 service for historical queries. 2684 ''' 2685 def __init__(self, discovery_connectors): 2686 self.discovery_connectors = discovery_connectors 2687 2688 def get(self, id, timeout=None): 2689 ''' 2690 Get reads one Connector by ID 2691 ''' 2692 return self.discovery_connectors.get(id, timeout=timeout) 2693 2694 def list(self, filter, *args, timeout=None): 2695 ''' 2696 List gets a list of Connectors matching a given set of criteria. 2697 ''' 2698 return self.discovery_connectors.list(filter, *args, timeout=timeout) 2699 2700 2701class GrantedAccountEntitlements: 2702 ''' 2703 GrantedAccountEntitlements enumerates the resources to which an account has been granted access. 2704 The GrantedAccountEntitlements service is read-only. 2705 See `strongdm.models.GrantedAccountEntitlement`. 2706 ''' 2707 def __init__(self, channel, client): 2708 self.parent = client 2709 self.stub = GrantedAccountEntitlementsStub(channel) 2710 2711 def list(self, account_id, filter, *args, timeout=None): 2712 ''' 2713 List gets a list of GrantedAccountEntitlement records matching a given set of criteria. 2714 ''' 2715 deadline = None if timeout is None else time.time() + timeout 2716 req = GrantedAccountEntitlementListRequest() 2717 req.meta.CopyFrom(ListRequestMetadata()) 2718 if self.parent.page_limit > 0: 2719 req.meta.limit = self.parent.page_limit 2720 if self.parent.snapshot_datetime is not None: 2721 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2722 2723 req.account_id = (account_id) 2724 req.filter = plumbing.quote_filter_args(filter, *args) 2725 2726 def generator(svc, req): 2727 tries = 0 2728 while True: 2729 t = None if deadline is None else deadline - time.time() 2730 try: 2731 plumbing_response = svc.stub.List( 2732 req, 2733 metadata=svc.parent.get_metadata( 2734 'GrantedAccountEntitlements.List', req), 2735 timeout=t) 2736 except Exception as e: 2737 if self.parent.shouldRetry(tries, e, deadline): 2738 tries += 1 2739 time.sleep( 2740 self.parent.exponentialBackoff(tries, deadline)) 2741 continue 2742 raise plumbing.convert_error_to_porcelain(e) from e 2743 tries = 0 2744 for plumbing_item in plumbing_response.granted_account_entitlements: 2745 yield plumbing.convert_granted_account_entitlement_to_porcelain( 2746 plumbing_item) 2747 if plumbing_response.meta.next_cursor == '': 2748 break 2749 req.meta.cursor = plumbing_response.meta.next_cursor 2750 2751 return generator(self, req) 2752 2753 2754class SnapshotGrantedAccountEntitlements: 2755 ''' 2756 SnapshotGrantedAccountEntitlements exposes the read only methods of the GrantedAccountEntitlements 2757 service for historical queries. 2758 ''' 2759 def __init__(self, granted_account_entitlements): 2760 self.granted_account_entitlements = granted_account_entitlements 2761 2762 def list(self, account_id, filter, *args, timeout=None): 2763 ''' 2764 List gets a list of GrantedAccountEntitlement records matching a given set of criteria. 2765 ''' 2766 return self.granted_account_entitlements.list(account_id, 2767 filter, 2768 *args, 2769 timeout=timeout) 2770 2771 2772class GrantedResourceEntitlements: 2773 ''' 2774 GrantedResourceEntitlements enumerates the accounts that have been granted access to a given resource. 2775 The GrantedResourceEntitlements service is read-only. 2776 See `strongdm.models.GrantedResourceEntitlement`. 2777 ''' 2778 def __init__(self, channel, client): 2779 self.parent = client 2780 self.stub = GrantedResourceEntitlementsStub(channel) 2781 2782 def list(self, resource_id, filter, *args, timeout=None): 2783 ''' 2784 List gets a list of GrantedResourceEntitlement records matching a given set of criteria. 2785 ''' 2786 deadline = None if timeout is None else time.time() + timeout 2787 req = GrantedResourceEntitlementListRequest() 2788 req.meta.CopyFrom(ListRequestMetadata()) 2789 if self.parent.page_limit > 0: 2790 req.meta.limit = self.parent.page_limit 2791 if self.parent.snapshot_datetime is not None: 2792 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2793 2794 req.resource_id = (resource_id) 2795 req.filter = plumbing.quote_filter_args(filter, *args) 2796 2797 def generator(svc, req): 2798 tries = 0 2799 while True: 2800 t = None if deadline is None else deadline - time.time() 2801 try: 2802 plumbing_response = svc.stub.List( 2803 req, 2804 metadata=svc.parent.get_metadata( 2805 'GrantedResourceEntitlements.List', req), 2806 timeout=t) 2807 except Exception as e: 2808 if self.parent.shouldRetry(tries, e, deadline): 2809 tries += 1 2810 time.sleep( 2811 self.parent.exponentialBackoff(tries, deadline)) 2812 continue 2813 raise plumbing.convert_error_to_porcelain(e) from e 2814 tries = 0 2815 for plumbing_item in plumbing_response.granted_resource_entitlements: 2816 yield plumbing.convert_granted_resource_entitlement_to_porcelain( 2817 plumbing_item) 2818 if plumbing_response.meta.next_cursor == '': 2819 break 2820 req.meta.cursor = plumbing_response.meta.next_cursor 2821 2822 return generator(self, req) 2823 2824 2825class SnapshotGrantedResourceEntitlements: 2826 ''' 2827 SnapshotGrantedResourceEntitlements exposes the read only methods of the GrantedResourceEntitlements 2828 service for historical queries. 2829 ''' 2830 def __init__(self, granted_resource_entitlements): 2831 self.granted_resource_entitlements = granted_resource_entitlements 2832 2833 def list(self, resource_id, filter, *args, timeout=None): 2834 ''' 2835 List gets a list of GrantedResourceEntitlement records matching a given set of criteria. 2836 ''' 2837 return self.granted_resource_entitlements.list(resource_id, 2838 filter, 2839 *args, 2840 timeout=timeout) 2841 2842 2843class GrantedRoleEntitlements: 2844 ''' 2845 GrantedRoleEntitlements enumerates the resources to which a role grants access. 2846 The GrantedRoleEntitlements service is read-only. 2847 See `strongdm.models.GrantedRoleEntitlement`. 2848 ''' 2849 def __init__(self, channel, client): 2850 self.parent = client 2851 self.stub = GrantedRoleEntitlementsStub(channel) 2852 2853 def list(self, role_id, filter, *args, timeout=None): 2854 ''' 2855 List gets a list of GrantedRoleEntitlement records matching a given set of criteria. 2856 ''' 2857 deadline = None if timeout is None else time.time() + timeout 2858 req = GrantedRoleEntitlementListRequest() 2859 req.meta.CopyFrom(ListRequestMetadata()) 2860 if self.parent.page_limit > 0: 2861 req.meta.limit = self.parent.page_limit 2862 if self.parent.snapshot_datetime is not None: 2863 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2864 2865 req.role_id = (role_id) 2866 req.filter = plumbing.quote_filter_args(filter, *args) 2867 2868 def generator(svc, req): 2869 tries = 0 2870 while True: 2871 t = None if deadline is None else deadline - time.time() 2872 try: 2873 plumbing_response = svc.stub.List( 2874 req, 2875 metadata=svc.parent.get_metadata( 2876 'GrantedRoleEntitlements.List', req), 2877 timeout=t) 2878 except Exception as e: 2879 if self.parent.shouldRetry(tries, e, deadline): 2880 tries += 1 2881 time.sleep( 2882 self.parent.exponentialBackoff(tries, deadline)) 2883 continue 2884 raise plumbing.convert_error_to_porcelain(e) from e 2885 tries = 0 2886 for plumbing_item in plumbing_response.granted_role_entitlements: 2887 yield plumbing.convert_granted_role_entitlement_to_porcelain( 2888 plumbing_item) 2889 if plumbing_response.meta.next_cursor == '': 2890 break 2891 req.meta.cursor = plumbing_response.meta.next_cursor 2892 2893 return generator(self, req) 2894 2895 2896class SnapshotGrantedRoleEntitlements: 2897 ''' 2898 SnapshotGrantedRoleEntitlements exposes the read only methods of the GrantedRoleEntitlements 2899 service for historical queries. 2900 ''' 2901 def __init__(self, granted_role_entitlements): 2902 self.granted_role_entitlements = granted_role_entitlements 2903 2904 def list(self, role_id, filter, *args, timeout=None): 2905 ''' 2906 List gets a list of GrantedRoleEntitlement records matching a given set of criteria. 2907 ''' 2908 return self.granted_role_entitlements.list(role_id, 2909 filter, 2910 *args, 2911 timeout=timeout) 2912 2913 2914class Roles: 2915 ''' 2916 A Role has a list of access rules which determine which Resources the members 2917 of the Role have access to. An Account can be a member of multiple Roles via 2918 AccountAttachments. 2919 See `strongdm.models.Role`. 2920 ''' 2921 def __init__(self, channel, client): 2922 self.parent = client 2923 self.stub = RolesStub(channel) 2924 2925 def create(self, role, timeout=None): 2926 ''' 2927 Create registers a new Role. 2928 ''' 2929 deadline = None if timeout is None else time.time() + timeout 2930 req = RoleCreateRequest() 2931 2932 if role is not None: 2933 req.role.CopyFrom(plumbing.convert_role_to_plumbing(role)) 2934 tries = 0 2935 plumbing_response = None 2936 while True: 2937 t = None if deadline is None else deadline - time.time() 2938 try: 2939 plumbing_response = self.stub.Create( 2940 req, 2941 metadata=self.parent.get_metadata('Roles.Create', req), 2942 timeout=t) 2943 except Exception as e: 2944 if self.parent.shouldRetry(tries, e, deadline): 2945 tries += 1 2946 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2947 continue 2948 raise plumbing.convert_error_to_porcelain(e) from e 2949 break 2950 2951 resp = models.RoleCreateResponse() 2952 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 2953 plumbing_response.meta) 2954 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2955 plumbing_response.rate_limit) 2956 resp.role = plumbing.convert_role_to_porcelain(plumbing_response.role) 2957 return resp 2958 2959 def get(self, id, timeout=None): 2960 ''' 2961 Get reads one Role by ID. 2962 ''' 2963 deadline = None if timeout is None else time.time() + timeout 2964 req = RoleGetRequest() 2965 if self.parent.snapshot_datetime is not None: 2966 req.meta.CopyFrom(GetRequestMetadata()) 2967 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2968 2969 req.id = (id) 2970 tries = 0 2971 plumbing_response = None 2972 while True: 2973 t = None if deadline is None else deadline - time.time() 2974 try: 2975 plumbing_response = self.stub.Get( 2976 req, 2977 metadata=self.parent.get_metadata('Roles.Get', req), 2978 timeout=t) 2979 except Exception as e: 2980 if self.parent.shouldRetry(tries, e, deadline): 2981 tries += 1 2982 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2983 continue 2984 raise plumbing.convert_error_to_porcelain(e) from e 2985 break 2986 2987 resp = models.RoleGetResponse() 2988 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2989 plumbing_response.meta) 2990 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2991 plumbing_response.rate_limit) 2992 resp.role = plumbing.convert_role_to_porcelain(plumbing_response.role) 2993 return resp 2994 2995 def update(self, role, timeout=None): 2996 ''' 2997 Update replaces all the fields of a Role by ID. 2998 ''' 2999 deadline = None if timeout is None else time.time() + timeout 3000 req = RoleUpdateRequest() 3001 3002 if role is not None: 3003 req.role.CopyFrom(plumbing.convert_role_to_plumbing(role)) 3004 tries = 0 3005 plumbing_response = None 3006 while True: 3007 t = None if deadline is None else deadline - time.time() 3008 try: 3009 plumbing_response = self.stub.Update( 3010 req, 3011 metadata=self.parent.get_metadata('Roles.Update', req), 3012 timeout=t) 3013 except Exception as e: 3014 if self.parent.shouldRetry(tries, e, deadline): 3015 tries += 1 3016 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3017 continue 3018 raise plumbing.convert_error_to_porcelain(e) from e 3019 break 3020 3021 resp = models.RoleUpdateResponse() 3022 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 3023 plumbing_response.meta) 3024 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3025 plumbing_response.rate_limit) 3026 resp.role = plumbing.convert_role_to_porcelain(plumbing_response.role) 3027 return resp 3028 3029 def delete(self, id, timeout=None): 3030 ''' 3031 Delete removes a Role by ID. 3032 ''' 3033 deadline = None if timeout is None else time.time() + timeout 3034 req = RoleDeleteRequest() 3035 3036 req.id = (id) 3037 tries = 0 3038 plumbing_response = None 3039 while True: 3040 t = None if deadline is None else deadline - time.time() 3041 try: 3042 plumbing_response = self.stub.Delete( 3043 req, 3044 metadata=self.parent.get_metadata('Roles.Delete', req), 3045 timeout=t) 3046 except Exception as e: 3047 if self.parent.shouldRetry(tries, e, deadline): 3048 tries += 1 3049 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3050 continue 3051 raise plumbing.convert_error_to_porcelain(e) from e 3052 break 3053 3054 resp = models.RoleDeleteResponse() 3055 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3056 plumbing_response.meta) 3057 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3058 plumbing_response.rate_limit) 3059 return resp 3060 3061 def list(self, filter, *args, timeout=None): 3062 ''' 3063 List gets a list of Roles matching a given set of criteria. 3064 ''' 3065 deadline = None if timeout is None else time.time() + timeout 3066 req = RoleListRequest() 3067 req.meta.CopyFrom(ListRequestMetadata()) 3068 if self.parent.page_limit > 0: 3069 req.meta.limit = self.parent.page_limit 3070 if self.parent.snapshot_datetime is not None: 3071 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3072 3073 req.filter = plumbing.quote_filter_args(filter, *args) 3074 3075 def generator(svc, req): 3076 tries = 0 3077 while True: 3078 t = None if deadline is None else deadline - time.time() 3079 try: 3080 plumbing_response = svc.stub.List( 3081 req, 3082 metadata=svc.parent.get_metadata('Roles.List', req), 3083 timeout=t) 3084 except Exception as e: 3085 if self.parent.shouldRetry(tries, e, deadline): 3086 tries += 1 3087 time.sleep( 3088 self.parent.exponentialBackoff(tries, deadline)) 3089 continue 3090 raise plumbing.convert_error_to_porcelain(e) from e 3091 tries = 0 3092 for plumbing_item in plumbing_response.roles: 3093 yield plumbing.convert_role_to_porcelain(plumbing_item) 3094 if plumbing_response.meta.next_cursor == '': 3095 break 3096 req.meta.cursor = plumbing_response.meta.next_cursor 3097 3098 return generator(self, req) 3099 3100 3101class SnapshotRoles: 3102 ''' 3103 SnapshotRoles exposes the read only methods of the Roles 3104 service for historical queries. 3105 ''' 3106 def __init__(self, roles): 3107 self.roles = roles 3108 3109 def get(self, id, timeout=None): 3110 ''' 3111 Get reads one Role by ID. 3112 ''' 3113 return self.roles.get(id, timeout=timeout) 3114 3115 def list(self, filter, *args, timeout=None): 3116 ''' 3117 List gets a list of Roles matching a given set of criteria. 3118 ''' 3119 return self.roles.list(filter, *args, timeout=timeout) 3120 3121 3122class Groups: 3123 ''' 3124 A Group is a set of principals. 3125 See `strongdm.models.Group`. 3126 ''' 3127 def __init__(self, channel, client): 3128 self.parent = client 3129 self.stub = GroupsStub(channel) 3130 3131 def create(self, group, timeout=None): 3132 ''' 3133 Create registers a new Group. 3134 ''' 3135 deadline = None if timeout is None else time.time() + timeout 3136 req = GroupCreateRequest() 3137 3138 if group is not None: 3139 req.group.CopyFrom(plumbing.convert_group_to_plumbing(group)) 3140 tries = 0 3141 plumbing_response = None 3142 while True: 3143 t = None if deadline is None else deadline - time.time() 3144 try: 3145 plumbing_response = self.stub.Create( 3146 req, 3147 metadata=self.parent.get_metadata('Groups.Create', req), 3148 timeout=t) 3149 except Exception as e: 3150 if self.parent.shouldRetry(tries, e, deadline): 3151 tries += 1 3152 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3153 continue 3154 raise plumbing.convert_error_to_porcelain(e) from e 3155 break 3156 3157 resp = models.GroupCreateResponse() 3158 resp.group = plumbing.convert_group_to_porcelain( 3159 plumbing_response.group) 3160 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3161 plumbing_response.rate_limit) 3162 return resp 3163 3164 def create_from_roles(self, role_ids, commit, timeout=None): 3165 deadline = None if timeout is None else time.time() + timeout 3166 req = GroupCreateFromRolesRequest() 3167 3168 req.role_ids.extend((role_ids)) 3169 req.commit = (commit) 3170 tries = 0 3171 plumbing_response = None 3172 while True: 3173 t = None if deadline is None else deadline - time.time() 3174 try: 3175 plumbing_response = self.stub.CreateFromRoles( 3176 req, 3177 metadata=self.parent.get_metadata('Groups.CreateFromRoles', 3178 req), 3179 timeout=t) 3180 except Exception as e: 3181 if self.parent.shouldRetry(tries, e, deadline): 3182 tries += 1 3183 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3184 continue 3185 raise plumbing.convert_error_to_porcelain(e) from e 3186 break 3187 3188 resp = models.GroupCreateFromRolesResponse() 3189 resp.group_from_role = plumbing.convert_repeated_group_from_role_to_porcelain( 3190 plumbing_response.group_from_role) 3191 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3192 plumbing_response.rate_limit) 3193 return resp 3194 3195 def get(self, id, timeout=None): 3196 ''' 3197 Get reads one Group by ID. 3198 ''' 3199 deadline = None if timeout is None else time.time() + timeout 3200 req = GroupGetRequest() 3201 if self.parent.snapshot_datetime is not None: 3202 req.meta.CopyFrom(GetRequestMetadata()) 3203 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3204 3205 req.id = (id) 3206 tries = 0 3207 plumbing_response = None 3208 while True: 3209 t = None if deadline is None else deadline - time.time() 3210 try: 3211 plumbing_response = self.stub.Get( 3212 req, 3213 metadata=self.parent.get_metadata('Groups.Get', req), 3214 timeout=t) 3215 except Exception as e: 3216 if self.parent.shouldRetry(tries, e, deadline): 3217 tries += 1 3218 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3219 continue 3220 raise plumbing.convert_error_to_porcelain(e) from e 3221 break 3222 3223 resp = models.GroupGetResponse() 3224 resp.group = plumbing.convert_group_to_porcelain( 3225 plumbing_response.group) 3226 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3227 plumbing_response.meta) 3228 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3229 plumbing_response.rate_limit) 3230 return resp 3231 3232 def update(self, group, timeout=None): 3233 ''' 3234 Update replaces all the fields of a Group by ID. 3235 ''' 3236 deadline = None if timeout is None else time.time() + timeout 3237 req = GroupUpdateRequest() 3238 3239 if group is not None: 3240 req.group.CopyFrom(plumbing.convert_group_to_plumbing(group)) 3241 tries = 0 3242 plumbing_response = None 3243 while True: 3244 t = None if deadline is None else deadline - time.time() 3245 try: 3246 plumbing_response = self.stub.Update( 3247 req, 3248 metadata=self.parent.get_metadata('Groups.Update', req), 3249 timeout=t) 3250 except Exception as e: 3251 if self.parent.shouldRetry(tries, e, deadline): 3252 tries += 1 3253 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3254 continue 3255 raise plumbing.convert_error_to_porcelain(e) from e 3256 break 3257 3258 resp = models.GroupUpdateResponse() 3259 resp.group = plumbing.convert_group_to_porcelain( 3260 plumbing_response.group) 3261 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3262 plumbing_response.rate_limit) 3263 return resp 3264 3265 def delete(self, id, timeout=None): 3266 ''' 3267 Delete removes a Group by ID. 3268 ''' 3269 deadline = None if timeout is None else time.time() + timeout 3270 req = GroupDeleteRequest() 3271 3272 req.id = (id) 3273 tries = 0 3274 plumbing_response = None 3275 while True: 3276 t = None if deadline is None else deadline - time.time() 3277 try: 3278 plumbing_response = self.stub.Delete( 3279 req, 3280 metadata=self.parent.get_metadata('Groups.Delete', req), 3281 timeout=t) 3282 except Exception as e: 3283 if self.parent.shouldRetry(tries, e, deadline): 3284 tries += 1 3285 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3286 continue 3287 raise plumbing.convert_error_to_porcelain(e) from e 3288 break 3289 3290 resp = models.GroupDeleteResponse() 3291 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3292 plumbing_response.meta) 3293 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3294 plumbing_response.rate_limit) 3295 return resp 3296 3297 def list(self, filter, *args, timeout=None): 3298 ''' 3299 List gets a list of Groups matching a given set of criteria. 3300 ''' 3301 deadline = None if timeout is None else time.time() + timeout 3302 req = GroupListRequest() 3303 req.meta.CopyFrom(ListRequestMetadata()) 3304 if self.parent.page_limit > 0: 3305 req.meta.limit = self.parent.page_limit 3306 if self.parent.snapshot_datetime is not None: 3307 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3308 3309 req.filter = plumbing.quote_filter_args(filter, *args) 3310 3311 def generator(svc, req): 3312 tries = 0 3313 while True: 3314 t = None if deadline is None else deadline - time.time() 3315 try: 3316 plumbing_response = svc.stub.List( 3317 req, 3318 metadata=svc.parent.get_metadata('Groups.List', req), 3319 timeout=t) 3320 except Exception as e: 3321 if self.parent.shouldRetry(tries, e, deadline): 3322 tries += 1 3323 time.sleep( 3324 self.parent.exponentialBackoff(tries, deadline)) 3325 continue 3326 raise plumbing.convert_error_to_porcelain(e) from e 3327 tries = 0 3328 for plumbing_item in plumbing_response.groups: 3329 yield plumbing.convert_group_to_porcelain(plumbing_item) 3330 if plumbing_response.meta.next_cursor == '': 3331 break 3332 req.meta.cursor = plumbing_response.meta.next_cursor 3333 3334 return generator(self, req) 3335 3336 3337class SnapshotGroups: 3338 ''' 3339 SnapshotGroups exposes the read only methods of the Groups 3340 service for historical queries. 3341 ''' 3342 def __init__(self, groups): 3343 self.groups = groups 3344 3345 def get(self, id, timeout=None): 3346 ''' 3347 Get reads one Group by ID. 3348 ''' 3349 return self.groups.get(id, timeout=timeout) 3350 3351 def list(self, filter, *args, timeout=None): 3352 ''' 3353 List gets a list of Groups matching a given set of criteria. 3354 ''' 3355 return self.groups.list(filter, *args, timeout=timeout) 3356 3357 3358class GroupsHistory: 3359 ''' 3360 GroupsHistory records all changes to the state of a Group. 3361 See `strongdm.models.GroupHistory`. 3362 ''' 3363 def __init__(self, channel, client): 3364 self.parent = client 3365 self.stub = GroupsHistoryStub(channel) 3366 3367 def list(self, filter, *args, timeout=None): 3368 ''' 3369 List gets a list of GroupHistory records matching a given set of criteria. 3370 ''' 3371 deadline = None if timeout is None else time.time() + timeout 3372 req = GroupHistoryListRequest() 3373 req.meta.CopyFrom(ListRequestMetadata()) 3374 if self.parent.page_limit > 0: 3375 req.meta.limit = self.parent.page_limit 3376 if self.parent.snapshot_datetime is not None: 3377 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3378 3379 req.filter = plumbing.quote_filter_args(filter, *args) 3380 3381 def generator(svc, req): 3382 tries = 0 3383 while True: 3384 t = None if deadline is None else deadline - time.time() 3385 try: 3386 plumbing_response = svc.stub.List( 3387 req, 3388 metadata=svc.parent.get_metadata( 3389 'GroupsHistory.List', req), 3390 timeout=t) 3391 except Exception as e: 3392 if self.parent.shouldRetry(tries, e, deadline): 3393 tries += 1 3394 time.sleep( 3395 self.parent.exponentialBackoff(tries, deadline)) 3396 continue 3397 raise plumbing.convert_error_to_porcelain(e) from e 3398 tries = 0 3399 for plumbing_item in plumbing_response.history: 3400 yield plumbing.convert_group_history_to_porcelain( 3401 plumbing_item) 3402 if plumbing_response.meta.next_cursor == '': 3403 break 3404 req.meta.cursor = plumbing_response.meta.next_cursor 3405 3406 return generator(self, req) 3407 3408 3409class GroupsRoles: 3410 ''' 3411 A GroupRole is an assignment of a Group to a Role. 3412 See `strongdm.models.GroupRole`. 3413 ''' 3414 def __init__(self, channel, client): 3415 self.parent = client 3416 self.stub = GroupsRolesStub(channel) 3417 3418 def create(self, group_role, timeout=None): 3419 ''' 3420 Create registers a new GroupRole. 3421 ''' 3422 deadline = None if timeout is None else time.time() + timeout 3423 req = GroupRoleCreateRequest() 3424 3425 if group_role is not None: 3426 req.group_role.CopyFrom( 3427 plumbing.convert_group_role_to_plumbing(group_role)) 3428 tries = 0 3429 plumbing_response = None 3430 while True: 3431 t = None if deadline is None else deadline - time.time() 3432 try: 3433 plumbing_response = self.stub.Create( 3434 req, 3435 metadata=self.parent.get_metadata('GroupsRoles.Create', 3436 req), 3437 timeout=t) 3438 except Exception as e: 3439 if self.parent.shouldRetry(tries, e, deadline): 3440 tries += 1 3441 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3442 continue 3443 raise plumbing.convert_error_to_porcelain(e) from e 3444 break 3445 3446 resp = models.GroupRoleCreateResponse() 3447 resp.group_role = plumbing.convert_group_role_to_porcelain( 3448 plumbing_response.group_role) 3449 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3450 plumbing_response.rate_limit) 3451 return resp 3452 3453 def get(self, id, timeout=None): 3454 ''' 3455 Get reads one GroupRole by ID. 3456 ''' 3457 deadline = None if timeout is None else time.time() + timeout 3458 req = GroupRoleGetRequest() 3459 if self.parent.snapshot_datetime is not None: 3460 req.meta.CopyFrom(GetRequestMetadata()) 3461 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3462 3463 req.id = (id) 3464 tries = 0 3465 plumbing_response = None 3466 while True: 3467 t = None if deadline is None else deadline - time.time() 3468 try: 3469 plumbing_response = self.stub.Get( 3470 req, 3471 metadata=self.parent.get_metadata('GroupsRoles.Get', req), 3472 timeout=t) 3473 except Exception as e: 3474 if self.parent.shouldRetry(tries, e, deadline): 3475 tries += 1 3476 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3477 continue 3478 raise plumbing.convert_error_to_porcelain(e) from e 3479 break 3480 3481 resp = models.GroupRoleGetResponse() 3482 resp.group_role = plumbing.convert_group_role_to_porcelain( 3483 plumbing_response.group_role) 3484 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3485 plumbing_response.meta) 3486 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3487 plumbing_response.rate_limit) 3488 return resp 3489 3490 def delete(self, id, timeout=None): 3491 ''' 3492 Delete removes a GroupRole by ID. 3493 ''' 3494 deadline = None if timeout is None else time.time() + timeout 3495 req = GroupRoleDeleteRequest() 3496 3497 req.id = (id) 3498 tries = 0 3499 plumbing_response = None 3500 while True: 3501 t = None if deadline is None else deadline - time.time() 3502 try: 3503 plumbing_response = self.stub.Delete( 3504 req, 3505 metadata=self.parent.get_metadata('GroupsRoles.Delete', 3506 req), 3507 timeout=t) 3508 except Exception as e: 3509 if self.parent.shouldRetry(tries, e, deadline): 3510 tries += 1 3511 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3512 continue 3513 raise plumbing.convert_error_to_porcelain(e) from e 3514 break 3515 3516 resp = models.GroupRoleDeleteResponse() 3517 resp.group_role = plumbing.convert_group_role_to_porcelain( 3518 plumbing_response.group_role) 3519 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3520 plumbing_response.meta) 3521 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3522 plumbing_response.rate_limit) 3523 return resp 3524 3525 def list(self, filter, *args, timeout=None): 3526 ''' 3527 List gets a list of GroupRoles matching a given set of criteria. 3528 ''' 3529 deadline = None if timeout is None else time.time() + timeout 3530 req = GroupRoleListRequest() 3531 req.meta.CopyFrom(ListRequestMetadata()) 3532 if self.parent.page_limit > 0: 3533 req.meta.limit = self.parent.page_limit 3534 if self.parent.snapshot_datetime is not None: 3535 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3536 3537 req.filter = plumbing.quote_filter_args(filter, *args) 3538 3539 def generator(svc, req): 3540 tries = 0 3541 while True: 3542 t = None if deadline is None else deadline - time.time() 3543 try: 3544 plumbing_response = svc.stub.List( 3545 req, 3546 metadata=svc.parent.get_metadata( 3547 'GroupsRoles.List', req), 3548 timeout=t) 3549 except Exception as e: 3550 if self.parent.shouldRetry(tries, e, deadline): 3551 tries += 1 3552 time.sleep( 3553 self.parent.exponentialBackoff(tries, deadline)) 3554 continue 3555 raise plumbing.convert_error_to_porcelain(e) from e 3556 tries = 0 3557 for plumbing_item in plumbing_response.groups_roles: 3558 yield plumbing.convert_group_role_to_porcelain( 3559 plumbing_item) 3560 if plumbing_response.meta.next_cursor == '': 3561 break 3562 req.meta.cursor = plumbing_response.meta.next_cursor 3563 3564 return generator(self, req) 3565 3566 3567class SnapshotGroupsRoles: 3568 ''' 3569 SnapshotGroupsRoles exposes the read only methods of the GroupsRoles 3570 service for historical queries. 3571 ''' 3572 def __init__(self, groups_roles): 3573 self.groups_roles = groups_roles 3574 3575 def get(self, id, timeout=None): 3576 ''' 3577 Get reads one GroupRole by ID. 3578 ''' 3579 return self.groups_roles.get(id, timeout=timeout) 3580 3581 def list(self, filter, *args, timeout=None): 3582 ''' 3583 List gets a list of GroupRoles matching a given set of criteria. 3584 ''' 3585 return self.groups_roles.list(filter, *args, timeout=timeout) 3586 3587 3588class GroupsRolesHistory: 3589 ''' 3590 GroupsRolesHistory records all changes to the state of a GroupRole. 3591 See `strongdm.models.GroupRoleHistory`. 3592 ''' 3593 def __init__(self, channel, client): 3594 self.parent = client 3595 self.stub = GroupsRolesHistoryStub(channel) 3596 3597 def list(self, filter, *args, timeout=None): 3598 ''' 3599 List gets a list of GroupRoleHistory records matching a given set of criteria. 3600 ''' 3601 deadline = None if timeout is None else time.time() + timeout 3602 req = GroupRoleHistoryListRequest() 3603 req.meta.CopyFrom(ListRequestMetadata()) 3604 if self.parent.page_limit > 0: 3605 req.meta.limit = self.parent.page_limit 3606 if self.parent.snapshot_datetime is not None: 3607 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3608 3609 req.filter = plumbing.quote_filter_args(filter, *args) 3610 3611 def generator(svc, req): 3612 tries = 0 3613 while True: 3614 t = None if deadline is None else deadline - time.time() 3615 try: 3616 plumbing_response = svc.stub.List( 3617 req, 3618 metadata=svc.parent.get_metadata( 3619 'GroupsRolesHistory.List', req), 3620 timeout=t) 3621 except Exception as e: 3622 if self.parent.shouldRetry(tries, e, deadline): 3623 tries += 1 3624 time.sleep( 3625 self.parent.exponentialBackoff(tries, deadline)) 3626 continue 3627 raise plumbing.convert_error_to_porcelain(e) from e 3628 tries = 0 3629 for plumbing_item in plumbing_response.history: 3630 yield plumbing.convert_group_role_history_to_porcelain( 3631 plumbing_item) 3632 if plumbing_response.meta.next_cursor == '': 3633 break 3634 req.meta.cursor = plumbing_response.meta.next_cursor 3635 3636 return generator(self, req) 3637 3638 3639class HealthChecks: 3640 ''' 3641 HealthChecks lists the last healthcheck between each node and resource. 3642 Note the unconventional capitalization here is to prevent having a collision with GRPC 3643 See `strongdm.models.Healthcheck`. 3644 ''' 3645 def __init__(self, channel, client): 3646 self.parent = client 3647 self.stub = HealthChecksStub(channel) 3648 3649 def list(self, filter, *args, timeout=None): 3650 ''' 3651 List gets a list of Healthchecks matching a given set of criteria. 3652 ''' 3653 deadline = None if timeout is None else time.time() + timeout 3654 req = HealthcheckListRequest() 3655 req.meta.CopyFrom(ListRequestMetadata()) 3656 if self.parent.page_limit > 0: 3657 req.meta.limit = self.parent.page_limit 3658 if self.parent.snapshot_datetime is not None: 3659 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3660 3661 req.filter = plumbing.quote_filter_args(filter, *args) 3662 3663 def generator(svc, req): 3664 tries = 0 3665 while True: 3666 t = None if deadline is None else deadline - time.time() 3667 try: 3668 plumbing_response = svc.stub.List( 3669 req, 3670 metadata=svc.parent.get_metadata( 3671 'HealthChecks.List', req), 3672 timeout=t) 3673 except Exception as e: 3674 if self.parent.shouldRetry(tries, e, deadline): 3675 tries += 1 3676 time.sleep( 3677 self.parent.exponentialBackoff(tries, deadline)) 3678 continue 3679 raise plumbing.convert_error_to_porcelain(e) from e 3680 tries = 0 3681 for plumbing_item in plumbing_response.healthchecks: 3682 yield plumbing.convert_healthcheck_to_porcelain( 3683 plumbing_item) 3684 if plumbing_response.meta.next_cursor == '': 3685 break 3686 req.meta.cursor = plumbing_response.meta.next_cursor 3687 3688 return generator(self, req) 3689 3690 3691class IdentityAliases: 3692 ''' 3693 IdentityAliases assign an alias to an account within an IdentitySet. 3694 The alias is used as the username when connecting to a identity supported resource. 3695 See `strongdm.models.IdentityAlias`. 3696 ''' 3697 def __init__(self, channel, client): 3698 self.parent = client 3699 self.stub = IdentityAliasesStub(channel) 3700 3701 def create(self, identity_alias, timeout=None): 3702 ''' 3703 Create registers a new IdentityAlias. 3704 ''' 3705 deadline = None if timeout is None else time.time() + timeout 3706 req = IdentityAliasCreateRequest() 3707 3708 if identity_alias is not None: 3709 req.identity_alias.CopyFrom( 3710 plumbing.convert_identity_alias_to_plumbing(identity_alias)) 3711 tries = 0 3712 plumbing_response = None 3713 while True: 3714 t = None if deadline is None else deadline - time.time() 3715 try: 3716 plumbing_response = self.stub.Create( 3717 req, 3718 metadata=self.parent.get_metadata('IdentityAliases.Create', 3719 req), 3720 timeout=t) 3721 except Exception as e: 3722 if self.parent.shouldRetry(tries, e, deadline): 3723 tries += 1 3724 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3725 continue 3726 raise plumbing.convert_error_to_porcelain(e) from e 3727 break 3728 3729 resp = models.IdentityAliasCreateResponse() 3730 resp.identity_alias = plumbing.convert_identity_alias_to_porcelain( 3731 plumbing_response.identity_alias) 3732 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 3733 plumbing_response.meta) 3734 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3735 plumbing_response.rate_limit) 3736 return resp 3737 3738 def get(self, id, timeout=None): 3739 ''' 3740 Get reads one IdentityAlias by ID. 3741 ''' 3742 deadline = None if timeout is None else time.time() + timeout 3743 req = IdentityAliasGetRequest() 3744 if self.parent.snapshot_datetime is not None: 3745 req.meta.CopyFrom(GetRequestMetadata()) 3746 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3747 3748 req.id = (id) 3749 tries = 0 3750 plumbing_response = None 3751 while True: 3752 t = None if deadline is None else deadline - time.time() 3753 try: 3754 plumbing_response = self.stub.Get( 3755 req, 3756 metadata=self.parent.get_metadata('IdentityAliases.Get', 3757 req), 3758 timeout=t) 3759 except Exception as e: 3760 if self.parent.shouldRetry(tries, e, deadline): 3761 tries += 1 3762 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3763 continue 3764 raise plumbing.convert_error_to_porcelain(e) from e 3765 break 3766 3767 resp = models.IdentityAliasGetResponse() 3768 resp.identity_alias = plumbing.convert_identity_alias_to_porcelain( 3769 plumbing_response.identity_alias) 3770 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3771 plumbing_response.meta) 3772 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3773 plumbing_response.rate_limit) 3774 return resp 3775 3776 def update(self, identity_alias, timeout=None): 3777 ''' 3778 Update replaces all the fields of a IdentityAlias by ID. 3779 ''' 3780 deadline = None if timeout is None else time.time() + timeout 3781 req = IdentityAliasUpdateRequest() 3782 3783 if identity_alias is not None: 3784 req.identity_alias.CopyFrom( 3785 plumbing.convert_identity_alias_to_plumbing(identity_alias)) 3786 tries = 0 3787 plumbing_response = None 3788 while True: 3789 t = None if deadline is None else deadline - time.time() 3790 try: 3791 plumbing_response = self.stub.Update( 3792 req, 3793 metadata=self.parent.get_metadata('IdentityAliases.Update', 3794 req), 3795 timeout=t) 3796 except Exception as e: 3797 if self.parent.shouldRetry(tries, e, deadline): 3798 tries += 1 3799 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3800 continue 3801 raise plumbing.convert_error_to_porcelain(e) from e 3802 break 3803 3804 resp = models.IdentityAliasUpdateResponse() 3805 resp.identity_alias = plumbing.convert_identity_alias_to_porcelain( 3806 plumbing_response.identity_alias) 3807 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 3808 plumbing_response.meta) 3809 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3810 plumbing_response.rate_limit) 3811 return resp 3812 3813 def delete(self, id, timeout=None): 3814 ''' 3815 Delete removes a IdentityAlias by ID. 3816 ''' 3817 deadline = None if timeout is None else time.time() + timeout 3818 req = IdentityAliasDeleteRequest() 3819 3820 req.id = (id) 3821 tries = 0 3822 plumbing_response = None 3823 while True: 3824 t = None if deadline is None else deadline - time.time() 3825 try: 3826 plumbing_response = self.stub.Delete( 3827 req, 3828 metadata=self.parent.get_metadata('IdentityAliases.Delete', 3829 req), 3830 timeout=t) 3831 except Exception as e: 3832 if self.parent.shouldRetry(tries, e, deadline): 3833 tries += 1 3834 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3835 continue 3836 raise plumbing.convert_error_to_porcelain(e) from e 3837 break 3838 3839 resp = models.IdentityAliasDeleteResponse() 3840 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3841 plumbing_response.meta) 3842 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3843 plumbing_response.rate_limit) 3844 return resp 3845 3846 def list(self, filter, *args, timeout=None): 3847 ''' 3848 List gets a list of IdentityAliases matching a given set of criteria. 3849 ''' 3850 deadline = None if timeout is None else time.time() + timeout 3851 req = IdentityAliasListRequest() 3852 req.meta.CopyFrom(ListRequestMetadata()) 3853 if self.parent.page_limit > 0: 3854 req.meta.limit = self.parent.page_limit 3855 if self.parent.snapshot_datetime is not None: 3856 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3857 3858 req.filter = plumbing.quote_filter_args(filter, *args) 3859 3860 def generator(svc, req): 3861 tries = 0 3862 while True: 3863 t = None if deadline is None else deadline - time.time() 3864 try: 3865 plumbing_response = svc.stub.List( 3866 req, 3867 metadata=svc.parent.get_metadata( 3868 'IdentityAliases.List', req), 3869 timeout=t) 3870 except Exception as e: 3871 if self.parent.shouldRetry(tries, e, deadline): 3872 tries += 1 3873 time.sleep( 3874 self.parent.exponentialBackoff(tries, deadline)) 3875 continue 3876 raise plumbing.convert_error_to_porcelain(e) from e 3877 tries = 0 3878 for plumbing_item in plumbing_response.identity_aliases: 3879 yield plumbing.convert_identity_alias_to_porcelain( 3880 plumbing_item) 3881 if plumbing_response.meta.next_cursor == '': 3882 break 3883 req.meta.cursor = plumbing_response.meta.next_cursor 3884 3885 return generator(self, req) 3886 3887 3888class SnapshotIdentityAliases: 3889 ''' 3890 SnapshotIdentityAliases exposes the read only methods of the IdentityAliases 3891 service for historical queries. 3892 ''' 3893 def __init__(self, identity_aliases): 3894 self.identity_aliases = identity_aliases 3895 3896 def get(self, id, timeout=None): 3897 ''' 3898 Get reads one IdentityAlias by ID. 3899 ''' 3900 return self.identity_aliases.get(id, timeout=timeout) 3901 3902 def list(self, filter, *args, timeout=None): 3903 ''' 3904 List gets a list of IdentityAliases matching a given set of criteria. 3905 ''' 3906 return self.identity_aliases.list(filter, *args, timeout=timeout) 3907 3908 3909class IdentityAliasesHistory: 3910 ''' 3911 IdentityAliasesHistory records all changes to the state of a IdentityAlias. 3912 See `strongdm.models.IdentityAliasHistory`. 3913 ''' 3914 def __init__(self, channel, client): 3915 self.parent = client 3916 self.stub = IdentityAliasesHistoryStub(channel) 3917 3918 def list(self, filter, *args, timeout=None): 3919 ''' 3920 List gets a list of IdentityAliasHistory records matching a given set of criteria. 3921 ''' 3922 deadline = None if timeout is None else time.time() + timeout 3923 req = IdentityAliasHistoryListRequest() 3924 req.meta.CopyFrom(ListRequestMetadata()) 3925 if self.parent.page_limit > 0: 3926 req.meta.limit = self.parent.page_limit 3927 if self.parent.snapshot_datetime is not None: 3928 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3929 3930 req.filter = plumbing.quote_filter_args(filter, *args) 3931 3932 def generator(svc, req): 3933 tries = 0 3934 while True: 3935 t = None if deadline is None else deadline - time.time() 3936 try: 3937 plumbing_response = svc.stub.List( 3938 req, 3939 metadata=svc.parent.get_metadata( 3940 'IdentityAliasesHistory.List', req), 3941 timeout=t) 3942 except Exception as e: 3943 if self.parent.shouldRetry(tries, e, deadline): 3944 tries += 1 3945 time.sleep( 3946 self.parent.exponentialBackoff(tries, deadline)) 3947 continue 3948 raise plumbing.convert_error_to_porcelain(e) from e 3949 tries = 0 3950 for plumbing_item in plumbing_response.history: 3951 yield plumbing.convert_identity_alias_history_to_porcelain( 3952 plumbing_item) 3953 if plumbing_response.meta.next_cursor == '': 3954 break 3955 req.meta.cursor = plumbing_response.meta.next_cursor 3956 3957 return generator(self, req) 3958 3959 3960class IdentitySets: 3961 ''' 3962 A IdentitySet is a named grouping of Identity Aliases for Accounts. 3963 An Account's relationship to a IdentitySet is defined via IdentityAlias objects. 3964 See `strongdm.models.IdentitySet`. 3965 ''' 3966 def __init__(self, channel, client): 3967 self.parent = client 3968 self.stub = IdentitySetsStub(channel) 3969 3970 def create(self, identity_set, timeout=None): 3971 ''' 3972 Create registers a new IdentitySet. 3973 ''' 3974 deadline = None if timeout is None else time.time() + timeout 3975 req = IdentitySetCreateRequest() 3976 3977 if identity_set is not None: 3978 req.identity_set.CopyFrom( 3979 plumbing.convert_identity_set_to_plumbing(identity_set)) 3980 tries = 0 3981 plumbing_response = None 3982 while True: 3983 t = None if deadline is None else deadline - time.time() 3984 try: 3985 plumbing_response = self.stub.Create( 3986 req, 3987 metadata=self.parent.get_metadata('IdentitySets.Create', 3988 req), 3989 timeout=t) 3990 except Exception as e: 3991 if self.parent.shouldRetry(tries, e, deadline): 3992 tries += 1 3993 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3994 continue 3995 raise plumbing.convert_error_to_porcelain(e) from e 3996 break 3997 3998 resp = models.IdentitySetCreateResponse() 3999 resp.identity_set = plumbing.convert_identity_set_to_porcelain( 4000 plumbing_response.identity_set) 4001 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4002 plumbing_response.meta) 4003 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4004 plumbing_response.rate_limit) 4005 return resp 4006 4007 def get(self, id, timeout=None): 4008 ''' 4009 Get reads one IdentitySet by ID. 4010 ''' 4011 deadline = None if timeout is None else time.time() + timeout 4012 req = IdentitySetGetRequest() 4013 if self.parent.snapshot_datetime is not None: 4014 req.meta.CopyFrom(GetRequestMetadata()) 4015 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4016 4017 req.id = (id) 4018 tries = 0 4019 plumbing_response = None 4020 while True: 4021 t = None if deadline is None else deadline - time.time() 4022 try: 4023 plumbing_response = self.stub.Get( 4024 req, 4025 metadata=self.parent.get_metadata('IdentitySets.Get', req), 4026 timeout=t) 4027 except Exception as e: 4028 if self.parent.shouldRetry(tries, e, deadline): 4029 tries += 1 4030 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4031 continue 4032 raise plumbing.convert_error_to_porcelain(e) from e 4033 break 4034 4035 resp = models.IdentitySetGetResponse() 4036 resp.identity_set = plumbing.convert_identity_set_to_porcelain( 4037 plumbing_response.identity_set) 4038 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4039 plumbing_response.meta) 4040 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4041 plumbing_response.rate_limit) 4042 return resp 4043 4044 def update(self, identity_set, timeout=None): 4045 ''' 4046 Update replaces all the fields of a IdentitySet by ID. 4047 ''' 4048 deadline = None if timeout is None else time.time() + timeout 4049 req = IdentitySetUpdateRequest() 4050 4051 if identity_set is not None: 4052 req.identity_set.CopyFrom( 4053 plumbing.convert_identity_set_to_plumbing(identity_set)) 4054 tries = 0 4055 plumbing_response = None 4056 while True: 4057 t = None if deadline is None else deadline - time.time() 4058 try: 4059 plumbing_response = self.stub.Update( 4060 req, 4061 metadata=self.parent.get_metadata('IdentitySets.Update', 4062 req), 4063 timeout=t) 4064 except Exception as e: 4065 if self.parent.shouldRetry(tries, e, deadline): 4066 tries += 1 4067 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4068 continue 4069 raise plumbing.convert_error_to_porcelain(e) from e 4070 break 4071 4072 resp = models.IdentitySetUpdateResponse() 4073 resp.identity_set = plumbing.convert_identity_set_to_porcelain( 4074 plumbing_response.identity_set) 4075 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 4076 plumbing_response.meta) 4077 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4078 plumbing_response.rate_limit) 4079 return resp 4080 4081 def delete(self, id, timeout=None): 4082 ''' 4083 Delete removes a IdentitySet by ID. 4084 ''' 4085 deadline = None if timeout is None else time.time() + timeout 4086 req = IdentitySetDeleteRequest() 4087 4088 req.id = (id) 4089 tries = 0 4090 plumbing_response = None 4091 while True: 4092 t = None if deadline is None else deadline - time.time() 4093 try: 4094 plumbing_response = self.stub.Delete( 4095 req, 4096 metadata=self.parent.get_metadata('IdentitySets.Delete', 4097 req), 4098 timeout=t) 4099 except Exception as e: 4100 if self.parent.shouldRetry(tries, e, deadline): 4101 tries += 1 4102 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4103 continue 4104 raise plumbing.convert_error_to_porcelain(e) from e 4105 break 4106 4107 resp = models.IdentitySetDeleteResponse() 4108 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 4109 plumbing_response.meta) 4110 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4111 plumbing_response.rate_limit) 4112 return resp 4113 4114 def list(self, filter, *args, timeout=None): 4115 ''' 4116 List gets a list of IdentitySets matching a given set of criteria. 4117 ''' 4118 deadline = None if timeout is None else time.time() + timeout 4119 req = IdentitySetListRequest() 4120 req.meta.CopyFrom(ListRequestMetadata()) 4121 if self.parent.page_limit > 0: 4122 req.meta.limit = self.parent.page_limit 4123 if self.parent.snapshot_datetime is not None: 4124 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4125 4126 req.filter = plumbing.quote_filter_args(filter, *args) 4127 4128 def generator(svc, req): 4129 tries = 0 4130 while True: 4131 t = None if deadline is None else deadline - time.time() 4132 try: 4133 plumbing_response = svc.stub.List( 4134 req, 4135 metadata=svc.parent.get_metadata( 4136 'IdentitySets.List', req), 4137 timeout=t) 4138 except Exception as e: 4139 if self.parent.shouldRetry(tries, e, deadline): 4140 tries += 1 4141 time.sleep( 4142 self.parent.exponentialBackoff(tries, deadline)) 4143 continue 4144 raise plumbing.convert_error_to_porcelain(e) from e 4145 tries = 0 4146 for plumbing_item in plumbing_response.identity_sets: 4147 yield plumbing.convert_identity_set_to_porcelain( 4148 plumbing_item) 4149 if plumbing_response.meta.next_cursor == '': 4150 break 4151 req.meta.cursor = plumbing_response.meta.next_cursor 4152 4153 return generator(self, req) 4154 4155 4156class SnapshotIdentitySets: 4157 ''' 4158 SnapshotIdentitySets exposes the read only methods of the IdentitySets 4159 service for historical queries. 4160 ''' 4161 def __init__(self, identity_sets): 4162 self.identity_sets = identity_sets 4163 4164 def get(self, id, timeout=None): 4165 ''' 4166 Get reads one IdentitySet by ID. 4167 ''' 4168 return self.identity_sets.get(id, timeout=timeout) 4169 4170 def list(self, filter, *args, timeout=None): 4171 ''' 4172 List gets a list of IdentitySets matching a given set of criteria. 4173 ''' 4174 return self.identity_sets.list(filter, *args, timeout=timeout) 4175 4176 4177class IdentitySetsHistory: 4178 ''' 4179 IdentitySetsHistory records all changes to the state of a IdentitySet. 4180 See `strongdm.models.IdentitySetHistory`. 4181 ''' 4182 def __init__(self, channel, client): 4183 self.parent = client 4184 self.stub = IdentitySetsHistoryStub(channel) 4185 4186 def list(self, filter, *args, timeout=None): 4187 ''' 4188 List gets a list of IdentitySetHistory records matching a given set of criteria. 4189 ''' 4190 deadline = None if timeout is None else time.time() + timeout 4191 req = IdentitySetHistoryListRequest() 4192 req.meta.CopyFrom(ListRequestMetadata()) 4193 if self.parent.page_limit > 0: 4194 req.meta.limit = self.parent.page_limit 4195 if self.parent.snapshot_datetime is not None: 4196 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4197 4198 req.filter = plumbing.quote_filter_args(filter, *args) 4199 4200 def generator(svc, req): 4201 tries = 0 4202 while True: 4203 t = None if deadline is None else deadline - time.time() 4204 try: 4205 plumbing_response = svc.stub.List( 4206 req, 4207 metadata=svc.parent.get_metadata( 4208 'IdentitySetsHistory.List', req), 4209 timeout=t) 4210 except Exception as e: 4211 if self.parent.shouldRetry(tries, e, deadline): 4212 tries += 1 4213 time.sleep( 4214 self.parent.exponentialBackoff(tries, deadline)) 4215 continue 4216 raise plumbing.convert_error_to_porcelain(e) from e 4217 tries = 0 4218 for plumbing_item in plumbing_response.history: 4219 yield plumbing.convert_identity_set_history_to_porcelain( 4220 plumbing_item) 4221 if plumbing_response.meta.next_cursor == '': 4222 break 4223 req.meta.cursor = plumbing_response.meta.next_cursor 4224 4225 return generator(self, req) 4226 4227 4228class ManagedSecrets: 4229 ''' 4230 ManagedSecret is a private vertical for creating, reading, updating, 4231 deleting, listing and rotating the managed secrets in the secrets engines as 4232 an authenticated user. 4233 See `strongdm.models.ManagedSecret`. 4234 ''' 4235 def __init__(self, channel, client): 4236 self.parent = client 4237 self.stub = ManagedSecretsStub(channel) 4238 4239 def list(self, filter, *args, timeout=None): 4240 ''' 4241 List returns Managed Secrets from a Secret Engine. 4242 ''' 4243 deadline = None if timeout is None else time.time() + timeout 4244 req = ManagedSecretListRequest() 4245 req.meta.CopyFrom(ListRequestMetadata()) 4246 if self.parent.page_limit > 0: 4247 req.meta.limit = self.parent.page_limit 4248 if self.parent.snapshot_datetime is not None: 4249 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4250 4251 req.filter = plumbing.quote_filter_args(filter, *args) 4252 4253 def generator(svc, req): 4254 tries = 0 4255 while True: 4256 t = None if deadline is None else deadline - time.time() 4257 try: 4258 plumbing_response = svc.stub.List( 4259 req, 4260 metadata=svc.parent.get_metadata( 4261 'ManagedSecrets.List', req), 4262 timeout=t) 4263 except Exception as e: 4264 if self.parent.shouldRetry(tries, e, deadline): 4265 tries += 1 4266 time.sleep( 4267 self.parent.exponentialBackoff(tries, deadline)) 4268 continue 4269 raise plumbing.convert_error_to_porcelain(e) from e 4270 tries = 0 4271 for plumbing_item in plumbing_response.managed_secrets: 4272 yield plumbing.convert_managed_secret_to_porcelain( 4273 plumbing_item) 4274 if plumbing_response.meta.next_cursor == '': 4275 break 4276 req.meta.cursor = plumbing_response.meta.next_cursor 4277 4278 return generator(self, req) 4279 4280 def list_by_actor(self, filter, *args, timeout=None): 4281 ''' 4282 List returns Managed Secrets for an Actor from a Secret Engine. 4283 ''' 4284 deadline = None if timeout is None else time.time() + timeout 4285 req = ManagedSecretListRequest() 4286 req.meta.CopyFrom(ListRequestMetadata()) 4287 if self.parent.page_limit > 0: 4288 req.meta.limit = self.parent.page_limit 4289 if self.parent.snapshot_datetime is not None: 4290 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4291 4292 req.filter = plumbing.quote_filter_args(filter, *args) 4293 4294 def generator(svc, req): 4295 tries = 0 4296 while True: 4297 t = None if deadline is None else deadline - time.time() 4298 try: 4299 plumbing_response = svc.stub.ListByActor( 4300 req, 4301 metadata=svc.parent.get_metadata( 4302 'ManagedSecrets.ListByActor', req), 4303 timeout=t) 4304 except Exception as e: 4305 if self.parent.shouldRetry(tries, e, deadline): 4306 tries += 1 4307 time.sleep( 4308 self.parent.exponentialBackoff(tries, deadline)) 4309 continue 4310 raise plumbing.convert_error_to_porcelain(e) from e 4311 tries = 0 4312 for plumbing_item in plumbing_response.managed_secrets: 4313 yield plumbing.convert_managed_secret_to_porcelain( 4314 plumbing_item) 4315 if plumbing_response.meta.next_cursor == '': 4316 break 4317 req.meta.cursor = plumbing_response.meta.next_cursor 4318 4319 return generator(self, req) 4320 4321 def create(self, managed_secret, timeout=None): 4322 ''' 4323 Create creates a Managed Secret 4324 ''' 4325 deadline = None if timeout is None else time.time() + timeout 4326 req = ManagedSecretCreateRequest() 4327 4328 if managed_secret is not None: 4329 req.managed_secret.CopyFrom( 4330 plumbing.convert_managed_secret_to_plumbing(managed_secret)) 4331 tries = 0 4332 plumbing_response = None 4333 while True: 4334 t = None if deadline is None else deadline - time.time() 4335 try: 4336 plumbing_response = self.stub.Create( 4337 req, 4338 metadata=self.parent.get_metadata('ManagedSecrets.Create', 4339 req), 4340 timeout=t) 4341 except Exception as e: 4342 if self.parent.shouldRetry(tries, e, deadline): 4343 tries += 1 4344 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4345 continue 4346 raise plumbing.convert_error_to_porcelain(e) from e 4347 break 4348 4349 resp = models.ManagedSecretCreateResponse() 4350 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 4351 plumbing_response.managed_secret) 4352 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4353 plumbing_response.meta) 4354 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4355 plumbing_response.rate_limit) 4356 return resp 4357 4358 def update(self, managed_secret, timeout=None): 4359 ''' 4360 Update updates a Managed Secret 4361 ''' 4362 deadline = None if timeout is None else time.time() + timeout 4363 req = ManagedSecretUpdateRequest() 4364 4365 if managed_secret is not None: 4366 req.managed_secret.CopyFrom( 4367 plumbing.convert_managed_secret_to_plumbing(managed_secret)) 4368 tries = 0 4369 plumbing_response = None 4370 while True: 4371 t = None if deadline is None else deadline - time.time() 4372 try: 4373 plumbing_response = self.stub.Update( 4374 req, 4375 metadata=self.parent.get_metadata('ManagedSecrets.Update', 4376 req), 4377 timeout=t) 4378 except Exception as e: 4379 if self.parent.shouldRetry(tries, e, deadline): 4380 tries += 1 4381 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4382 continue 4383 raise plumbing.convert_error_to_porcelain(e) from e 4384 break 4385 4386 resp = models.ManagedSecretUpdateResponse() 4387 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 4388 plumbing_response.managed_secret) 4389 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 4390 plumbing_response.meta) 4391 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4392 plumbing_response.rate_limit) 4393 return resp 4394 4395 def rotate(self, id, timeout=None): 4396 ''' 4397 Rotate forces rotation of Managed Secret 4398 ''' 4399 deadline = None if timeout is None else time.time() + timeout 4400 req = ManagedSecretRotateRequest() 4401 4402 req.id = (id) 4403 tries = 0 4404 plumbing_response = None 4405 while True: 4406 t = None if deadline is None else deadline - time.time() 4407 try: 4408 plumbing_response = self.stub.Rotate( 4409 req, 4410 metadata=self.parent.get_metadata('ManagedSecrets.Rotate', 4411 req), 4412 timeout=t) 4413 except Exception as e: 4414 if self.parent.shouldRetry(tries, e, deadline): 4415 tries += 1 4416 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4417 continue 4418 raise plumbing.convert_error_to_porcelain(e) from e 4419 break 4420 4421 resp = models.ManagedSecretRotateResponse() 4422 resp.meta = plumbing.convert_generic_response_metadata_to_porcelain( 4423 plumbing_response.meta) 4424 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4425 plumbing_response.rate_limit) 4426 return resp 4427 4428 def delete(self, id, timeout=None): 4429 ''' 4430 Delete deletes a Managed Secret 4431 ''' 4432 deadline = None if timeout is None else time.time() + timeout 4433 req = ManagedSecretDeleteRequest() 4434 4435 req.id = (id) 4436 tries = 0 4437 plumbing_response = None 4438 while True: 4439 t = None if deadline is None else deadline - time.time() 4440 try: 4441 plumbing_response = self.stub.Delete( 4442 req, 4443 metadata=self.parent.get_metadata('ManagedSecrets.Delete', 4444 req), 4445 timeout=t) 4446 except Exception as e: 4447 if self.parent.shouldRetry(tries, e, deadline): 4448 tries += 1 4449 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4450 continue 4451 raise plumbing.convert_error_to_porcelain(e) from e 4452 break 4453 4454 resp = models.ManagedSecretDeleteResponse() 4455 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4456 plumbing_response.rate_limit) 4457 return resp 4458 4459 def force_delete(self, id, timeout=None): 4460 ''' 4461 ForceDelete deletes a Managed Secret regardless of errors on external system 4462 ''' 4463 deadline = None if timeout is None else time.time() + timeout 4464 req = ManagedSecretDeleteRequest() 4465 4466 req.id = (id) 4467 tries = 0 4468 plumbing_response = None 4469 while True: 4470 t = None if deadline is None else deadline - time.time() 4471 try: 4472 plumbing_response = self.stub.ForceDelete( 4473 req, 4474 metadata=self.parent.get_metadata( 4475 'ManagedSecrets.ForceDelete', req), 4476 timeout=t) 4477 except Exception as e: 4478 if self.parent.shouldRetry(tries, e, deadline): 4479 tries += 1 4480 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4481 continue 4482 raise plumbing.convert_error_to_porcelain(e) from e 4483 break 4484 4485 resp = models.ManagedSecretDeleteResponse() 4486 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4487 plumbing_response.rate_limit) 4488 return resp 4489 4490 def get(self, id, timeout=None): 4491 ''' 4492 Get gets details of a Managed Secret without sensitive data 4493 ''' 4494 deadline = None if timeout is None else time.time() + timeout 4495 req = ManagedSecretGetRequest() 4496 if self.parent.snapshot_datetime is not None: 4497 req.meta.CopyFrom(GetRequestMetadata()) 4498 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4499 4500 req.id = (id) 4501 tries = 0 4502 plumbing_response = None 4503 while True: 4504 t = None if deadline is None else deadline - time.time() 4505 try: 4506 plumbing_response = self.stub.Get( 4507 req, 4508 metadata=self.parent.get_metadata('ManagedSecrets.Get', 4509 req), 4510 timeout=t) 4511 except Exception as e: 4512 if self.parent.shouldRetry(tries, e, deadline): 4513 tries += 1 4514 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4515 continue 4516 raise plumbing.convert_error_to_porcelain(e) from e 4517 break 4518 4519 resp = models.ManagedSecretGetResponse() 4520 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 4521 plumbing_response.managed_secret) 4522 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4523 plumbing_response.meta) 4524 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4525 plumbing_response.rate_limit) 4526 return resp 4527 4528 def retrieve(self, id, timeout=None): 4529 ''' 4530 Retrieve returns Managed Secret with sensitive data 4531 ''' 4532 deadline = None if timeout is None else time.time() + timeout 4533 req = ManagedSecretRetrieveRequest() 4534 4535 req.id = (id) 4536 tries = 0 4537 plumbing_response = None 4538 while True: 4539 t = None if deadline is None else deadline - time.time() 4540 try: 4541 plumbing_response = self.stub.Retrieve( 4542 req, 4543 metadata=self.parent.get_metadata( 4544 'ManagedSecrets.Retrieve', req), 4545 timeout=t) 4546 except Exception as e: 4547 if self.parent.shouldRetry(tries, e, deadline): 4548 tries += 1 4549 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4550 continue 4551 raise plumbing.convert_error_to_porcelain(e) from e 4552 break 4553 4554 resp = models.ManagedSecretRetrieveResponse() 4555 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 4556 plumbing_response.managed_secret) 4557 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4558 plumbing_response.meta) 4559 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4560 plumbing_response.rate_limit) 4561 return resp 4562 4563 def validate(self, id, timeout=None): 4564 ''' 4565 Validate returns the result of testing the stored credential against the 4566 secret engine. 4567 ''' 4568 deadline = None if timeout is None else time.time() + timeout 4569 req = ManagedSecretValidateRequest() 4570 4571 req.id = (id) 4572 tries = 0 4573 plumbing_response = None 4574 while True: 4575 t = None if deadline is None else deadline - time.time() 4576 try: 4577 plumbing_response = self.stub.Validate( 4578 req, 4579 metadata=self.parent.get_metadata( 4580 'ManagedSecrets.Validate', req), 4581 timeout=t) 4582 except Exception as e: 4583 if self.parent.shouldRetry(tries, e, deadline): 4584 tries += 1 4585 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4586 continue 4587 raise plumbing.convert_error_to_porcelain(e) from e 4588 break 4589 4590 resp = models.ManagedSecretValidateResponse() 4591 resp.invalid_info = (plumbing_response.invalid_info) 4592 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4593 plumbing_response.meta) 4594 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4595 plumbing_response.rate_limit) 4596 resp.valid = (plumbing_response.valid) 4597 return resp 4598 4599 def logs(self, filter, *args, timeout=None): 4600 ''' 4601 Logs returns the audit records for the managed secret. This may be replaced 4602 in the future. 4603 ''' 4604 deadline = None if timeout is None else time.time() + timeout 4605 req = ManagedSecretLogsRequest() 4606 req.meta.CopyFrom(ListRequestMetadata()) 4607 if self.parent.page_limit > 0: 4608 req.meta.limit = self.parent.page_limit 4609 if self.parent.snapshot_datetime is not None: 4610 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4611 4612 req.filter = plumbing.quote_filter_args(filter, *args) 4613 4614 def generator(svc, req): 4615 tries = 0 4616 while True: 4617 t = None if deadline is None else deadline - time.time() 4618 try: 4619 plumbing_response = svc.stub.Logs( 4620 req, 4621 metadata=svc.parent.get_metadata( 4622 'ManagedSecrets.Logs', req), 4623 timeout=t) 4624 except Exception as e: 4625 if self.parent.shouldRetry(tries, e, deadline): 4626 tries += 1 4627 time.sleep( 4628 self.parent.exponentialBackoff(tries, deadline)) 4629 continue 4630 raise plumbing.convert_error_to_porcelain(e) from e 4631 tries = 0 4632 for plumbing_item in plumbing_response.managed_secret_logs: 4633 yield plumbing.convert_managed_secret_log_to_porcelain( 4634 plumbing_item) 4635 if plumbing_response.meta.next_cursor == '': 4636 break 4637 req.meta.cursor = plumbing_response.meta.next_cursor 4638 4639 return generator(self, req) 4640 4641 4642class Nodes: 4643 ''' 4644 Nodes make up the StrongDM network, and allow your users to connect securely to your resources. 4645 There are three types of nodes: 4646 1. **Relay:** creates connectivity to your datasources, while maintaining the egress-only nature of your firewall 4647 2. **Gateway:** a relay that also listens for connections from StrongDM clients 4648 3. **Proxy Cluster:** a cluster of workers that together mediate access from clients to resources 4649 See: 4650 `strongdm.models.Gateway` 4651 `strongdm.models.ProxyCluster` 4652 `strongdm.models.Relay` 4653 ''' 4654 def __init__(self, channel, client): 4655 self.parent = client 4656 self.stub = NodesStub(channel) 4657 4658 def create(self, node, timeout=None): 4659 ''' 4660 Create registers a new Node. 4661 ''' 4662 deadline = None if timeout is None else time.time() + timeout 4663 req = NodeCreateRequest() 4664 4665 if node is not None: 4666 req.node.CopyFrom(plumbing.convert_node_to_plumbing(node)) 4667 tries = 0 4668 plumbing_response = None 4669 while True: 4670 t = None if deadline is None else deadline - time.time() 4671 try: 4672 plumbing_response = self.stub.Create( 4673 req, 4674 metadata=self.parent.get_metadata('Nodes.Create', req), 4675 timeout=t) 4676 except Exception as e: 4677 if self.parent.shouldRetry(tries, e, deadline): 4678 tries += 1 4679 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4680 continue 4681 raise plumbing.convert_error_to_porcelain(e) from e 4682 break 4683 4684 resp = models.NodeCreateResponse() 4685 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4686 plumbing_response.meta) 4687 resp.node = plumbing.convert_node_to_porcelain(plumbing_response.node) 4688 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4689 plumbing_response.rate_limit) 4690 resp.token = (plumbing_response.token) 4691 return resp 4692 4693 def get(self, id, timeout=None): 4694 ''' 4695 Get reads one Node by ID. 4696 ''' 4697 deadline = None if timeout is None else time.time() + timeout 4698 req = NodeGetRequest() 4699 if self.parent.snapshot_datetime is not None: 4700 req.meta.CopyFrom(GetRequestMetadata()) 4701 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4702 4703 req.id = (id) 4704 tries = 0 4705 plumbing_response = None 4706 while True: 4707 t = None if deadline is None else deadline - time.time() 4708 try: 4709 plumbing_response = self.stub.Get( 4710 req, 4711 metadata=self.parent.get_metadata('Nodes.Get', req), 4712 timeout=t) 4713 except Exception as e: 4714 if self.parent.shouldRetry(tries, e, deadline): 4715 tries += 1 4716 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4717 continue 4718 raise plumbing.convert_error_to_porcelain(e) from e 4719 break 4720 4721 resp = models.NodeGetResponse() 4722 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4723 plumbing_response.meta) 4724 resp.node = plumbing.convert_node_to_porcelain(plumbing_response.node) 4725 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4726 plumbing_response.rate_limit) 4727 return resp 4728 4729 def update(self, node, timeout=None): 4730 ''' 4731 Update replaces all the fields of a Node by ID. 4732 ''' 4733 deadline = None if timeout is None else time.time() + timeout 4734 req = NodeUpdateRequest() 4735 4736 if node is not None: 4737 req.node.CopyFrom(plumbing.convert_node_to_plumbing(node)) 4738 tries = 0 4739 plumbing_response = None 4740 while True: 4741 t = None if deadline is None else deadline - time.time() 4742 try: 4743 plumbing_response = self.stub.Update( 4744 req, 4745 metadata=self.parent.get_metadata('Nodes.Update', req), 4746 timeout=t) 4747 except Exception as e: 4748 if self.parent.shouldRetry(tries, e, deadline): 4749 tries += 1 4750 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4751 continue 4752 raise plumbing.convert_error_to_porcelain(e) from e 4753 break 4754 4755 resp = models.NodeUpdateResponse() 4756 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 4757 plumbing_response.meta) 4758 resp.node = plumbing.convert_node_to_porcelain(plumbing_response.node) 4759 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4760 plumbing_response.rate_limit) 4761 return resp 4762 4763 def delete(self, id, timeout=None): 4764 ''' 4765 Delete removes a Node by ID. 4766 ''' 4767 deadline = None if timeout is None else time.time() + timeout 4768 req = NodeDeleteRequest() 4769 4770 req.id = (id) 4771 tries = 0 4772 plumbing_response = None 4773 while True: 4774 t = None if deadline is None else deadline - time.time() 4775 try: 4776 plumbing_response = self.stub.Delete( 4777 req, 4778 metadata=self.parent.get_metadata('Nodes.Delete', req), 4779 timeout=t) 4780 except Exception as e: 4781 if self.parent.shouldRetry(tries, e, deadline): 4782 tries += 1 4783 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4784 continue 4785 raise plumbing.convert_error_to_porcelain(e) from e 4786 break 4787 4788 resp = models.NodeDeleteResponse() 4789 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 4790 plumbing_response.meta) 4791 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4792 plumbing_response.rate_limit) 4793 return resp 4794 4795 def list(self, filter, *args, timeout=None): 4796 ''' 4797 List gets a list of Nodes matching a given set of criteria. 4798 ''' 4799 deadline = None if timeout is None else time.time() + timeout 4800 req = NodeListRequest() 4801 req.meta.CopyFrom(ListRequestMetadata()) 4802 if self.parent.page_limit > 0: 4803 req.meta.limit = self.parent.page_limit 4804 if self.parent.snapshot_datetime is not None: 4805 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4806 4807 req.filter = plumbing.quote_filter_args(filter, *args) 4808 4809 def generator(svc, req): 4810 tries = 0 4811 while True: 4812 t = None if deadline is None else deadline - time.time() 4813 try: 4814 plumbing_response = svc.stub.List( 4815 req, 4816 metadata=svc.parent.get_metadata('Nodes.List', req), 4817 timeout=t) 4818 except Exception as e: 4819 if self.parent.shouldRetry(tries, e, deadline): 4820 tries += 1 4821 time.sleep( 4822 self.parent.exponentialBackoff(tries, deadline)) 4823 continue 4824 raise plumbing.convert_error_to_porcelain(e) from e 4825 tries = 0 4826 for plumbing_item in plumbing_response.nodes: 4827 yield plumbing.convert_node_to_porcelain(plumbing_item) 4828 if plumbing_response.meta.next_cursor == '': 4829 break 4830 req.meta.cursor = plumbing_response.meta.next_cursor 4831 4832 return generator(self, req) 4833 4834 def tcp_probe(self, node_id, host, port, timeout=None): 4835 ''' 4836 TCPProbe instructs a Node to connect to an address via TCP and report the 4837 result. 4838 ''' 4839 deadline = None if timeout is None else time.time() + timeout 4840 req = NodeTCPProbeRequest() 4841 4842 req.node_id = (node_id) 4843 req.host = (host) 4844 req.port = (port) 4845 tries = 0 4846 plumbing_response = None 4847 while True: 4848 t = None if deadline is None else deadline - time.time() 4849 try: 4850 plumbing_response = self.stub.TCPProbe( 4851 req, 4852 metadata=self.parent.get_metadata('Nodes.TCPProbe', req), 4853 timeout=t) 4854 except Exception as e: 4855 if self.parent.shouldRetry(tries, e, deadline): 4856 tries += 1 4857 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4858 continue 4859 raise plumbing.convert_error_to_porcelain(e) from e 4860 break 4861 4862 resp = models.NodeTCPProbeResponse() 4863 resp.error = (plumbing_response.error) 4864 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4865 plumbing_response.meta) 4866 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4867 plumbing_response.rate_limit) 4868 resp.succeeded = (plumbing_response.succeeded) 4869 return resp 4870 4871 4872class SnapshotNodes: 4873 ''' 4874 SnapshotNodes exposes the read only methods of the Nodes 4875 service for historical queries. 4876 ''' 4877 def __init__(self, nodes): 4878 self.nodes = nodes 4879 4880 def get(self, id, timeout=None): 4881 ''' 4882 Get reads one Node by ID. 4883 ''' 4884 return self.nodes.get(id, timeout=timeout) 4885 4886 def list(self, filter, *args, timeout=None): 4887 ''' 4888 List gets a list of Nodes matching a given set of criteria. 4889 ''' 4890 return self.nodes.list(filter, *args, timeout=timeout) 4891 4892 4893class NodesHistory: 4894 ''' 4895 NodesHistory records all changes to the state of a Node. 4896 See `strongdm.models.NodeHistory`. 4897 ''' 4898 def __init__(self, channel, client): 4899 self.parent = client 4900 self.stub = NodesHistoryStub(channel) 4901 4902 def list(self, filter, *args, timeout=None): 4903 ''' 4904 List gets a list of NodeHistory records matching a given set of criteria. 4905 ''' 4906 deadline = None if timeout is None else time.time() + timeout 4907 req = NodeHistoryListRequest() 4908 req.meta.CopyFrom(ListRequestMetadata()) 4909 if self.parent.page_limit > 0: 4910 req.meta.limit = self.parent.page_limit 4911 if self.parent.snapshot_datetime is not None: 4912 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4913 4914 req.filter = plumbing.quote_filter_args(filter, *args) 4915 4916 def generator(svc, req): 4917 tries = 0 4918 while True: 4919 t = None if deadline is None else deadline - time.time() 4920 try: 4921 plumbing_response = svc.stub.List( 4922 req, 4923 metadata=svc.parent.get_metadata( 4924 'NodesHistory.List', req), 4925 timeout=t) 4926 except Exception as e: 4927 if self.parent.shouldRetry(tries, e, deadline): 4928 tries += 1 4929 time.sleep( 4930 self.parent.exponentialBackoff(tries, deadline)) 4931 continue 4932 raise plumbing.convert_error_to_porcelain(e) from e 4933 tries = 0 4934 for plumbing_item in plumbing_response.history: 4935 yield plumbing.convert_node_history_to_porcelain( 4936 plumbing_item) 4937 if plumbing_response.meta.next_cursor == '': 4938 break 4939 req.meta.cursor = plumbing_response.meta.next_cursor 4940 4941 return generator(self, req) 4942 4943 4944class OrganizationHistory: 4945 ''' 4946 OrganizationHistory records all changes to the state of an Organization. 4947 See `strongdm.models.OrganizationHistoryRecord`. 4948 ''' 4949 def __init__(self, channel, client): 4950 self.parent = client 4951 self.stub = OrganizationHistoryStub(channel) 4952 4953 def list(self, filter, *args, timeout=None): 4954 ''' 4955 List gets a list of OrganizationHistory records matching a given set of criteria. 4956 ''' 4957 deadline = None if timeout is None else time.time() + timeout 4958 req = OrganizationHistoryListRequest() 4959 req.meta.CopyFrom(ListRequestMetadata()) 4960 if self.parent.page_limit > 0: 4961 req.meta.limit = self.parent.page_limit 4962 if self.parent.snapshot_datetime is not None: 4963 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4964 4965 req.filter = plumbing.quote_filter_args(filter, *args) 4966 4967 def generator(svc, req): 4968 tries = 0 4969 while True: 4970 t = None if deadline is None else deadline - time.time() 4971 try: 4972 plumbing_response = svc.stub.List( 4973 req, 4974 metadata=svc.parent.get_metadata( 4975 'OrganizationHistory.List', req), 4976 timeout=t) 4977 except Exception as e: 4978 if self.parent.shouldRetry(tries, e, deadline): 4979 tries += 1 4980 time.sleep( 4981 self.parent.exponentialBackoff(tries, deadline)) 4982 continue 4983 raise plumbing.convert_error_to_porcelain(e) from e 4984 tries = 0 4985 for plumbing_item in plumbing_response.history: 4986 yield plumbing.convert_organization_history_record_to_porcelain( 4987 plumbing_item) 4988 if plumbing_response.meta.next_cursor == '': 4989 break 4990 req.meta.cursor = plumbing_response.meta.next_cursor 4991 4992 return generator(self, req) 4993 4994 4995class PeeringGroupNodes: 4996 ''' 4997 PeeringGroupNodes provides the building blocks necessary to obtain attach a node to a peering group. 4998 See `strongdm.models.PeeringGroupNode`. 4999 ''' 5000 def __init__(self, channel, client): 5001 self.parent = client 5002 self.stub = PeeringGroupNodesStub(channel) 5003 5004 def create(self, peering_group_node, timeout=None): 5005 ''' 5006 Create attaches a Node to a PeeringGroup 5007 ''' 5008 deadline = None if timeout is None else time.time() + timeout 5009 req = PeeringGroupNodeCreateRequest() 5010 5011 if peering_group_node is not None: 5012 req.peering_group_node.CopyFrom( 5013 plumbing.convert_peering_group_node_to_plumbing( 5014 peering_group_node)) 5015 tries = 0 5016 plumbing_response = None 5017 while True: 5018 t = None if deadline is None else deadline - time.time() 5019 try: 5020 plumbing_response = self.stub.Create( 5021 req, 5022 metadata=self.parent.get_metadata( 5023 'PeeringGroupNodes.Create', req), 5024 timeout=t) 5025 except Exception as e: 5026 if self.parent.shouldRetry(tries, e, deadline): 5027 tries += 1 5028 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5029 continue 5030 raise plumbing.convert_error_to_porcelain(e) from e 5031 break 5032 5033 resp = models.PeeringGroupNodeCreateResponse() 5034 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5035 plumbing_response.meta) 5036 resp.peering_group_node = plumbing.convert_peering_group_node_to_porcelain( 5037 plumbing_response.peering_group_node) 5038 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5039 plumbing_response.rate_limit) 5040 return resp 5041 5042 def delete(self, id, timeout=None): 5043 ''' 5044 Delete detaches a Node to a PeeringGroup. 5045 ''' 5046 deadline = None if timeout is None else time.time() + timeout 5047 req = PeeringGroupNodeDeleteRequest() 5048 5049 req.id = (id) 5050 tries = 0 5051 plumbing_response = None 5052 while True: 5053 t = None if deadline is None else deadline - time.time() 5054 try: 5055 plumbing_response = self.stub.Delete( 5056 req, 5057 metadata=self.parent.get_metadata( 5058 'PeeringGroupNodes.Delete', req), 5059 timeout=t) 5060 except Exception as e: 5061 if self.parent.shouldRetry(tries, e, deadline): 5062 tries += 1 5063 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5064 continue 5065 raise plumbing.convert_error_to_porcelain(e) from e 5066 break 5067 5068 resp = models.PeeringGroupNodeDeleteResponse() 5069 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 5070 plumbing_response.meta) 5071 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5072 plumbing_response.rate_limit) 5073 return resp 5074 5075 def get(self, id, timeout=None): 5076 ''' 5077 Get reads the information of one peering group to node attachment. 5078 ''' 5079 deadline = None if timeout is None else time.time() + timeout 5080 req = PeeringGroupNodeGetRequest() 5081 if self.parent.snapshot_datetime is not None: 5082 req.meta.CopyFrom(GetRequestMetadata()) 5083 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5084 5085 req.id = (id) 5086 tries = 0 5087 plumbing_response = None 5088 while True: 5089 t = None if deadline is None else deadline - time.time() 5090 try: 5091 plumbing_response = self.stub.Get( 5092 req, 5093 metadata=self.parent.get_metadata('PeeringGroupNodes.Get', 5094 req), 5095 timeout=t) 5096 except Exception as e: 5097 if self.parent.shouldRetry(tries, e, deadline): 5098 tries += 1 5099 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5100 continue 5101 raise plumbing.convert_error_to_porcelain(e) from e 5102 break 5103 5104 resp = models.PeeringGroupNodeGetResponse() 5105 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5106 plumbing_response.meta) 5107 resp.peering_group_node = plumbing.convert_peering_group_node_to_porcelain( 5108 plumbing_response.peering_group_node) 5109 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5110 plumbing_response.rate_limit) 5111 return resp 5112 5113 def list(self, filter, *args, timeout=None): 5114 ''' 5115 List gets a list of peering group node attachments. 5116 ''' 5117 deadline = None if timeout is None else time.time() + timeout 5118 req = PeeringGroupNodeListRequest() 5119 req.meta.CopyFrom(ListRequestMetadata()) 5120 if self.parent.page_limit > 0: 5121 req.meta.limit = self.parent.page_limit 5122 if self.parent.snapshot_datetime is not None: 5123 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5124 5125 req.filter = plumbing.quote_filter_args(filter, *args) 5126 5127 def generator(svc, req): 5128 tries = 0 5129 while True: 5130 t = None if deadline is None else deadline - time.time() 5131 try: 5132 plumbing_response = svc.stub.List( 5133 req, 5134 metadata=svc.parent.get_metadata( 5135 'PeeringGroupNodes.List', req), 5136 timeout=t) 5137 except Exception as e: 5138 if self.parent.shouldRetry(tries, e, deadline): 5139 tries += 1 5140 time.sleep( 5141 self.parent.exponentialBackoff(tries, deadline)) 5142 continue 5143 raise plumbing.convert_error_to_porcelain(e) from e 5144 tries = 0 5145 for plumbing_item in plumbing_response.peering_group_nodes: 5146 yield plumbing.convert_peering_group_node_to_porcelain( 5147 plumbing_item) 5148 if plumbing_response.meta.next_cursor == '': 5149 break 5150 req.meta.cursor = plumbing_response.meta.next_cursor 5151 5152 return generator(self, req) 5153 5154 5155class PeeringGroupPeers: 5156 ''' 5157 PeeringGroupPeers provides the building blocks necessary to link two peering groups. 5158 See `strongdm.models.PeeringGroupPeer`. 5159 ''' 5160 def __init__(self, channel, client): 5161 self.parent = client 5162 self.stub = PeeringGroupPeersStub(channel) 5163 5164 def create(self, peering_group_peer, timeout=None): 5165 ''' 5166 Create links two peering groups. 5167 ''' 5168 deadline = None if timeout is None else time.time() + timeout 5169 req = PeeringGroupPeerCreateRequest() 5170 5171 if peering_group_peer is not None: 5172 req.peering_group_peer.CopyFrom( 5173 plumbing.convert_peering_group_peer_to_plumbing( 5174 peering_group_peer)) 5175 tries = 0 5176 plumbing_response = None 5177 while True: 5178 t = None if deadline is None else deadline - time.time() 5179 try: 5180 plumbing_response = self.stub.Create( 5181 req, 5182 metadata=self.parent.get_metadata( 5183 'PeeringGroupPeers.Create', req), 5184 timeout=t) 5185 except Exception as e: 5186 if self.parent.shouldRetry(tries, e, deadline): 5187 tries += 1 5188 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5189 continue 5190 raise plumbing.convert_error_to_porcelain(e) from e 5191 break 5192 5193 resp = models.PeeringGroupPeerCreateResponse() 5194 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5195 plumbing_response.meta) 5196 resp.peering_group_peer = plumbing.convert_peering_group_peer_to_porcelain( 5197 plumbing_response.peering_group_peer) 5198 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5199 plumbing_response.rate_limit) 5200 return resp 5201 5202 def delete(self, id, timeout=None): 5203 ''' 5204 Delete unlinks two peering groups. 5205 ''' 5206 deadline = None if timeout is None else time.time() + timeout 5207 req = PeeringGroupPeerDeleteRequest() 5208 5209 req.id = (id) 5210 tries = 0 5211 plumbing_response = None 5212 while True: 5213 t = None if deadline is None else deadline - time.time() 5214 try: 5215 plumbing_response = self.stub.Delete( 5216 req, 5217 metadata=self.parent.get_metadata( 5218 'PeeringGroupPeers.Delete', req), 5219 timeout=t) 5220 except Exception as e: 5221 if self.parent.shouldRetry(tries, e, deadline): 5222 tries += 1 5223 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5224 continue 5225 raise plumbing.convert_error_to_porcelain(e) from e 5226 break 5227 5228 resp = models.PeeringGroupPeerDeleteResponse() 5229 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 5230 plumbing_response.meta) 5231 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5232 plumbing_response.rate_limit) 5233 return resp 5234 5235 def get(self, id, timeout=None): 5236 ''' 5237 Get reads the information of one peering group link. 5238 ''' 5239 deadline = None if timeout is None else time.time() + timeout 5240 req = PeeringGroupPeerGetRequest() 5241 if self.parent.snapshot_datetime is not None: 5242 req.meta.CopyFrom(GetRequestMetadata()) 5243 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5244 5245 req.id = (id) 5246 tries = 0 5247 plumbing_response = None 5248 while True: 5249 t = None if deadline is None else deadline - time.time() 5250 try: 5251 plumbing_response = self.stub.Get( 5252 req, 5253 metadata=self.parent.get_metadata('PeeringGroupPeers.Get', 5254 req), 5255 timeout=t) 5256 except Exception as e: 5257 if self.parent.shouldRetry(tries, e, deadline): 5258 tries += 1 5259 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5260 continue 5261 raise plumbing.convert_error_to_porcelain(e) from e 5262 break 5263 5264 resp = models.PeeringGroupPeerGetResponse() 5265 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5266 plumbing_response.meta) 5267 resp.peering_group_peer = plumbing.convert_peering_group_peer_to_porcelain( 5268 plumbing_response.peering_group_peer) 5269 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5270 plumbing_response.rate_limit) 5271 return resp 5272 5273 def list(self, filter, *args, timeout=None): 5274 ''' 5275 List gets a list of peering group links. 5276 ''' 5277 deadline = None if timeout is None else time.time() + timeout 5278 req = PeeringGroupPeerListRequest() 5279 req.meta.CopyFrom(ListRequestMetadata()) 5280 if self.parent.page_limit > 0: 5281 req.meta.limit = self.parent.page_limit 5282 if self.parent.snapshot_datetime is not None: 5283 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5284 5285 req.filter = plumbing.quote_filter_args(filter, *args) 5286 5287 def generator(svc, req): 5288 tries = 0 5289 while True: 5290 t = None if deadline is None else deadline - time.time() 5291 try: 5292 plumbing_response = svc.stub.List( 5293 req, 5294 metadata=svc.parent.get_metadata( 5295 'PeeringGroupPeers.List', req), 5296 timeout=t) 5297 except Exception as e: 5298 if self.parent.shouldRetry(tries, e, deadline): 5299 tries += 1 5300 time.sleep( 5301 self.parent.exponentialBackoff(tries, deadline)) 5302 continue 5303 raise plumbing.convert_error_to_porcelain(e) from e 5304 tries = 0 5305 for plumbing_item in plumbing_response.peering_group_peers: 5306 yield plumbing.convert_peering_group_peer_to_porcelain( 5307 plumbing_item) 5308 if plumbing_response.meta.next_cursor == '': 5309 break 5310 req.meta.cursor = plumbing_response.meta.next_cursor 5311 5312 return generator(self, req) 5313 5314 5315class PeeringGroupResources: 5316 ''' 5317 PeeringGroupResources provides the building blocks necessary to obtain attach a resource to a peering group. 5318 See `strongdm.models.PeeringGroupResource`. 5319 ''' 5320 def __init__(self, channel, client): 5321 self.parent = client 5322 self.stub = PeeringGroupResourcesStub(channel) 5323 5324 def create(self, peering_group_resource, timeout=None): 5325 ''' 5326 Create attaches a Resource to a PeeringGroup 5327 ''' 5328 deadline = None if timeout is None else time.time() + timeout 5329 req = PeeringGroupResourceCreateRequest() 5330 5331 if peering_group_resource is not None: 5332 req.peering_group_resource.CopyFrom( 5333 plumbing.convert_peering_group_resource_to_plumbing( 5334 peering_group_resource)) 5335 tries = 0 5336 plumbing_response = None 5337 while True: 5338 t = None if deadline is None else deadline - time.time() 5339 try: 5340 plumbing_response = self.stub.Create( 5341 req, 5342 metadata=self.parent.get_metadata( 5343 'PeeringGroupResources.Create', req), 5344 timeout=t) 5345 except Exception as e: 5346 if self.parent.shouldRetry(tries, e, deadline): 5347 tries += 1 5348 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5349 continue 5350 raise plumbing.convert_error_to_porcelain(e) from e 5351 break 5352 5353 resp = models.PeeringGroupResourceCreateResponse() 5354 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5355 plumbing_response.meta) 5356 resp.peering_group_resource = plumbing.convert_peering_group_resource_to_porcelain( 5357 plumbing_response.peering_group_resource) 5358 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5359 plumbing_response.rate_limit) 5360 return resp 5361 5362 def delete(self, id, timeout=None): 5363 ''' 5364 Delete detaches a Resource to a PeeringGroup 5365 ''' 5366 deadline = None if timeout is None else time.time() + timeout 5367 req = PeeringGroupResourceDeleteRequest() 5368 5369 req.id = (id) 5370 tries = 0 5371 plumbing_response = None 5372 while True: 5373 t = None if deadline is None else deadline - time.time() 5374 try: 5375 plumbing_response = self.stub.Delete( 5376 req, 5377 metadata=self.parent.get_metadata( 5378 'PeeringGroupResources.Delete', req), 5379 timeout=t) 5380 except Exception as e: 5381 if self.parent.shouldRetry(tries, e, deadline): 5382 tries += 1 5383 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5384 continue 5385 raise plumbing.convert_error_to_porcelain(e) from e 5386 break 5387 5388 resp = models.PeeringGroupResourceDeleteResponse() 5389 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 5390 plumbing_response.meta) 5391 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5392 plumbing_response.rate_limit) 5393 return resp 5394 5395 def get(self, id, timeout=None): 5396 ''' 5397 Get reads the information of one peering group to resource attachment. 5398 ''' 5399 deadline = None if timeout is None else time.time() + timeout 5400 req = PeeringGroupResourceGetRequest() 5401 if self.parent.snapshot_datetime is not None: 5402 req.meta.CopyFrom(GetRequestMetadata()) 5403 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5404 5405 req.id = (id) 5406 tries = 0 5407 plumbing_response = None 5408 while True: 5409 t = None if deadline is None else deadline - time.time() 5410 try: 5411 plumbing_response = self.stub.Get( 5412 req, 5413 metadata=self.parent.get_metadata( 5414 'PeeringGroupResources.Get', req), 5415 timeout=t) 5416 except Exception as e: 5417 if self.parent.shouldRetry(tries, e, deadline): 5418 tries += 1 5419 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5420 continue 5421 raise plumbing.convert_error_to_porcelain(e) from e 5422 break 5423 5424 resp = models.PeeringGroupResourceGetResponse() 5425 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5426 plumbing_response.meta) 5427 resp.peering_group_resource = plumbing.convert_peering_group_resource_to_porcelain( 5428 plumbing_response.peering_group_resource) 5429 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5430 plumbing_response.rate_limit) 5431 return resp 5432 5433 def list(self, filter, *args, timeout=None): 5434 ''' 5435 List gets a list of peering group resource attachments. 5436 ''' 5437 deadline = None if timeout is None else time.time() + timeout 5438 req = PeeringGroupResourceListRequest() 5439 req.meta.CopyFrom(ListRequestMetadata()) 5440 if self.parent.page_limit > 0: 5441 req.meta.limit = self.parent.page_limit 5442 if self.parent.snapshot_datetime is not None: 5443 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5444 5445 req.filter = plumbing.quote_filter_args(filter, *args) 5446 5447 def generator(svc, req): 5448 tries = 0 5449 while True: 5450 t = None if deadline is None else deadline - time.time() 5451 try: 5452 plumbing_response = svc.stub.List( 5453 req, 5454 metadata=svc.parent.get_metadata( 5455 'PeeringGroupResources.List', req), 5456 timeout=t) 5457 except Exception as e: 5458 if self.parent.shouldRetry(tries, e, deadline): 5459 tries += 1 5460 time.sleep( 5461 self.parent.exponentialBackoff(tries, deadline)) 5462 continue 5463 raise plumbing.convert_error_to_porcelain(e) from e 5464 tries = 0 5465 for plumbing_item in plumbing_response.peering_group_resources: 5466 yield plumbing.convert_peering_group_resource_to_porcelain( 5467 plumbing_item) 5468 if plumbing_response.meta.next_cursor == '': 5469 break 5470 req.meta.cursor = plumbing_response.meta.next_cursor 5471 5472 return generator(self, req) 5473 5474 5475class PeeringGroups: 5476 ''' 5477 PeeringGroups provides the building blocks necessary to obtain explicit network topology and routing. 5478 See `strongdm.models.PeeringGroup`. 5479 ''' 5480 def __init__(self, channel, client): 5481 self.parent = client 5482 self.stub = PeeringGroupsStub(channel) 5483 5484 def create(self, peering_group, timeout=None): 5485 ''' 5486 Create registers a new PeeringGroup. 5487 ''' 5488 deadline = None if timeout is None else time.time() + timeout 5489 req = PeeringGroupCreateRequest() 5490 5491 if peering_group is not None: 5492 req.peering_group.CopyFrom( 5493 plumbing.convert_peering_group_to_plumbing(peering_group)) 5494 tries = 0 5495 plumbing_response = None 5496 while True: 5497 t = None if deadline is None else deadline - time.time() 5498 try: 5499 plumbing_response = self.stub.Create( 5500 req, 5501 metadata=self.parent.get_metadata('PeeringGroups.Create', 5502 req), 5503 timeout=t) 5504 except Exception as e: 5505 if self.parent.shouldRetry(tries, e, deadline): 5506 tries += 1 5507 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5508 continue 5509 raise plumbing.convert_error_to_porcelain(e) from e 5510 break 5511 5512 resp = models.PeeringGroupCreateResponse() 5513 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5514 plumbing_response.meta) 5515 resp.peering_group = plumbing.convert_peering_group_to_porcelain( 5516 plumbing_response.peering_group) 5517 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5518 plumbing_response.rate_limit) 5519 return resp 5520 5521 def delete(self, id, timeout=None): 5522 ''' 5523 Delete removes a PeeringGroup by ID. 5524 ''' 5525 deadline = None if timeout is None else time.time() + timeout 5526 req = PeeringGroupDeleteRequest() 5527 5528 req.id = (id) 5529 tries = 0 5530 plumbing_response = None 5531 while True: 5532 t = None if deadline is None else deadline - time.time() 5533 try: 5534 plumbing_response = self.stub.Delete( 5535 req, 5536 metadata=self.parent.get_metadata('PeeringGroups.Delete', 5537 req), 5538 timeout=t) 5539 except Exception as e: 5540 if self.parent.shouldRetry(tries, e, deadline): 5541 tries += 1 5542 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5543 continue 5544 raise plumbing.convert_error_to_porcelain(e) from e 5545 break 5546 5547 resp = models.PeeringGroupDeleteResponse() 5548 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 5549 plumbing_response.meta) 5550 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5551 plumbing_response.rate_limit) 5552 return resp 5553 5554 def get(self, id, timeout=None): 5555 ''' 5556 Get reads one PeeringGroup by ID. It will load all its dependencies. 5557 ''' 5558 deadline = None if timeout is None else time.time() + timeout 5559 req = PeeringGroupGetRequest() 5560 if self.parent.snapshot_datetime is not None: 5561 req.meta.CopyFrom(GetRequestMetadata()) 5562 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5563 5564 req.id = (id) 5565 tries = 0 5566 plumbing_response = None 5567 while True: 5568 t = None if deadline is None else deadline - time.time() 5569 try: 5570 plumbing_response = self.stub.Get( 5571 req, 5572 metadata=self.parent.get_metadata('PeeringGroups.Get', 5573 req), 5574 timeout=t) 5575 except Exception as e: 5576 if self.parent.shouldRetry(tries, e, deadline): 5577 tries += 1 5578 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5579 continue 5580 raise plumbing.convert_error_to_porcelain(e) from e 5581 break 5582 5583 resp = models.PeeringGroupGetResponse() 5584 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5585 plumbing_response.meta) 5586 resp.peering_group = plumbing.convert_peering_group_to_porcelain( 5587 plumbing_response.peering_group) 5588 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5589 plumbing_response.rate_limit) 5590 return resp 5591 5592 def list(self, filter, *args, timeout=None): 5593 ''' 5594 List gets a list of Peering Groups. 5595 ''' 5596 deadline = None if timeout is None else time.time() + timeout 5597 req = PeeringGroupListRequest() 5598 req.meta.CopyFrom(ListRequestMetadata()) 5599 if self.parent.page_limit > 0: 5600 req.meta.limit = self.parent.page_limit 5601 if self.parent.snapshot_datetime is not None: 5602 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5603 5604 req.filter = plumbing.quote_filter_args(filter, *args) 5605 5606 def generator(svc, req): 5607 tries = 0 5608 while True: 5609 t = None if deadline is None else deadline - time.time() 5610 try: 5611 plumbing_response = svc.stub.List( 5612 req, 5613 metadata=svc.parent.get_metadata( 5614 'PeeringGroups.List', req), 5615 timeout=t) 5616 except Exception as e: 5617 if self.parent.shouldRetry(tries, e, deadline): 5618 tries += 1 5619 time.sleep( 5620 self.parent.exponentialBackoff(tries, deadline)) 5621 continue 5622 raise plumbing.convert_error_to_porcelain(e) from e 5623 tries = 0 5624 for plumbing_item in plumbing_response.peering_groups: 5625 yield plumbing.convert_peering_group_to_porcelain( 5626 plumbing_item) 5627 if plumbing_response.meta.next_cursor == '': 5628 break 5629 req.meta.cursor = plumbing_response.meta.next_cursor 5630 5631 return generator(self, req) 5632 5633 5634class Policies: 5635 ''' 5636 Policies are the collection of one or more statements that enforce fine-grained access 5637 control for the users of an organization. 5638 See `strongdm.models.Policy`. 5639 ''' 5640 def __init__(self, channel, client): 5641 self.parent = client 5642 self.stub = PoliciesStub(channel) 5643 5644 def create(self, policy, timeout=None): 5645 ''' 5646 Create creates a new Policy. 5647 ''' 5648 deadline = None if timeout is None else time.time() + timeout 5649 req = PolicyCreateRequest() 5650 5651 if policy is not None: 5652 req.policy.CopyFrom(plumbing.convert_policy_to_plumbing(policy)) 5653 tries = 0 5654 plumbing_response = None 5655 while True: 5656 t = None if deadline is None else deadline - time.time() 5657 try: 5658 plumbing_response = self.stub.Create( 5659 req, 5660 metadata=self.parent.get_metadata('Policies.Create', req), 5661 timeout=t) 5662 except Exception as e: 5663 if self.parent.shouldRetry(tries, e, deadline): 5664 tries += 1 5665 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5666 continue 5667 raise plumbing.convert_error_to_porcelain(e) from e 5668 break 5669 5670 resp = models.PolicyCreateResponse() 5671 resp.policy = plumbing.convert_policy_to_porcelain( 5672 plumbing_response.policy) 5673 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5674 plumbing_response.rate_limit) 5675 return resp 5676 5677 def delete(self, id, timeout=None): 5678 ''' 5679 Delete removes a Policy by ID. 5680 ''' 5681 deadline = None if timeout is None else time.time() + timeout 5682 req = PolicyDeleteRequest() 5683 5684 req.id = (id) 5685 tries = 0 5686 plumbing_response = None 5687 while True: 5688 t = None if deadline is None else deadline - time.time() 5689 try: 5690 plumbing_response = self.stub.Delete( 5691 req, 5692 metadata=self.parent.get_metadata('Policies.Delete', req), 5693 timeout=t) 5694 except Exception as e: 5695 if self.parent.shouldRetry(tries, e, deadline): 5696 tries += 1 5697 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5698 continue 5699 raise plumbing.convert_error_to_porcelain(e) from e 5700 break 5701 5702 resp = models.PolicyDeleteResponse() 5703 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5704 plumbing_response.rate_limit) 5705 return resp 5706 5707 def update(self, policy, timeout=None): 5708 ''' 5709 Update replaces all the fields of a Policy by ID. 5710 ''' 5711 deadline = None if timeout is None else time.time() + timeout 5712 req = PolicyUpdateRequest() 5713 5714 if policy is not None: 5715 req.policy.CopyFrom(plumbing.convert_policy_to_plumbing(policy)) 5716 tries = 0 5717 plumbing_response = None 5718 while True: 5719 t = None if deadline is None else deadline - time.time() 5720 try: 5721 plumbing_response = self.stub.Update( 5722 req, 5723 metadata=self.parent.get_metadata('Policies.Update', req), 5724 timeout=t) 5725 except Exception as e: 5726 if self.parent.shouldRetry(tries, e, deadline): 5727 tries += 1 5728 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5729 continue 5730 raise plumbing.convert_error_to_porcelain(e) from e 5731 break 5732 5733 resp = models.PolicyUpdateResponse() 5734 resp.policy = plumbing.convert_policy_to_porcelain( 5735 plumbing_response.policy) 5736 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5737 plumbing_response.rate_limit) 5738 return resp 5739 5740 def get(self, id, timeout=None): 5741 ''' 5742 Get reads one Policy by ID. 5743 ''' 5744 deadline = None if timeout is None else time.time() + timeout 5745 req = PolicyGetRequest() 5746 if self.parent.snapshot_datetime is not None: 5747 req.meta.CopyFrom(GetRequestMetadata()) 5748 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5749 5750 req.id = (id) 5751 tries = 0 5752 plumbing_response = None 5753 while True: 5754 t = None if deadline is None else deadline - time.time() 5755 try: 5756 plumbing_response = self.stub.Get( 5757 req, 5758 metadata=self.parent.get_metadata('Policies.Get', req), 5759 timeout=t) 5760 except Exception as e: 5761 if self.parent.shouldRetry(tries, e, deadline): 5762 tries += 1 5763 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5764 continue 5765 raise plumbing.convert_error_to_porcelain(e) from e 5766 break 5767 5768 resp = models.PolicyGetResponse() 5769 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5770 plumbing_response.meta) 5771 resp.policy = plumbing.convert_policy_to_porcelain( 5772 plumbing_response.policy) 5773 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5774 plumbing_response.rate_limit) 5775 return resp 5776 5777 def list(self, filter, *args, timeout=None): 5778 ''' 5779 List gets a list of Policy matching a given set of criteria 5780 ''' 5781 deadline = None if timeout is None else time.time() + timeout 5782 req = PolicyListRequest() 5783 req.meta.CopyFrom(ListRequestMetadata()) 5784 if self.parent.page_limit > 0: 5785 req.meta.limit = self.parent.page_limit 5786 if self.parent.snapshot_datetime is not None: 5787 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5788 5789 req.filter = plumbing.quote_filter_args(filter, *args) 5790 5791 def generator(svc, req): 5792 tries = 0 5793 while True: 5794 t = None if deadline is None else deadline - time.time() 5795 try: 5796 plumbing_response = svc.stub.List( 5797 req, 5798 metadata=svc.parent.get_metadata('Policies.List', req), 5799 timeout=t) 5800 except Exception as e: 5801 if self.parent.shouldRetry(tries, e, deadline): 5802 tries += 1 5803 time.sleep( 5804 self.parent.exponentialBackoff(tries, deadline)) 5805 continue 5806 raise plumbing.convert_error_to_porcelain(e) from e 5807 tries = 0 5808 for plumbing_item in plumbing_response.policies: 5809 yield plumbing.convert_policy_to_porcelain(plumbing_item) 5810 if plumbing_response.meta.next_cursor == '': 5811 break 5812 req.meta.cursor = plumbing_response.meta.next_cursor 5813 5814 return generator(self, req) 5815 5816 5817class SnapshotPolicies: 5818 ''' 5819 SnapshotPolicies exposes the read only methods of the Policies 5820 service for historical queries. 5821 ''' 5822 def __init__(self, policies): 5823 self.policies = policies 5824 5825 def get(self, id, timeout=None): 5826 ''' 5827 Get reads one Policy by ID. 5828 ''' 5829 return self.policies.get(id, timeout=timeout) 5830 5831 def list(self, filter, *args, timeout=None): 5832 ''' 5833 List gets a list of Policy matching a given set of criteria 5834 ''' 5835 return self.policies.list(filter, *args, timeout=timeout) 5836 5837 5838class PoliciesHistory: 5839 ''' 5840 PoliciesHistory records all changes to the state of a Policy. 5841 See `strongdm.models.PolicyHistory`. 5842 ''' 5843 def __init__(self, channel, client): 5844 self.parent = client 5845 self.stub = PoliciesHistoryStub(channel) 5846 5847 def list(self, filter, *args, timeout=None): 5848 ''' 5849 List gets a list of PolicyHistory records matching a given set of criteria. 5850 ''' 5851 deadline = None if timeout is None else time.time() + timeout 5852 req = PoliciesHistoryListRequest() 5853 req.meta.CopyFrom(ListRequestMetadata()) 5854 if self.parent.page_limit > 0: 5855 req.meta.limit = self.parent.page_limit 5856 if self.parent.snapshot_datetime is not None: 5857 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5858 5859 req.filter = plumbing.quote_filter_args(filter, *args) 5860 5861 def generator(svc, req): 5862 tries = 0 5863 while True: 5864 t = None if deadline is None else deadline - time.time() 5865 try: 5866 plumbing_response = svc.stub.List( 5867 req, 5868 metadata=svc.parent.get_metadata( 5869 'PoliciesHistory.List', req), 5870 timeout=t) 5871 except Exception as e: 5872 if self.parent.shouldRetry(tries, e, deadline): 5873 tries += 1 5874 time.sleep( 5875 self.parent.exponentialBackoff(tries, deadline)) 5876 continue 5877 raise plumbing.convert_error_to_porcelain(e) from e 5878 tries = 0 5879 for plumbing_item in plumbing_response.history: 5880 yield plumbing.convert_policy_history_to_porcelain( 5881 plumbing_item) 5882 if plumbing_response.meta.next_cursor == '': 5883 break 5884 req.meta.cursor = plumbing_response.meta.next_cursor 5885 5886 return generator(self, req) 5887 5888 5889class ProxyClusterKeys: 5890 ''' 5891 Proxy Cluster Keys are authentication keys for all proxies within a cluster. 5892 The proxies within a cluster share the same key. One cluster can have 5893 multiple keys in order to facilitate key rotation. 5894 See `strongdm.models.ProxyClusterKey`. 5895 ''' 5896 def __init__(self, channel, client): 5897 self.parent = client 5898 self.stub = ProxyClusterKeysStub(channel) 5899 5900 def create(self, proxy_cluster_key, timeout=None): 5901 ''' 5902 Create registers a new ProxyClusterKey. 5903 ''' 5904 deadline = None if timeout is None else time.time() + timeout 5905 req = ProxyClusterKeyCreateRequest() 5906 5907 if proxy_cluster_key is not None: 5908 req.proxy_cluster_key.CopyFrom( 5909 plumbing.convert_proxy_cluster_key_to_plumbing( 5910 proxy_cluster_key)) 5911 tries = 0 5912 plumbing_response = None 5913 while True: 5914 t = None if deadline is None else deadline - time.time() 5915 try: 5916 plumbing_response = self.stub.Create( 5917 req, 5918 metadata=self.parent.get_metadata( 5919 'ProxyClusterKeys.Create', req), 5920 timeout=t) 5921 except Exception as e: 5922 if self.parent.shouldRetry(tries, e, deadline): 5923 tries += 1 5924 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5925 continue 5926 raise plumbing.convert_error_to_porcelain(e) from e 5927 break 5928 5929 resp = models.ProxyClusterKeyCreateResponse() 5930 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5931 plumbing_response.meta) 5932 resp.proxy_cluster_key = plumbing.convert_proxy_cluster_key_to_porcelain( 5933 plumbing_response.proxy_cluster_key) 5934 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5935 plumbing_response.rate_limit) 5936 resp.secret_key = (plumbing_response.secret_key) 5937 return resp 5938 5939 def get(self, id, timeout=None): 5940 ''' 5941 Get reads one ProxyClusterKey by ID. 5942 ''' 5943 deadline = None if timeout is None else time.time() + timeout 5944 req = ProxyClusterKeyGetRequest() 5945 if self.parent.snapshot_datetime is not None: 5946 req.meta.CopyFrom(GetRequestMetadata()) 5947 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5948 5949 req.id = (id) 5950 tries = 0 5951 plumbing_response = None 5952 while True: 5953 t = None if deadline is None else deadline - time.time() 5954 try: 5955 plumbing_response = self.stub.Get( 5956 req, 5957 metadata=self.parent.get_metadata('ProxyClusterKeys.Get', 5958 req), 5959 timeout=t) 5960 except Exception as e: 5961 if self.parent.shouldRetry(tries, e, deadline): 5962 tries += 1 5963 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5964 continue 5965 raise plumbing.convert_error_to_porcelain(e) from e 5966 break 5967 5968 resp = models.ProxyClusterKeyGetResponse() 5969 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5970 plumbing_response.meta) 5971 resp.proxy_cluster_key = plumbing.convert_proxy_cluster_key_to_porcelain( 5972 plumbing_response.proxy_cluster_key) 5973 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5974 plumbing_response.rate_limit) 5975 return resp 5976 5977 def delete(self, id, timeout=None): 5978 ''' 5979 Delete removes a ProxyClusterKey by ID. 5980 ''' 5981 deadline = None if timeout is None else time.time() + timeout 5982 req = ProxyClusterKeyDeleteRequest() 5983 5984 req.id = (id) 5985 tries = 0 5986 plumbing_response = None 5987 while True: 5988 t = None if deadline is None else deadline - time.time() 5989 try: 5990 plumbing_response = self.stub.Delete( 5991 req, 5992 metadata=self.parent.get_metadata( 5993 'ProxyClusterKeys.Delete', req), 5994 timeout=t) 5995 except Exception as e: 5996 if self.parent.shouldRetry(tries, e, deadline): 5997 tries += 1 5998 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5999 continue 6000 raise plumbing.convert_error_to_porcelain(e) from e 6001 break 6002 6003 resp = models.ProxyClusterKeyDeleteResponse() 6004 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 6005 plumbing_response.meta) 6006 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6007 plumbing_response.rate_limit) 6008 return resp 6009 6010 def list(self, filter, *args, timeout=None): 6011 ''' 6012 List gets a list of ProxyClusterKeys matching a given set of criteria. 6013 ''' 6014 deadline = None if timeout is None else time.time() + timeout 6015 req = ProxyClusterKeyListRequest() 6016 req.meta.CopyFrom(ListRequestMetadata()) 6017 if self.parent.page_limit > 0: 6018 req.meta.limit = self.parent.page_limit 6019 if self.parent.snapshot_datetime is not None: 6020 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6021 6022 req.filter = plumbing.quote_filter_args(filter, *args) 6023 6024 def generator(svc, req): 6025 tries = 0 6026 while True: 6027 t = None if deadline is None else deadline - time.time() 6028 try: 6029 plumbing_response = svc.stub.List( 6030 req, 6031 metadata=svc.parent.get_metadata( 6032 'ProxyClusterKeys.List', req), 6033 timeout=t) 6034 except Exception as e: 6035 if self.parent.shouldRetry(tries, e, deadline): 6036 tries += 1 6037 time.sleep( 6038 self.parent.exponentialBackoff(tries, deadline)) 6039 continue 6040 raise plumbing.convert_error_to_porcelain(e) from e 6041 tries = 0 6042 for plumbing_item in plumbing_response.proxy_cluster_keys: 6043 yield plumbing.convert_proxy_cluster_key_to_porcelain( 6044 plumbing_item) 6045 if plumbing_response.meta.next_cursor == '': 6046 break 6047 req.meta.cursor = plumbing_response.meta.next_cursor 6048 6049 return generator(self, req) 6050 6051 6052class SnapshotProxyClusterKeys: 6053 ''' 6054 SnapshotProxyClusterKeys exposes the read only methods of the ProxyClusterKeys 6055 service for historical queries. 6056 ''' 6057 def __init__(self, proxy_cluster_keys): 6058 self.proxy_cluster_keys = proxy_cluster_keys 6059 6060 def get(self, id, timeout=None): 6061 ''' 6062 Get reads one ProxyClusterKey by ID. 6063 ''' 6064 return self.proxy_cluster_keys.get(id, timeout=timeout) 6065 6066 def list(self, filter, *args, timeout=None): 6067 ''' 6068 List gets a list of ProxyClusterKeys matching a given set of criteria. 6069 ''' 6070 return self.proxy_cluster_keys.list(filter, *args, timeout=timeout) 6071 6072 6073class Queries: 6074 ''' 6075 A Query is a record of a single client request to a resource, such as a SQL query. 6076 Long-running SSH, RDP, or Kubernetes interactive sessions also count as queries. 6077 The Queries service is read-only. 6078 See `strongdm.models.Query`. 6079 ''' 6080 def __init__(self, channel, client): 6081 self.parent = client 6082 self.stub = QueriesStub(channel) 6083 6084 def list(self, filter, *args, timeout=None): 6085 ''' 6086 List gets a list of Queries matching a given set of criteria. 6087 ''' 6088 deadline = None if timeout is None else time.time() + timeout 6089 req = QueryListRequest() 6090 req.meta.CopyFrom(ListRequestMetadata()) 6091 if self.parent.page_limit > 0: 6092 req.meta.limit = self.parent.page_limit 6093 if self.parent.snapshot_datetime is not None: 6094 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6095 6096 req.filter = plumbing.quote_filter_args(filter, *args) 6097 6098 def generator(svc, req): 6099 tries = 0 6100 while True: 6101 t = None if deadline is None else deadline - time.time() 6102 try: 6103 plumbing_response = svc.stub.List( 6104 req, 6105 metadata=svc.parent.get_metadata('Queries.List', req), 6106 timeout=t) 6107 except Exception as e: 6108 if self.parent.shouldRetry(tries, e, deadline): 6109 tries += 1 6110 time.sleep( 6111 self.parent.exponentialBackoff(tries, deadline)) 6112 continue 6113 raise plumbing.convert_error_to_porcelain(e) from e 6114 tries = 0 6115 for plumbing_item in plumbing_response.queries: 6116 yield plumbing.convert_query_to_porcelain(plumbing_item) 6117 if plumbing_response.meta.next_cursor == '': 6118 break 6119 req.meta.cursor = plumbing_response.meta.next_cursor 6120 6121 return generator(self, req) 6122 6123 6124class RemoteIdentities: 6125 ''' 6126 RemoteIdentities assign a resource directly to an account, giving the account the permission to connect to that resource. 6127 See `strongdm.models.RemoteIdentity`. 6128 ''' 6129 def __init__(self, channel, client): 6130 self.parent = client 6131 self.stub = RemoteIdentitiesStub(channel) 6132 6133 def create(self, remote_identity, timeout=None): 6134 ''' 6135 Create registers a new RemoteIdentity. 6136 ''' 6137 deadline = None if timeout is None else time.time() + timeout 6138 req = RemoteIdentityCreateRequest() 6139 6140 if remote_identity is not None: 6141 req.remote_identity.CopyFrom( 6142 plumbing.convert_remote_identity_to_plumbing(remote_identity)) 6143 tries = 0 6144 plumbing_response = None 6145 while True: 6146 t = None if deadline is None else deadline - time.time() 6147 try: 6148 plumbing_response = self.stub.Create( 6149 req, 6150 metadata=self.parent.get_metadata( 6151 'RemoteIdentities.Create', req), 6152 timeout=t) 6153 except Exception as e: 6154 if self.parent.shouldRetry(tries, e, deadline): 6155 tries += 1 6156 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6157 continue 6158 raise plumbing.convert_error_to_porcelain(e) from e 6159 break 6160 6161 resp = models.RemoteIdentityCreateResponse() 6162 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 6163 plumbing_response.meta) 6164 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6165 plumbing_response.rate_limit) 6166 resp.remote_identity = plumbing.convert_remote_identity_to_porcelain( 6167 plumbing_response.remote_identity) 6168 return resp 6169 6170 def get(self, id, timeout=None): 6171 ''' 6172 Get reads one RemoteIdentity by ID. 6173 ''' 6174 deadline = None if timeout is None else time.time() + timeout 6175 req = RemoteIdentityGetRequest() 6176 if self.parent.snapshot_datetime is not None: 6177 req.meta.CopyFrom(GetRequestMetadata()) 6178 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6179 6180 req.id = (id) 6181 tries = 0 6182 plumbing_response = None 6183 while True: 6184 t = None if deadline is None else deadline - time.time() 6185 try: 6186 plumbing_response = self.stub.Get( 6187 req, 6188 metadata=self.parent.get_metadata('RemoteIdentities.Get', 6189 req), 6190 timeout=t) 6191 except Exception as e: 6192 if self.parent.shouldRetry(tries, e, deadline): 6193 tries += 1 6194 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6195 continue 6196 raise plumbing.convert_error_to_porcelain(e) from e 6197 break 6198 6199 resp = models.RemoteIdentityGetResponse() 6200 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 6201 plumbing_response.meta) 6202 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6203 plumbing_response.rate_limit) 6204 resp.remote_identity = plumbing.convert_remote_identity_to_porcelain( 6205 plumbing_response.remote_identity) 6206 return resp 6207 6208 def update(self, remote_identity, timeout=None): 6209 ''' 6210 Update replaces all the fields of a RemoteIdentity by ID. 6211 ''' 6212 deadline = None if timeout is None else time.time() + timeout 6213 req = RemoteIdentityUpdateRequest() 6214 6215 if remote_identity is not None: 6216 req.remote_identity.CopyFrom( 6217 plumbing.convert_remote_identity_to_plumbing(remote_identity)) 6218 tries = 0 6219 plumbing_response = None 6220 while True: 6221 t = None if deadline is None else deadline - time.time() 6222 try: 6223 plumbing_response = self.stub.Update( 6224 req, 6225 metadata=self.parent.get_metadata( 6226 'RemoteIdentities.Update', req), 6227 timeout=t) 6228 except Exception as e: 6229 if self.parent.shouldRetry(tries, e, deadline): 6230 tries += 1 6231 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6232 continue 6233 raise plumbing.convert_error_to_porcelain(e) from e 6234 break 6235 6236 resp = models.RemoteIdentityUpdateResponse() 6237 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 6238 plumbing_response.meta) 6239 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6240 plumbing_response.rate_limit) 6241 resp.remote_identity = plumbing.convert_remote_identity_to_porcelain( 6242 plumbing_response.remote_identity) 6243 return resp 6244 6245 def delete(self, id, timeout=None): 6246 ''' 6247 Delete removes a RemoteIdentity by ID. 6248 ''' 6249 deadline = None if timeout is None else time.time() + timeout 6250 req = RemoteIdentityDeleteRequest() 6251 6252 req.id = (id) 6253 tries = 0 6254 plumbing_response = None 6255 while True: 6256 t = None if deadline is None else deadline - time.time() 6257 try: 6258 plumbing_response = self.stub.Delete( 6259 req, 6260 metadata=self.parent.get_metadata( 6261 'RemoteIdentities.Delete', req), 6262 timeout=t) 6263 except Exception as e: 6264 if self.parent.shouldRetry(tries, e, deadline): 6265 tries += 1 6266 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6267 continue 6268 raise plumbing.convert_error_to_porcelain(e) from e 6269 break 6270 6271 resp = models.RemoteIdentityDeleteResponse() 6272 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 6273 plumbing_response.meta) 6274 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6275 plumbing_response.rate_limit) 6276 return resp 6277 6278 def list(self, filter, *args, timeout=None): 6279 ''' 6280 List gets a list of RemoteIdentities matching a given set of criteria. 6281 ''' 6282 deadline = None if timeout is None else time.time() + timeout 6283 req = RemoteIdentityListRequest() 6284 req.meta.CopyFrom(ListRequestMetadata()) 6285 if self.parent.page_limit > 0: 6286 req.meta.limit = self.parent.page_limit 6287 if self.parent.snapshot_datetime is not None: 6288 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6289 6290 req.filter = plumbing.quote_filter_args(filter, *args) 6291 6292 def generator(svc, req): 6293 tries = 0 6294 while True: 6295 t = None if deadline is None else deadline - time.time() 6296 try: 6297 plumbing_response = svc.stub.List( 6298 req, 6299 metadata=svc.parent.get_metadata( 6300 'RemoteIdentities.List', req), 6301 timeout=t) 6302 except Exception as e: 6303 if self.parent.shouldRetry(tries, e, deadline): 6304 tries += 1 6305 time.sleep( 6306 self.parent.exponentialBackoff(tries, deadline)) 6307 continue 6308 raise plumbing.convert_error_to_porcelain(e) from e 6309 tries = 0 6310 for plumbing_item in plumbing_response.remote_identities: 6311 yield plumbing.convert_remote_identity_to_porcelain( 6312 plumbing_item) 6313 if plumbing_response.meta.next_cursor == '': 6314 break 6315 req.meta.cursor = plumbing_response.meta.next_cursor 6316 6317 return generator(self, req) 6318 6319 6320class SnapshotRemoteIdentities: 6321 ''' 6322 SnapshotRemoteIdentities exposes the read only methods of the RemoteIdentities 6323 service for historical queries. 6324 ''' 6325 def __init__(self, remote_identities): 6326 self.remote_identities = remote_identities 6327 6328 def get(self, id, timeout=None): 6329 ''' 6330 Get reads one RemoteIdentity by ID. 6331 ''' 6332 return self.remote_identities.get(id, timeout=timeout) 6333 6334 def list(self, filter, *args, timeout=None): 6335 ''' 6336 List gets a list of RemoteIdentities matching a given set of criteria. 6337 ''' 6338 return self.remote_identities.list(filter, *args, timeout=timeout) 6339 6340 6341class RemoteIdentitiesHistory: 6342 ''' 6343 RemoteIdentitiesHistory records all changes to the state of a RemoteIdentity. 6344 See `strongdm.models.RemoteIdentityHistory`. 6345 ''' 6346 def __init__(self, channel, client): 6347 self.parent = client 6348 self.stub = RemoteIdentitiesHistoryStub(channel) 6349 6350 def list(self, filter, *args, timeout=None): 6351 ''' 6352 List gets a list of RemoteIdentityHistory records matching a given set of criteria. 6353 ''' 6354 deadline = None if timeout is None else time.time() + timeout 6355 req = RemoteIdentityHistoryListRequest() 6356 req.meta.CopyFrom(ListRequestMetadata()) 6357 if self.parent.page_limit > 0: 6358 req.meta.limit = self.parent.page_limit 6359 if self.parent.snapshot_datetime is not None: 6360 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6361 6362 req.filter = plumbing.quote_filter_args(filter, *args) 6363 6364 def generator(svc, req): 6365 tries = 0 6366 while True: 6367 t = None if deadline is None else deadline - time.time() 6368 try: 6369 plumbing_response = svc.stub.List( 6370 req, 6371 metadata=svc.parent.get_metadata( 6372 'RemoteIdentitiesHistory.List', req), 6373 timeout=t) 6374 except Exception as e: 6375 if self.parent.shouldRetry(tries, e, deadline): 6376 tries += 1 6377 time.sleep( 6378 self.parent.exponentialBackoff(tries, deadline)) 6379 continue 6380 raise plumbing.convert_error_to_porcelain(e) from e 6381 tries = 0 6382 for plumbing_item in plumbing_response.history: 6383 yield plumbing.convert_remote_identity_history_to_porcelain( 6384 plumbing_item) 6385 if plumbing_response.meta.next_cursor == '': 6386 break 6387 req.meta.cursor = plumbing_response.meta.next_cursor 6388 6389 return generator(self, req) 6390 6391 6392class RemoteIdentityGroups: 6393 ''' 6394 A RemoteIdentityGroup is a named grouping of Remote Identities for Accounts. 6395 An Account's relationship to a RemoteIdentityGroup is defined via RemoteIdentity objects. 6396 See `strongdm.models.RemoteIdentityGroup`. 6397 ''' 6398 def __init__(self, channel, client): 6399 self.parent = client 6400 self.stub = RemoteIdentityGroupsStub(channel) 6401 6402 def get(self, id, timeout=None): 6403 ''' 6404 Get reads one RemoteIdentityGroup by ID. 6405 ''' 6406 deadline = None if timeout is None else time.time() + timeout 6407 req = RemoteIdentityGroupGetRequest() 6408 if self.parent.snapshot_datetime is not None: 6409 req.meta.CopyFrom(GetRequestMetadata()) 6410 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6411 6412 req.id = (id) 6413 tries = 0 6414 plumbing_response = None 6415 while True: 6416 t = None if deadline is None else deadline - time.time() 6417 try: 6418 plumbing_response = self.stub.Get( 6419 req, 6420 metadata=self.parent.get_metadata( 6421 'RemoteIdentityGroups.Get', req), 6422 timeout=t) 6423 except Exception as e: 6424 if self.parent.shouldRetry(tries, e, deadline): 6425 tries += 1 6426 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6427 continue 6428 raise plumbing.convert_error_to_porcelain(e) from e 6429 break 6430 6431 resp = models.RemoteIdentityGroupGetResponse() 6432 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 6433 plumbing_response.meta) 6434 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6435 plumbing_response.rate_limit) 6436 resp.remote_identity_group = plumbing.convert_remote_identity_group_to_porcelain( 6437 plumbing_response.remote_identity_group) 6438 return resp 6439 6440 def list(self, filter, *args, timeout=None): 6441 ''' 6442 List gets a list of RemoteIdentityGroups matching a given set of criteria. 6443 ''' 6444 deadline = None if timeout is None else time.time() + timeout 6445 req = RemoteIdentityGroupListRequest() 6446 req.meta.CopyFrom(ListRequestMetadata()) 6447 if self.parent.page_limit > 0: 6448 req.meta.limit = self.parent.page_limit 6449 if self.parent.snapshot_datetime is not None: 6450 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6451 6452 req.filter = plumbing.quote_filter_args(filter, *args) 6453 6454 def generator(svc, req): 6455 tries = 0 6456 while True: 6457 t = None if deadline is None else deadline - time.time() 6458 try: 6459 plumbing_response = svc.stub.List( 6460 req, 6461 metadata=svc.parent.get_metadata( 6462 'RemoteIdentityGroups.List', req), 6463 timeout=t) 6464 except Exception as e: 6465 if self.parent.shouldRetry(tries, e, deadline): 6466 tries += 1 6467 time.sleep( 6468 self.parent.exponentialBackoff(tries, deadline)) 6469 continue 6470 raise plumbing.convert_error_to_porcelain(e) from e 6471 tries = 0 6472 for plumbing_item in plumbing_response.remote_identity_groups: 6473 yield plumbing.convert_remote_identity_group_to_porcelain( 6474 plumbing_item) 6475 if plumbing_response.meta.next_cursor == '': 6476 break 6477 req.meta.cursor = plumbing_response.meta.next_cursor 6478 6479 return generator(self, req) 6480 6481 6482class SnapshotRemoteIdentityGroups: 6483 ''' 6484 SnapshotRemoteIdentityGroups exposes the read only methods of the RemoteIdentityGroups 6485 service for historical queries. 6486 ''' 6487 def __init__(self, remote_identity_groups): 6488 self.remote_identity_groups = remote_identity_groups 6489 6490 def get(self, id, timeout=None): 6491 ''' 6492 Get reads one RemoteIdentityGroup by ID. 6493 ''' 6494 return self.remote_identity_groups.get(id, timeout=timeout) 6495 6496 def list(self, filter, *args, timeout=None): 6497 ''' 6498 List gets a list of RemoteIdentityGroups matching a given set of criteria. 6499 ''' 6500 return self.remote_identity_groups.list(filter, *args, timeout=timeout) 6501 6502 6503class RemoteIdentityGroupsHistory: 6504 ''' 6505 RemoteIdentityGroupsHistory records all changes to the state of a RemoteIdentityGroup. 6506 See `strongdm.models.RemoteIdentityGroupHistory`. 6507 ''' 6508 def __init__(self, channel, client): 6509 self.parent = client 6510 self.stub = RemoteIdentityGroupsHistoryStub(channel) 6511 6512 def list(self, filter, *args, timeout=None): 6513 ''' 6514 List gets a list of RemoteIdentityGroupHistory records matching a given set of criteria. 6515 ''' 6516 deadline = None if timeout is None else time.time() + timeout 6517 req = RemoteIdentityGroupHistoryListRequest() 6518 req.meta.CopyFrom(ListRequestMetadata()) 6519 if self.parent.page_limit > 0: 6520 req.meta.limit = self.parent.page_limit 6521 if self.parent.snapshot_datetime is not None: 6522 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6523 6524 req.filter = plumbing.quote_filter_args(filter, *args) 6525 6526 def generator(svc, req): 6527 tries = 0 6528 while True: 6529 t = None if deadline is None else deadline - time.time() 6530 try: 6531 plumbing_response = svc.stub.List( 6532 req, 6533 metadata=svc.parent.get_metadata( 6534 'RemoteIdentityGroupsHistory.List', req), 6535 timeout=t) 6536 except Exception as e: 6537 if self.parent.shouldRetry(tries, e, deadline): 6538 tries += 1 6539 time.sleep( 6540 self.parent.exponentialBackoff(tries, deadline)) 6541 continue 6542 raise plumbing.convert_error_to_porcelain(e) from e 6543 tries = 0 6544 for plumbing_item in plumbing_response.history: 6545 yield plumbing.convert_remote_identity_group_history_to_porcelain( 6546 plumbing_item) 6547 if plumbing_response.meta.next_cursor == '': 6548 break 6549 req.meta.cursor = plumbing_response.meta.next_cursor 6550 6551 return generator(self, req) 6552 6553 6554class Replays: 6555 ''' 6556 A Replay captures the data transferred over a long-running SSH, RDP, or Kubernetes interactive session 6557 (otherwise referred to as a query). The Replays service is read-only. 6558 See `strongdm.models.ReplayChunk`. 6559 ''' 6560 def __init__(self, channel, client): 6561 self.parent = client 6562 self.stub = ReplaysStub(channel) 6563 6564 def list(self, filter, *args, timeout=None): 6565 ''' 6566 List gets a list of ReplayChunks for the Query ID specified by the filter criteria. 6567 ''' 6568 deadline = None if timeout is None else time.time() + timeout 6569 req = ReplayListRequest() 6570 req.meta.CopyFrom(ListRequestMetadata()) 6571 if self.parent.page_limit > 0: 6572 req.meta.limit = self.parent.page_limit 6573 if self.parent.snapshot_datetime is not None: 6574 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6575 6576 req.filter = plumbing.quote_filter_args(filter, *args) 6577 6578 def generator(svc, req): 6579 tries = 0 6580 while True: 6581 t = None if deadline is None else deadline - time.time() 6582 try: 6583 plumbing_response = svc.stub.List( 6584 req, 6585 metadata=svc.parent.get_metadata('Replays.List', req), 6586 timeout=t) 6587 except Exception as e: 6588 if self.parent.shouldRetry(tries, e, deadline): 6589 tries += 1 6590 time.sleep( 6591 self.parent.exponentialBackoff(tries, deadline)) 6592 continue 6593 raise plumbing.convert_error_to_porcelain(e) from e 6594 tries = 0 6595 for plumbing_item in plumbing_response.chunks: 6596 yield plumbing.convert_replay_chunk_to_porcelain( 6597 plumbing_item) 6598 if plumbing_response.meta.next_cursor == '': 6599 break 6600 req.meta.cursor = plumbing_response.meta.next_cursor 6601 6602 return generator(self, req) 6603 6604 6605class RequestableAccountEntitlements: 6606 ''' 6607 RequestableAccountEntitlements enumerates the resources that an account is permitted to request access to. 6608 The RequestableAccountEntitlements service is read-only. 6609 See `strongdm.models.RequestableAccountEntitlement`. 6610 ''' 6611 def __init__(self, channel, client): 6612 self.parent = client 6613 self.stub = RequestableAccountEntitlementsStub(channel) 6614 6615 def list(self, account_id, filter, *args, timeout=None): 6616 ''' 6617 List gets a list of RequestableAccountEntitlement records matching a given set of criteria. 6618 ''' 6619 deadline = None if timeout is None else time.time() + timeout 6620 req = RequestableAccountEntitlementListRequest() 6621 req.meta.CopyFrom(ListRequestMetadata()) 6622 if self.parent.page_limit > 0: 6623 req.meta.limit = self.parent.page_limit 6624 if self.parent.snapshot_datetime is not None: 6625 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6626 6627 req.account_id = (account_id) 6628 req.filter = plumbing.quote_filter_args(filter, *args) 6629 6630 def generator(svc, req): 6631 tries = 0 6632 while True: 6633 t = None if deadline is None else deadline - time.time() 6634 try: 6635 plumbing_response = svc.stub.List( 6636 req, 6637 metadata=svc.parent.get_metadata( 6638 'RequestableAccountEntitlements.List', req), 6639 timeout=t) 6640 except Exception as e: 6641 if self.parent.shouldRetry(tries, e, deadline): 6642 tries += 1 6643 time.sleep( 6644 self.parent.exponentialBackoff(tries, deadline)) 6645 continue 6646 raise plumbing.convert_error_to_porcelain(e) from e 6647 tries = 0 6648 for plumbing_item in plumbing_response.requestable_account_entitlements: 6649 yield plumbing.convert_requestable_account_entitlement_to_porcelain( 6650 plumbing_item) 6651 if plumbing_response.meta.next_cursor == '': 6652 break 6653 req.meta.cursor = plumbing_response.meta.next_cursor 6654 6655 return generator(self, req) 6656 6657 6658class SnapshotRequestableAccountEntitlements: 6659 ''' 6660 SnapshotRequestableAccountEntitlements exposes the read only methods of the RequestableAccountEntitlements 6661 service for historical queries. 6662 ''' 6663 def __init__(self, requestable_account_entitlements): 6664 self.requestable_account_entitlements = requestable_account_entitlements 6665 6666 def list(self, account_id, filter, *args, timeout=None): 6667 ''' 6668 List gets a list of RequestableAccountEntitlement records matching a given set of criteria. 6669 ''' 6670 return self.requestable_account_entitlements.list(account_id, 6671 filter, 6672 *args, 6673 timeout=timeout) 6674 6675 6676class RequestableResourceEntitlements: 6677 ''' 6678 RequestableResourceEntitlements enumerates the accounts that are permitted to request access to a given resource. 6679 The RequestableResourceEntitlements service is read-only. 6680 See `strongdm.models.RequestableResourceEntitlement`. 6681 ''' 6682 def __init__(self, channel, client): 6683 self.parent = client 6684 self.stub = RequestableResourceEntitlementsStub(channel) 6685 6686 def list(self, resource_id, filter, *args, timeout=None): 6687 ''' 6688 List gets a list of RequestableResourceEntitlement records matching a given set of criteria. 6689 ''' 6690 deadline = None if timeout is None else time.time() + timeout 6691 req = RequestableResourceEntitlementListRequest() 6692 req.meta.CopyFrom(ListRequestMetadata()) 6693 if self.parent.page_limit > 0: 6694 req.meta.limit = self.parent.page_limit 6695 if self.parent.snapshot_datetime is not None: 6696 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6697 6698 req.resource_id = (resource_id) 6699 req.filter = plumbing.quote_filter_args(filter, *args) 6700 6701 def generator(svc, req): 6702 tries = 0 6703 while True: 6704 t = None if deadline is None else deadline - time.time() 6705 try: 6706 plumbing_response = svc.stub.List( 6707 req, 6708 metadata=svc.parent.get_metadata( 6709 'RequestableResourceEntitlements.List', req), 6710 timeout=t) 6711 except Exception as e: 6712 if self.parent.shouldRetry(tries, e, deadline): 6713 tries += 1 6714 time.sleep( 6715 self.parent.exponentialBackoff(tries, deadline)) 6716 continue 6717 raise plumbing.convert_error_to_porcelain(e) from e 6718 tries = 0 6719 for plumbing_item in plumbing_response.requestable_resource_entitlements: 6720 yield plumbing.convert_requestable_resource_entitlement_to_porcelain( 6721 plumbing_item) 6722 if plumbing_response.meta.next_cursor == '': 6723 break 6724 req.meta.cursor = plumbing_response.meta.next_cursor 6725 6726 return generator(self, req) 6727 6728 6729class SnapshotRequestableResourceEntitlements: 6730 ''' 6731 SnapshotRequestableResourceEntitlements exposes the read only methods of the RequestableResourceEntitlements 6732 service for historical queries. 6733 ''' 6734 def __init__(self, requestable_resource_entitlements): 6735 self.requestable_resource_entitlements = requestable_resource_entitlements 6736 6737 def list(self, resource_id, filter, *args, timeout=None): 6738 ''' 6739 List gets a list of RequestableResourceEntitlement records matching a given set of criteria. 6740 ''' 6741 return self.requestable_resource_entitlements.list(resource_id, 6742 filter, 6743 *args, 6744 timeout=timeout) 6745 6746 6747class RequestableRoleEntitlements: 6748 ''' 6749 RequestableRoleEntitlements enumerates the resources that a role permits its members to request access to. 6750 The RequestableRoleEntitlements service is read-only. 6751 See `strongdm.models.RequestableRoleEntitlement`. 6752 ''' 6753 def __init__(self, channel, client): 6754 self.parent = client 6755 self.stub = RequestableRoleEntitlementsStub(channel) 6756 6757 def list(self, role_id, filter, *args, timeout=None): 6758 ''' 6759 List gets a list of RequestableRoleEntitlement records matching a given set of criteria. 6760 ''' 6761 deadline = None if timeout is None else time.time() + timeout 6762 req = RequestableRoleEntitlementListRequest() 6763 req.meta.CopyFrom(ListRequestMetadata()) 6764 if self.parent.page_limit > 0: 6765 req.meta.limit = self.parent.page_limit 6766 if self.parent.snapshot_datetime is not None: 6767 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6768 6769 req.role_id = (role_id) 6770 req.filter = plumbing.quote_filter_args(filter, *args) 6771 6772 def generator(svc, req): 6773 tries = 0 6774 while True: 6775 t = None if deadline is None else deadline - time.time() 6776 try: 6777 plumbing_response = svc.stub.List( 6778 req, 6779 metadata=svc.parent.get_metadata( 6780 'RequestableRoleEntitlements.List', req), 6781 timeout=t) 6782 except Exception as e: 6783 if self.parent.shouldRetry(tries, e, deadline): 6784 tries += 1 6785 time.sleep( 6786 self.parent.exponentialBackoff(tries, deadline)) 6787 continue 6788 raise plumbing.convert_error_to_porcelain(e) from e 6789 tries = 0 6790 for plumbing_item in plumbing_response.requestable_role_entitlements: 6791 yield plumbing.convert_requestable_role_entitlement_to_porcelain( 6792 plumbing_item) 6793 if plumbing_response.meta.next_cursor == '': 6794 break 6795 req.meta.cursor = plumbing_response.meta.next_cursor 6796 6797 return generator(self, req) 6798 6799 6800class SnapshotRequestableRoleEntitlements: 6801 ''' 6802 SnapshotRequestableRoleEntitlements exposes the read only methods of the RequestableRoleEntitlements 6803 service for historical queries. 6804 ''' 6805 def __init__(self, requestable_role_entitlements): 6806 self.requestable_role_entitlements = requestable_role_entitlements 6807 6808 def list(self, role_id, filter, *args, timeout=None): 6809 ''' 6810 List gets a list of RequestableRoleEntitlement records matching a given set of criteria. 6811 ''' 6812 return self.requestable_role_entitlements.list(role_id, 6813 filter, 6814 *args, 6815 timeout=timeout) 6816 6817 6818class Resources: 6819 ''' 6820 Resources are databases, servers, clusters, websites, or clouds that strongDM 6821 delegates access to. 6822 See: 6823 `strongdm.models.Aerospike` 6824 `strongdm.models.AKS` 6825 `strongdm.models.AKSBasicAuth` 6826 `strongdm.models.AKSServiceAccount` 6827 `strongdm.models.AKSServiceAccountUserImpersonation` 6828 `strongdm.models.AKSUserImpersonation` 6829 `strongdm.models.AmazonEKS` 6830 `strongdm.models.AmazonEKSInstanceProfile` 6831 `strongdm.models.AmazonEKSInstanceProfileUserImpersonation` 6832 `strongdm.models.AmazonEKSUserImpersonation` 6833 `strongdm.models.AmazonES` 6834 `strongdm.models.AmazonESIAM` 6835 `strongdm.models.AmazonMQAMQP091` 6836 `strongdm.models.AMQP` 6837 `strongdm.models.Athena` 6838 `strongdm.models.AthenaIAM` 6839 `strongdm.models.AuroraMysql` 6840 `strongdm.models.AuroraMysqlIAM` 6841 `strongdm.models.AuroraPostgres` 6842 `strongdm.models.AuroraPostgresIAM` 6843 `strongdm.models.AWS` 6844 `strongdm.models.AWSConsole` 6845 `strongdm.models.AWSConsoleStaticKeyPair` 6846 `strongdm.models.AWSInstanceProfile` 6847 `strongdm.models.Azure` 6848 `strongdm.models.AzureCertificate` 6849 `strongdm.models.AzureMysql` 6850 `strongdm.models.AzureMysqlManagedIdentity` 6851 `strongdm.models.AzurePostgres` 6852 `strongdm.models.AzurePostgresManagedIdentity` 6853 `strongdm.models.BigQuery` 6854 `strongdm.models.Cassandra` 6855 `strongdm.models.Citus` 6856 `strongdm.models.ClickHouseHTTP` 6857 `strongdm.models.ClickHouseMySQL` 6858 `strongdm.models.ClickHouseTCP` 6859 `strongdm.models.Clustrix` 6860 `strongdm.models.Cockroach` 6861 `strongdm.models.CouchbaseDatabase` 6862 `strongdm.models.CouchbaseWebUI` 6863 `strongdm.models.Databricks` 6864 `strongdm.models.DB2I` 6865 `strongdm.models.DB2LUW` 6866 `strongdm.models.DocumentDBHost` 6867 `strongdm.models.DocumentDBHostIAM` 6868 `strongdm.models.DocumentDBReplicaSet` 6869 `strongdm.models.DocumentDBReplicaSetIAM` 6870 `strongdm.models.Druid` 6871 `strongdm.models.DynamoDB` 6872 `strongdm.models.DynamoDBIAM` 6873 `strongdm.models.Elastic` 6874 `strongdm.models.ElasticacheRedis` 6875 `strongdm.models.ElasticacheRedisIAM` 6876 `strongdm.models.EntraID` 6877 `strongdm.models.GCP` 6878 `strongdm.models.GCPConsole` 6879 `strongdm.models.GCPWIF` 6880 `strongdm.models.GoogleGKE` 6881 `strongdm.models.GoogleGKEUserImpersonation` 6882 `strongdm.models.GoogleSpanner` 6883 `strongdm.models.Greenplum` 6884 `strongdm.models.HTTPAuth` 6885 `strongdm.models.HTTPBasicAuth` 6886 `strongdm.models.HTTPNoAuth` 6887 `strongdm.models.Kubernetes` 6888 `strongdm.models.KubernetesBasicAuth` 6889 `strongdm.models.KubernetesPodIdentity` 6890 `strongdm.models.KubernetesServiceAccount` 6891 `strongdm.models.KubernetesServiceAccountUserImpersonation` 6892 `strongdm.models.KubernetesUserImpersonation` 6893 `strongdm.models.Maria` 6894 `strongdm.models.MCPGatewayNoAuth` 6895 `strongdm.models.MCPGatewayOAuth` 6896 `strongdm.models.MCPGatewayOAuthDCR` 6897 `strongdm.models.MCPGatewayPAT` 6898 `strongdm.models.Memcached` 6899 `strongdm.models.Memsql` 6900 `strongdm.models.MongoHost` 6901 `strongdm.models.MongoLegacyHost` 6902 `strongdm.models.MongoLegacyReplicaset` 6903 `strongdm.models.MongoReplicaSet` 6904 `strongdm.models.MongoShardedCluster` 6905 `strongdm.models.MTLSMysql` 6906 `strongdm.models.MTLSPostgres` 6907 `strongdm.models.Mysql` 6908 `strongdm.models.Neptune` 6909 `strongdm.models.NeptuneIAM` 6910 `strongdm.models.OktaGroups` 6911 `strongdm.models.Oracle` 6912 `strongdm.models.OracleNNE` 6913 `strongdm.models.Postgres` 6914 `strongdm.models.Presto` 6915 `strongdm.models.RabbitMQAMQP091` 6916 `strongdm.models.RawTCP` 6917 `strongdm.models.RDP` 6918 `strongdm.models.RDPCert` 6919 `strongdm.models.RDSPostgresIAM` 6920 `strongdm.models.Redis` 6921 `strongdm.models.RedisCluster` 6922 `strongdm.models.Redshift` 6923 `strongdm.models.RedshiftIAM` 6924 `strongdm.models.RedshiftServerlessIAM` 6925 `strongdm.models.SingleStore` 6926 `strongdm.models.Snowflake` 6927 `strongdm.models.Snowsight` 6928 `strongdm.models.SQLServer` 6929 `strongdm.models.SQLServerAzureAD` 6930 `strongdm.models.SQLServerKerberosAD` 6931 `strongdm.models.SSH` 6932 `strongdm.models.SSHCert` 6933 `strongdm.models.SSHCustomerKey` 6934 `strongdm.models.SSHPassword` 6935 `strongdm.models.Sybase` 6936 `strongdm.models.SybaseIQ` 6937 `strongdm.models.Teradata` 6938 `strongdm.models.Trino` 6939 `strongdm.models.Vertica` 6940 ''' 6941 def __init__(self, channel, client): 6942 self.parent = client 6943 self.stub = ResourcesStub(channel) 6944 6945 def enumerate_tags(self, filter, *args, timeout=None): 6946 ''' 6947 EnumerateTags gets a list of the filter matching tags. 6948 ''' 6949 deadline = None if timeout is None else time.time() + timeout 6950 req = EnumerateTagsRequest() 6951 req.meta.CopyFrom(ListRequestMetadata()) 6952 if self.parent.page_limit > 0: 6953 req.meta.limit = self.parent.page_limit 6954 if self.parent.snapshot_datetime is not None: 6955 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6956 6957 req.filter = plumbing.quote_filter_args(filter, *args) 6958 6959 def generator(svc, req): 6960 tries = 0 6961 while True: 6962 t = None if deadline is None else deadline - time.time() 6963 try: 6964 plumbing_response = svc.stub.EnumerateTags( 6965 req, 6966 metadata=svc.parent.get_metadata( 6967 'Resources.EnumerateTags', req), 6968 timeout=t) 6969 except Exception as e: 6970 if self.parent.shouldRetry(tries, e, deadline): 6971 tries += 1 6972 time.sleep( 6973 self.parent.exponentialBackoff(tries, deadline)) 6974 continue 6975 raise plumbing.convert_error_to_porcelain(e) from e 6976 tries = 0 6977 for plumbing_item in plumbing_response.matches: 6978 yield plumbing.convert_tag_to_porcelain(plumbing_item) 6979 if plumbing_response.meta.next_cursor == '': 6980 break 6981 req.meta.cursor = plumbing_response.meta.next_cursor 6982 6983 return generator(self, req) 6984 6985 def create(self, resource, timeout=None): 6986 ''' 6987 Create registers a new Resource. 6988 ''' 6989 deadline = None if timeout is None else time.time() + timeout 6990 req = ResourceCreateRequest() 6991 6992 if resource is not None: 6993 req.resource.CopyFrom( 6994 plumbing.convert_resource_to_plumbing(resource)) 6995 tries = 0 6996 plumbing_response = None 6997 while True: 6998 t = None if deadline is None else deadline - time.time() 6999 try: 7000 plumbing_response = self.stub.Create( 7001 req, 7002 metadata=self.parent.get_metadata('Resources.Create', req), 7003 timeout=t) 7004 except Exception as e: 7005 if self.parent.shouldRetry(tries, e, deadline): 7006 tries += 1 7007 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7008 continue 7009 raise plumbing.convert_error_to_porcelain(e) from e 7010 break 7011 7012 resp = models.ResourceCreateResponse() 7013 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 7014 plumbing_response.meta) 7015 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7016 plumbing_response.rate_limit) 7017 resp.resource = plumbing.convert_resource_to_porcelain( 7018 plumbing_response.resource) 7019 return resp 7020 7021 def get(self, id, timeout=None): 7022 ''' 7023 Get reads one Resource by ID. 7024 ''' 7025 deadline = None if timeout is None else time.time() + timeout 7026 req = ResourceGetRequest() 7027 if self.parent.snapshot_datetime is not None: 7028 req.meta.CopyFrom(GetRequestMetadata()) 7029 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7030 7031 req.id = (id) 7032 tries = 0 7033 plumbing_response = None 7034 while True: 7035 t = None if deadline is None else deadline - time.time() 7036 try: 7037 plumbing_response = self.stub.Get( 7038 req, 7039 metadata=self.parent.get_metadata('Resources.Get', req), 7040 timeout=t) 7041 except Exception as e: 7042 if self.parent.shouldRetry(tries, e, deadline): 7043 tries += 1 7044 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7045 continue 7046 raise plumbing.convert_error_to_porcelain(e) from e 7047 break 7048 7049 resp = models.ResourceGetResponse() 7050 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 7051 plumbing_response.meta) 7052 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7053 plumbing_response.rate_limit) 7054 resp.resource = plumbing.convert_resource_to_porcelain( 7055 plumbing_response.resource) 7056 return resp 7057 7058 def update(self, resource, timeout=None): 7059 ''' 7060 Update replaces all the fields of a Resource by ID. 7061 ''' 7062 deadline = None if timeout is None else time.time() + timeout 7063 req = ResourceUpdateRequest() 7064 7065 if resource is not None: 7066 req.resource.CopyFrom( 7067 plumbing.convert_resource_to_plumbing(resource)) 7068 tries = 0 7069 plumbing_response = None 7070 while True: 7071 t = None if deadline is None else deadline - time.time() 7072 try: 7073 plumbing_response = self.stub.Update( 7074 req, 7075 metadata=self.parent.get_metadata('Resources.Update', req), 7076 timeout=t) 7077 except Exception as e: 7078 if self.parent.shouldRetry(tries, e, deadline): 7079 tries += 1 7080 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7081 continue 7082 raise plumbing.convert_error_to_porcelain(e) from e 7083 break 7084 7085 resp = models.ResourceUpdateResponse() 7086 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 7087 plumbing_response.meta) 7088 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7089 plumbing_response.rate_limit) 7090 resp.resource = plumbing.convert_resource_to_porcelain( 7091 plumbing_response.resource) 7092 return resp 7093 7094 def delete(self, id, timeout=None): 7095 ''' 7096 Delete removes a Resource by ID. 7097 ''' 7098 deadline = None if timeout is None else time.time() + timeout 7099 req = ResourceDeleteRequest() 7100 7101 req.id = (id) 7102 tries = 0 7103 plumbing_response = None 7104 while True: 7105 t = None if deadline is None else deadline - time.time() 7106 try: 7107 plumbing_response = self.stub.Delete( 7108 req, 7109 metadata=self.parent.get_metadata('Resources.Delete', req), 7110 timeout=t) 7111 except Exception as e: 7112 if self.parent.shouldRetry(tries, e, deadline): 7113 tries += 1 7114 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7115 continue 7116 raise plumbing.convert_error_to_porcelain(e) from e 7117 break 7118 7119 resp = models.ResourceDeleteResponse() 7120 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 7121 plumbing_response.meta) 7122 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7123 plumbing_response.rate_limit) 7124 return resp 7125 7126 def list(self, filter, *args, timeout=None): 7127 ''' 7128 List gets a list of Resources matching a given set of criteria. 7129 ''' 7130 deadline = None if timeout is None else time.time() + timeout 7131 req = ResourceListRequest() 7132 req.meta.CopyFrom(ListRequestMetadata()) 7133 if self.parent.page_limit > 0: 7134 req.meta.limit = self.parent.page_limit 7135 if self.parent.snapshot_datetime is not None: 7136 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7137 7138 req.filter = plumbing.quote_filter_args(filter, *args) 7139 7140 def generator(svc, req): 7141 tries = 0 7142 while True: 7143 t = None if deadline is None else deadline - time.time() 7144 try: 7145 plumbing_response = svc.stub.List( 7146 req, 7147 metadata=svc.parent.get_metadata( 7148 'Resources.List', req), 7149 timeout=t) 7150 except Exception as e: 7151 if self.parent.shouldRetry(tries, e, deadline): 7152 tries += 1 7153 time.sleep( 7154 self.parent.exponentialBackoff(tries, deadline)) 7155 continue 7156 raise plumbing.convert_error_to_porcelain(e) from e 7157 tries = 0 7158 for plumbing_item in plumbing_response.resources: 7159 yield plumbing.convert_resource_to_porcelain(plumbing_item) 7160 if plumbing_response.meta.next_cursor == '': 7161 break 7162 req.meta.cursor = plumbing_response.meta.next_cursor 7163 7164 return generator(self, req) 7165 7166 def healthcheck(self, id, timeout=None): 7167 ''' 7168 Healthcheck triggers a remote healthcheck. It may take minutes to propagate across a 7169 large network of Nodes. The call will return immediately, and the updated health of the 7170 Resource can be retrieved via Get or List. 7171 ''' 7172 deadline = None if timeout is None else time.time() + timeout 7173 req = ResourceHealthcheckRequest() 7174 7175 req.id = (id) 7176 tries = 0 7177 plumbing_response = None 7178 while True: 7179 t = None if deadline is None else deadline - time.time() 7180 try: 7181 plumbing_response = self.stub.Healthcheck( 7182 req, 7183 metadata=self.parent.get_metadata('Resources.Healthcheck', 7184 req), 7185 timeout=t) 7186 except Exception as e: 7187 if self.parent.shouldRetry(tries, e, deadline): 7188 tries += 1 7189 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7190 continue 7191 raise plumbing.convert_error_to_porcelain(e) from e 7192 break 7193 7194 resp = models.ResourceHealthcheckResponse() 7195 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 7196 plumbing_response.meta) 7197 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7198 plumbing_response.rate_limit) 7199 return resp 7200 7201 7202class SnapshotResources: 7203 ''' 7204 SnapshotResources exposes the read only methods of the Resources 7205 service for historical queries. 7206 ''' 7207 def __init__(self, resources): 7208 self.resources = resources 7209 7210 def get(self, id, timeout=None): 7211 ''' 7212 Get reads one Resource by ID. 7213 ''' 7214 return self.resources.get(id, timeout=timeout) 7215 7216 def list(self, filter, *args, timeout=None): 7217 ''' 7218 List gets a list of Resources matching a given set of criteria. 7219 ''' 7220 return self.resources.list(filter, *args, timeout=timeout) 7221 7222 7223class ResourcesHistory: 7224 ''' 7225 ResourcesHistory records all changes to the state of a Resource. 7226 See `strongdm.models.ResourceHistory`. 7227 ''' 7228 def __init__(self, channel, client): 7229 self.parent = client 7230 self.stub = ResourcesHistoryStub(channel) 7231 7232 def list(self, filter, *args, timeout=None): 7233 ''' 7234 List gets a list of ResourceHistory records matching a given set of criteria. 7235 ''' 7236 deadline = None if timeout is None else time.time() + timeout 7237 req = ResourceHistoryListRequest() 7238 req.meta.CopyFrom(ListRequestMetadata()) 7239 if self.parent.page_limit > 0: 7240 req.meta.limit = self.parent.page_limit 7241 if self.parent.snapshot_datetime is not None: 7242 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7243 7244 req.filter = plumbing.quote_filter_args(filter, *args) 7245 7246 def generator(svc, req): 7247 tries = 0 7248 while True: 7249 t = None if deadline is None else deadline - time.time() 7250 try: 7251 plumbing_response = svc.stub.List( 7252 req, 7253 metadata=svc.parent.get_metadata( 7254 'ResourcesHistory.List', req), 7255 timeout=t) 7256 except Exception as e: 7257 if self.parent.shouldRetry(tries, e, deadline): 7258 tries += 1 7259 time.sleep( 7260 self.parent.exponentialBackoff(tries, deadline)) 7261 continue 7262 raise plumbing.convert_error_to_porcelain(e) from e 7263 tries = 0 7264 for plumbing_item in plumbing_response.history: 7265 yield plumbing.convert_resource_history_to_porcelain( 7266 plumbing_item) 7267 if plumbing_response.meta.next_cursor == '': 7268 break 7269 req.meta.cursor = plumbing_response.meta.next_cursor 7270 7271 return generator(self, req) 7272 7273 7274class RoleResources: 7275 ''' 7276 RoleResources enumerates the resources to which roles have access. 7277 The RoleResources service is read-only. 7278 See `strongdm.models.RoleResource`. 7279 ''' 7280 def __init__(self, channel, client): 7281 self.parent = client 7282 self.stub = RoleResourcesStub(channel) 7283 7284 def list(self, filter, *args, timeout=None): 7285 ''' 7286 List gets a list of RoleResource records matching a given set of criteria. 7287 ''' 7288 deadline = None if timeout is None else time.time() + timeout 7289 req = RoleResourceListRequest() 7290 req.meta.CopyFrom(ListRequestMetadata()) 7291 if self.parent.page_limit > 0: 7292 req.meta.limit = self.parent.page_limit 7293 if self.parent.snapshot_datetime is not None: 7294 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7295 7296 req.filter = plumbing.quote_filter_args(filter, *args) 7297 7298 def generator(svc, req): 7299 tries = 0 7300 while True: 7301 t = None if deadline is None else deadline - time.time() 7302 try: 7303 plumbing_response = svc.stub.List( 7304 req, 7305 metadata=svc.parent.get_metadata( 7306 'RoleResources.List', req), 7307 timeout=t) 7308 except Exception as e: 7309 if self.parent.shouldRetry(tries, e, deadline): 7310 tries += 1 7311 time.sleep( 7312 self.parent.exponentialBackoff(tries, deadline)) 7313 continue 7314 raise plumbing.convert_error_to_porcelain(e) from e 7315 tries = 0 7316 for plumbing_item in plumbing_response.role_resources: 7317 yield plumbing.convert_role_resource_to_porcelain( 7318 plumbing_item) 7319 if plumbing_response.meta.next_cursor == '': 7320 break 7321 req.meta.cursor = plumbing_response.meta.next_cursor 7322 7323 return generator(self, req) 7324 7325 7326class SnapshotRoleResources: 7327 ''' 7328 SnapshotRoleResources exposes the read only methods of the RoleResources 7329 service for historical queries. 7330 ''' 7331 def __init__(self, role_resources): 7332 self.role_resources = role_resources 7333 7334 def list(self, filter, *args, timeout=None): 7335 ''' 7336 List gets a list of RoleResource records matching a given set of criteria. 7337 ''' 7338 return self.role_resources.list(filter, *args, timeout=timeout) 7339 7340 7341class RoleResourcesHistory: 7342 ''' 7343 RoleResourcesHistory records all changes to the state of a RoleResource. 7344 See `strongdm.models.RoleResourceHistory`. 7345 ''' 7346 def __init__(self, channel, client): 7347 self.parent = client 7348 self.stub = RoleResourcesHistoryStub(channel) 7349 7350 def list(self, filter, *args, timeout=None): 7351 ''' 7352 List gets a list of RoleResourceHistory records matching a given set of criteria. 7353 ''' 7354 deadline = None if timeout is None else time.time() + timeout 7355 req = RoleResourceHistoryListRequest() 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 'RoleResourcesHistory.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_role_resource_history_to_porcelain( 7384 plumbing_item) 7385 if plumbing_response.meta.next_cursor == '': 7386 break 7387 req.meta.cursor = plumbing_response.meta.next_cursor 7388 7389 return generator(self, req) 7390 7391 7392class RolesHistory: 7393 ''' 7394 RolesHistory records all changes to the state of a Role. 7395 See `strongdm.models.RoleHistory`. 7396 ''' 7397 def __init__(self, channel, client): 7398 self.parent = client 7399 self.stub = RolesHistoryStub(channel) 7400 7401 def list(self, filter, *args, timeout=None): 7402 ''' 7403 List gets a list of RoleHistory records matching a given set of criteria. 7404 ''' 7405 deadline = None if timeout is None else time.time() + timeout 7406 req = RoleHistoryListRequest() 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 'RolesHistory.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.history: 7434 yield plumbing.convert_role_history_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 SecretStores: 7444 ''' 7445 SecretStores are servers where resource secrets (passwords, keys) are stored. 7446 See: 7447 `strongdm.models.ActiveDirectoryStore` 7448 `strongdm.models.AWSStore` 7449 `strongdm.models.AWSCertX509Store` 7450 `strongdm.models.AzureStore` 7451 `strongdm.models.CyberarkConjurStore` 7452 `strongdm.models.CyberarkPAMStore` 7453 `strongdm.models.CyberarkPAMExperimentalStore` 7454 `strongdm.models.DelineaStore` 7455 `strongdm.models.GCPStore` 7456 `strongdm.models.GCPCertX509Store` 7457 `strongdm.models.KeyfactorSSHStore` 7458 `strongdm.models.KeyfactorX509Store` 7459 `strongdm.models.StrongVaultStore` 7460 `strongdm.models.VaultAppRoleStore` 7461 `strongdm.models.VaultAppRoleCertSSHStore` 7462 `strongdm.models.VaultAppRoleCertX509Store` 7463 `strongdm.models.VaultAWSEC2Store` 7464 `strongdm.models.VaultAWSEC2CertSSHStore` 7465 `strongdm.models.VaultAWSEC2CertX509Store` 7466 `strongdm.models.VaultAWSIAMStore` 7467 `strongdm.models.VaultAWSIAMCertSSHStore` 7468 `strongdm.models.VaultAWSIAMCertX509Store` 7469 `strongdm.models.VaultTLSStore` 7470 `strongdm.models.VaultTLSCertSSHStore` 7471 `strongdm.models.VaultTLSCertX509Store` 7472 `strongdm.models.VaultTokenStore` 7473 `strongdm.models.VaultTokenCertSSHStore` 7474 `strongdm.models.VaultTokenCertX509Store` 7475 ''' 7476 def __init__(self, channel, client): 7477 self.parent = client 7478 self.stub = SecretStoresStub(channel) 7479 7480 def create(self, secret_store, timeout=None): 7481 deadline = None if timeout is None else time.time() + timeout 7482 req = SecretStoreCreateRequest() 7483 7484 if secret_store is not None: 7485 req.secret_store.CopyFrom( 7486 plumbing.convert_secret_store_to_plumbing(secret_store)) 7487 tries = 0 7488 plumbing_response = None 7489 while True: 7490 t = None if deadline is None else deadline - time.time() 7491 try: 7492 plumbing_response = self.stub.Create( 7493 req, 7494 metadata=self.parent.get_metadata('SecretStores.Create', 7495 req), 7496 timeout=t) 7497 except Exception as e: 7498 if self.parent.shouldRetry(tries, e, deadline): 7499 tries += 1 7500 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7501 continue 7502 raise plumbing.convert_error_to_porcelain(e) from e 7503 break 7504 7505 resp = models.SecretStoreCreateResponse() 7506 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 7507 plumbing_response.meta) 7508 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7509 plumbing_response.rate_limit) 7510 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 7511 plumbing_response.secret_store) 7512 return resp 7513 7514 def get(self, id, timeout=None): 7515 ''' 7516 Get reads one SecretStore by ID. 7517 ''' 7518 deadline = None if timeout is None else time.time() + timeout 7519 req = SecretStoreGetRequest() 7520 if self.parent.snapshot_datetime is not None: 7521 req.meta.CopyFrom(GetRequestMetadata()) 7522 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7523 7524 req.id = (id) 7525 tries = 0 7526 plumbing_response = None 7527 while True: 7528 t = None if deadline is None else deadline - time.time() 7529 try: 7530 plumbing_response = self.stub.Get( 7531 req, 7532 metadata=self.parent.get_metadata('SecretStores.Get', req), 7533 timeout=t) 7534 except Exception as e: 7535 if self.parent.shouldRetry(tries, e, deadline): 7536 tries += 1 7537 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7538 continue 7539 raise plumbing.convert_error_to_porcelain(e) from e 7540 break 7541 7542 resp = models.SecretStoreGetResponse() 7543 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 7544 plumbing_response.meta) 7545 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7546 plumbing_response.rate_limit) 7547 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 7548 plumbing_response.secret_store) 7549 return resp 7550 7551 def update(self, secret_store, timeout=None): 7552 ''' 7553 Update replaces all the fields of a SecretStore by ID. 7554 ''' 7555 deadline = None if timeout is None else time.time() + timeout 7556 req = SecretStoreUpdateRequest() 7557 7558 if secret_store is not None: 7559 req.secret_store.CopyFrom( 7560 plumbing.convert_secret_store_to_plumbing(secret_store)) 7561 tries = 0 7562 plumbing_response = None 7563 while True: 7564 t = None if deadline is None else deadline - time.time() 7565 try: 7566 plumbing_response = self.stub.Update( 7567 req, 7568 metadata=self.parent.get_metadata('SecretStores.Update', 7569 req), 7570 timeout=t) 7571 except Exception as e: 7572 if self.parent.shouldRetry(tries, e, deadline): 7573 tries += 1 7574 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7575 continue 7576 raise plumbing.convert_error_to_porcelain(e) from e 7577 break 7578 7579 resp = models.SecretStoreUpdateResponse() 7580 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 7581 plumbing_response.meta) 7582 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7583 plumbing_response.rate_limit) 7584 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 7585 plumbing_response.secret_store) 7586 return resp 7587 7588 def delete(self, id, timeout=None): 7589 ''' 7590 Delete removes a SecretStore by ID. 7591 ''' 7592 deadline = None if timeout is None else time.time() + timeout 7593 req = SecretStoreDeleteRequest() 7594 7595 req.id = (id) 7596 tries = 0 7597 plumbing_response = None 7598 while True: 7599 t = None if deadline is None else deadline - time.time() 7600 try: 7601 plumbing_response = self.stub.Delete( 7602 req, 7603 metadata=self.parent.get_metadata('SecretStores.Delete', 7604 req), 7605 timeout=t) 7606 except Exception as e: 7607 if self.parent.shouldRetry(tries, e, deadline): 7608 tries += 1 7609 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7610 continue 7611 raise plumbing.convert_error_to_porcelain(e) from e 7612 break 7613 7614 resp = models.SecretStoreDeleteResponse() 7615 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 7616 plumbing_response.meta) 7617 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7618 plumbing_response.rate_limit) 7619 return resp 7620 7621 def list(self, filter, *args, timeout=None): 7622 ''' 7623 List gets a list of SecretStores matching a given set of criteria. 7624 ''' 7625 deadline = None if timeout is None else time.time() + timeout 7626 req = SecretStoreListRequest() 7627 req.meta.CopyFrom(ListRequestMetadata()) 7628 if self.parent.page_limit > 0: 7629 req.meta.limit = self.parent.page_limit 7630 if self.parent.snapshot_datetime is not None: 7631 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7632 7633 req.filter = plumbing.quote_filter_args(filter, *args) 7634 7635 def generator(svc, req): 7636 tries = 0 7637 while True: 7638 t = None if deadline is None else deadline - time.time() 7639 try: 7640 plumbing_response = svc.stub.List( 7641 req, 7642 metadata=svc.parent.get_metadata( 7643 'SecretStores.List', req), 7644 timeout=t) 7645 except Exception as e: 7646 if self.parent.shouldRetry(tries, e, deadline): 7647 tries += 1 7648 time.sleep( 7649 self.parent.exponentialBackoff(tries, deadline)) 7650 continue 7651 raise plumbing.convert_error_to_porcelain(e) from e 7652 tries = 0 7653 for plumbing_item in plumbing_response.secret_stores: 7654 yield plumbing.convert_secret_store_to_porcelain( 7655 plumbing_item) 7656 if plumbing_response.meta.next_cursor == '': 7657 break 7658 req.meta.cursor = plumbing_response.meta.next_cursor 7659 7660 return generator(self, req) 7661 7662 7663class SnapshotSecretStores: 7664 ''' 7665 SnapshotSecretStores exposes the read only methods of the SecretStores 7666 service for historical queries. 7667 ''' 7668 def __init__(self, secret_stores): 7669 self.secret_stores = secret_stores 7670 7671 def get(self, id, timeout=None): 7672 ''' 7673 Get reads one SecretStore by ID. 7674 ''' 7675 return self.secret_stores.get(id, timeout=timeout) 7676 7677 def list(self, filter, *args, timeout=None): 7678 ''' 7679 List gets a list of SecretStores matching a given set of criteria. 7680 ''' 7681 return self.secret_stores.list(filter, *args, timeout=timeout) 7682 7683 7684class SecretEngines: 7685 ''' 7686 7687 See: 7688 `strongdm.models.ActiveDirectoryEngine` 7689 `strongdm.models.KeyValueEngine` 7690 `strongdm.models.MysqlEngine` 7691 `strongdm.models.PostgresEngine` 7692 `strongdm.models.SqlserverEngine` 7693 ''' 7694 def __init__(self, channel, client): 7695 self.parent = client 7696 self.stub = SecretEnginesStub(channel) 7697 7698 def list(self, filter, *args, timeout=None): 7699 ''' 7700 List returns a list of Secret Engines 7701 ''' 7702 deadline = None if timeout is None else time.time() + timeout 7703 req = SecretEngineListRequest() 7704 req.meta.CopyFrom(ListRequestMetadata()) 7705 if self.parent.page_limit > 0: 7706 req.meta.limit = self.parent.page_limit 7707 if self.parent.snapshot_datetime is not None: 7708 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7709 7710 req.filter = plumbing.quote_filter_args(filter, *args) 7711 7712 def generator(svc, req): 7713 tries = 0 7714 while True: 7715 t = None if deadline is None else deadline - time.time() 7716 try: 7717 plumbing_response = svc.stub.List( 7718 req, 7719 metadata=svc.parent.get_metadata( 7720 'SecretEngines.List', req), 7721 timeout=t) 7722 except Exception as e: 7723 if self.parent.shouldRetry(tries, e, deadline): 7724 tries += 1 7725 time.sleep( 7726 self.parent.exponentialBackoff(tries, deadline)) 7727 continue 7728 raise plumbing.convert_error_to_porcelain(e) from e 7729 tries = 0 7730 for plumbing_item in plumbing_response.secret_engines: 7731 yield plumbing.convert_secret_engine_to_porcelain( 7732 plumbing_item) 7733 if plumbing_response.meta.next_cursor == '': 7734 break 7735 req.meta.cursor = plumbing_response.meta.next_cursor 7736 7737 return generator(self, req) 7738 7739 def get(self, id, timeout=None): 7740 ''' 7741 Get returns a secret engine details 7742 ''' 7743 deadline = None if timeout is None else time.time() + timeout 7744 req = SecretEngineGetRequest() 7745 if self.parent.snapshot_datetime is not None: 7746 req.meta.CopyFrom(GetRequestMetadata()) 7747 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7748 7749 req.id = (id) 7750 tries = 0 7751 plumbing_response = None 7752 while True: 7753 t = None if deadline is None else deadline - time.time() 7754 try: 7755 plumbing_response = self.stub.Get( 7756 req, 7757 metadata=self.parent.get_metadata('SecretEngines.Get', 7758 req), 7759 timeout=t) 7760 except Exception as e: 7761 if self.parent.shouldRetry(tries, e, deadline): 7762 tries += 1 7763 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7764 continue 7765 raise plumbing.convert_error_to_porcelain(e) from e 7766 break 7767 7768 resp = models.SecretEngineGetResponse() 7769 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 7770 plumbing_response.meta) 7771 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7772 plumbing_response.rate_limit) 7773 resp.secret_engine = plumbing.convert_secret_engine_to_porcelain( 7774 plumbing_response.secret_engine) 7775 return resp 7776 7777 def create(self, secret_engine, timeout=None): 7778 ''' 7779 Create creates a secret engine 7780 ''' 7781 deadline = None if timeout is None else time.time() + timeout 7782 req = SecretEngineCreateRequest() 7783 7784 if secret_engine is not None: 7785 req.secret_engine.CopyFrom( 7786 plumbing.convert_secret_engine_to_plumbing(secret_engine)) 7787 tries = 0 7788 plumbing_response = None 7789 while True: 7790 t = None if deadline is None else deadline - time.time() 7791 try: 7792 plumbing_response = self.stub.Create( 7793 req, 7794 metadata=self.parent.get_metadata('SecretEngines.Create', 7795 req), 7796 timeout=t) 7797 except Exception as e: 7798 if self.parent.shouldRetry(tries, e, deadline): 7799 tries += 1 7800 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7801 continue 7802 raise plumbing.convert_error_to_porcelain(e) from e 7803 break 7804 7805 resp = models.SecretEngineCreateResponse() 7806 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 7807 plumbing_response.meta) 7808 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7809 plumbing_response.rate_limit) 7810 resp.secret_engine = plumbing.convert_secret_engine_to_porcelain( 7811 plumbing_response.secret_engine) 7812 return resp 7813 7814 def update(self, secret_engine, timeout=None): 7815 ''' 7816 Update updates a secret engine 7817 ''' 7818 deadline = None if timeout is None else time.time() + timeout 7819 req = SecretEngineUpdateRequest() 7820 7821 if secret_engine is not None: 7822 req.secret_engine.CopyFrom( 7823 plumbing.convert_secret_engine_to_plumbing(secret_engine)) 7824 tries = 0 7825 plumbing_response = None 7826 while True: 7827 t = None if deadline is None else deadline - time.time() 7828 try: 7829 plumbing_response = self.stub.Update( 7830 req, 7831 metadata=self.parent.get_metadata('SecretEngines.Update', 7832 req), 7833 timeout=t) 7834 except Exception as e: 7835 if self.parent.shouldRetry(tries, e, deadline): 7836 tries += 1 7837 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7838 continue 7839 raise plumbing.convert_error_to_porcelain(e) from e 7840 break 7841 7842 resp = models.SecretEngineUpdateResponse() 7843 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 7844 plumbing_response.meta) 7845 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7846 plumbing_response.rate_limit) 7847 resp.secret_engine = plumbing.convert_secret_engine_to_porcelain( 7848 plumbing_response.secret_engine) 7849 return resp 7850 7851 def delete(self, id, timeout=None): 7852 ''' 7853 Delete deletes a secret engine 7854 ''' 7855 deadline = None if timeout is None else time.time() + timeout 7856 req = SecretEngineDeleteRequest() 7857 7858 req.id = (id) 7859 tries = 0 7860 plumbing_response = None 7861 while True: 7862 t = None if deadline is None else deadline - time.time() 7863 try: 7864 plumbing_response = self.stub.Delete( 7865 req, 7866 metadata=self.parent.get_metadata('SecretEngines.Delete', 7867 req), 7868 timeout=t) 7869 except Exception as e: 7870 if self.parent.shouldRetry(tries, e, deadline): 7871 tries += 1 7872 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7873 continue 7874 raise plumbing.convert_error_to_porcelain(e) from e 7875 break 7876 7877 resp = models.SecretEngineDeleteResponse() 7878 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7879 plumbing_response.rate_limit) 7880 return resp 7881 7882 def list_secret_stores(self, filter, *args, timeout=None): 7883 ''' 7884 ListSecretStores returns a list of Secret Stores that can be used as a backing store 7885 for Secret Engine 7886 ''' 7887 deadline = None if timeout is None else time.time() + timeout 7888 req = SecretStoreListRequest() 7889 req.meta.CopyFrom(ListRequestMetadata()) 7890 if self.parent.page_limit > 0: 7891 req.meta.limit = self.parent.page_limit 7892 if self.parent.snapshot_datetime is not None: 7893 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7894 7895 req.filter = plumbing.quote_filter_args(filter, *args) 7896 7897 def generator(svc, req): 7898 tries = 0 7899 while True: 7900 t = None if deadline is None else deadline - time.time() 7901 try: 7902 plumbing_response = svc.stub.ListSecretStores( 7903 req, 7904 metadata=svc.parent.get_metadata( 7905 'SecretEngines.ListSecretStores', req), 7906 timeout=t) 7907 except Exception as e: 7908 if self.parent.shouldRetry(tries, e, deadline): 7909 tries += 1 7910 time.sleep( 7911 self.parent.exponentialBackoff(tries, deadline)) 7912 continue 7913 raise plumbing.convert_error_to_porcelain(e) from e 7914 tries = 0 7915 for plumbing_item in plumbing_response.secret_stores: 7916 yield plumbing.convert_secret_store_to_porcelain( 7917 plumbing_item) 7918 if plumbing_response.meta.next_cursor == '': 7919 break 7920 req.meta.cursor = plumbing_response.meta.next_cursor 7921 7922 return generator(self, req) 7923 7924 def generate_keys(self, secret_engine_id, timeout=None): 7925 ''' 7926 GenerateKeys generates a private key, stores it in a secret store and stores a public key in a secret engine 7927 ''' 7928 deadline = None if timeout is None else time.time() + timeout 7929 req = GenerateKeysRequest() 7930 7931 req.secret_engine_id = (secret_engine_id) 7932 tries = 0 7933 plumbing_response = None 7934 while True: 7935 t = None if deadline is None else deadline - time.time() 7936 try: 7937 plumbing_response = self.stub.GenerateKeys( 7938 req, 7939 metadata=self.parent.get_metadata( 7940 'SecretEngines.GenerateKeys', req), 7941 timeout=t) 7942 except Exception as e: 7943 if self.parent.shouldRetry(tries, e, deadline): 7944 tries += 1 7945 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7946 continue 7947 raise plumbing.convert_error_to_porcelain(e) from e 7948 break 7949 7950 resp = models.GenerateKeysResponse() 7951 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7952 plumbing_response.rate_limit) 7953 return resp 7954 7955 def healthcheck(self, secret_engine_id, timeout=None): 7956 ''' 7957 Healthcheck triggers a healthcheck for all nodes serving a secret engine 7958 ''' 7959 deadline = None if timeout is None else time.time() + timeout 7960 req = HealthcheckRequest() 7961 7962 req.secret_engine_id = (secret_engine_id) 7963 tries = 0 7964 plumbing_response = None 7965 while True: 7966 t = None if deadline is None else deadline - time.time() 7967 try: 7968 plumbing_response = self.stub.Healthcheck( 7969 req, 7970 metadata=self.parent.get_metadata( 7971 'SecretEngines.Healthcheck', req), 7972 timeout=t) 7973 except Exception as e: 7974 if self.parent.shouldRetry(tries, e, deadline): 7975 tries += 1 7976 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7977 continue 7978 raise plumbing.convert_error_to_porcelain(e) from e 7979 break 7980 7981 resp = models.HealthcheckResponse() 7982 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7983 plumbing_response.rate_limit) 7984 resp.status = plumbing.convert_repeated_healthcheck_status_to_porcelain( 7985 plumbing_response.status) 7986 return resp 7987 7988 def rotate(self, id, password_policy, timeout=None): 7989 ''' 7990 Rotate rotates secret engine's credentials 7991 ''' 7992 deadline = None if timeout is None else time.time() + timeout 7993 req = SecretEngineRotateRequest() 7994 7995 req.id = (id) 7996 if password_policy is not None: 7997 req.password_policy.CopyFrom( 7998 plumbing.convert_secret_engine_password_policy_to_plumbing( 7999 password_policy)) 8000 tries = 0 8001 plumbing_response = None 8002 while True: 8003 t = None if deadline is None else deadline - time.time() 8004 try: 8005 plumbing_response = self.stub.Rotate( 8006 req, 8007 metadata=self.parent.get_metadata('SecretEngines.Rotate', 8008 req), 8009 timeout=t) 8010 except Exception as e: 8011 if self.parent.shouldRetry(tries, e, deadline): 8012 tries += 1 8013 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8014 continue 8015 raise plumbing.convert_error_to_porcelain(e) from e 8016 break 8017 8018 resp = models.SecretEngineRotateResponse() 8019 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8020 plumbing_response.rate_limit) 8021 return resp 8022 8023 8024class SecretStoreHealths: 8025 ''' 8026 SecretStoreHealths exposes health states for secret stores. 8027 See `strongdm.models.SecretStoreHealth`. 8028 ''' 8029 def __init__(self, channel, client): 8030 self.parent = client 8031 self.stub = SecretStoreHealthsStub(channel) 8032 8033 def list(self, filter, *args, timeout=None): 8034 ''' 8035 List reports the health status of node to secret store pairs. 8036 ''' 8037 deadline = None if timeout is None else time.time() + timeout 8038 req = SecretStoreHealthListRequest() 8039 req.meta.CopyFrom(ListRequestMetadata()) 8040 if self.parent.page_limit > 0: 8041 req.meta.limit = self.parent.page_limit 8042 if self.parent.snapshot_datetime is not None: 8043 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8044 8045 req.filter = plumbing.quote_filter_args(filter, *args) 8046 8047 def generator(svc, req): 8048 tries = 0 8049 while True: 8050 t = None if deadline is None else deadline - time.time() 8051 try: 8052 plumbing_response = svc.stub.List( 8053 req, 8054 metadata=svc.parent.get_metadata( 8055 'SecretStoreHealths.List', req), 8056 timeout=t) 8057 except Exception as e: 8058 if self.parent.shouldRetry(tries, e, deadline): 8059 tries += 1 8060 time.sleep( 8061 self.parent.exponentialBackoff(tries, deadline)) 8062 continue 8063 raise plumbing.convert_error_to_porcelain(e) from e 8064 tries = 0 8065 for plumbing_item in plumbing_response.secret_store_healths: 8066 yield plumbing.convert_secret_store_health_to_porcelain( 8067 plumbing_item) 8068 if plumbing_response.meta.next_cursor == '': 8069 break 8070 req.meta.cursor = plumbing_response.meta.next_cursor 8071 8072 return generator(self, req) 8073 8074 def healthcheck(self, secret_store_id, timeout=None): 8075 ''' 8076 Healthcheck triggers a remote healthcheck request for a secret store. It may take minutes 8077 to propagate across a large network of Nodes. The call will return immediately, and the 8078 updated health of the Secret Store can be retrieved via List. 8079 ''' 8080 deadline = None if timeout is None else time.time() + timeout 8081 req = SecretStoreHealthcheckRequest() 8082 8083 req.secret_store_id = (secret_store_id) 8084 tries = 0 8085 plumbing_response = None 8086 while True: 8087 t = None if deadline is None else deadline - time.time() 8088 try: 8089 plumbing_response = self.stub.Healthcheck( 8090 req, 8091 metadata=self.parent.get_metadata( 8092 'SecretStoreHealths.Healthcheck', req), 8093 timeout=t) 8094 except Exception as e: 8095 if self.parent.shouldRetry(tries, e, deadline): 8096 tries += 1 8097 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8098 continue 8099 raise plumbing.convert_error_to_porcelain(e) from e 8100 break 8101 8102 resp = models.SecretStoreHealthcheckResponse() 8103 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8104 plumbing_response.rate_limit) 8105 return resp 8106 8107 8108class SecretStoresHistory: 8109 ''' 8110 SecretStoresHistory records all changes to the state of a SecretStore. 8111 See `strongdm.models.SecretStoreHistory`. 8112 ''' 8113 def __init__(self, channel, client): 8114 self.parent = client 8115 self.stub = SecretStoresHistoryStub(channel) 8116 8117 def list(self, filter, *args, timeout=None): 8118 ''' 8119 List gets a list of SecretStoreHistory records matching a given set of criteria. 8120 ''' 8121 deadline = None if timeout is None else time.time() + timeout 8122 req = SecretStoreHistoryListRequest() 8123 req.meta.CopyFrom(ListRequestMetadata()) 8124 if self.parent.page_limit > 0: 8125 req.meta.limit = self.parent.page_limit 8126 if self.parent.snapshot_datetime is not None: 8127 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8128 8129 req.filter = plumbing.quote_filter_args(filter, *args) 8130 8131 def generator(svc, req): 8132 tries = 0 8133 while True: 8134 t = None if deadline is None else deadline - time.time() 8135 try: 8136 plumbing_response = svc.stub.List( 8137 req, 8138 metadata=svc.parent.get_metadata( 8139 'SecretStoresHistory.List', req), 8140 timeout=t) 8141 except Exception as e: 8142 if self.parent.shouldRetry(tries, e, deadline): 8143 tries += 1 8144 time.sleep( 8145 self.parent.exponentialBackoff(tries, deadline)) 8146 continue 8147 raise plumbing.convert_error_to_porcelain(e) from e 8148 tries = 0 8149 for plumbing_item in plumbing_response.history: 8150 yield plumbing.convert_secret_store_history_to_porcelain( 8151 plumbing_item) 8152 if plumbing_response.meta.next_cursor == '': 8153 break 8154 req.meta.cursor = plumbing_response.meta.next_cursor 8155 8156 return generator(self, req) 8157 8158 8159class WorkflowApprovers: 8160 ''' 8161 WorkflowApprovers is an account or a role with the ability to approve requests bound to a workflow. 8162 See `strongdm.models.WorkflowApprover`. 8163 ''' 8164 def __init__(self, channel, client): 8165 self.parent = client 8166 self.stub = WorkflowApproversStub(channel) 8167 8168 def create(self, workflow_approver, timeout=None): 8169 ''' 8170 Create creates a new workflow approver 8171 ''' 8172 deadline = None if timeout is None else time.time() + timeout 8173 req = WorkflowApproversCreateRequest() 8174 8175 if workflow_approver is not None: 8176 req.workflow_approver.CopyFrom( 8177 plumbing.convert_workflow_approver_to_plumbing( 8178 workflow_approver)) 8179 tries = 0 8180 plumbing_response = None 8181 while True: 8182 t = None if deadline is None else deadline - time.time() 8183 try: 8184 plumbing_response = self.stub.Create( 8185 req, 8186 metadata=self.parent.get_metadata( 8187 'WorkflowApprovers.Create', req), 8188 timeout=t) 8189 except Exception as e: 8190 if self.parent.shouldRetry(tries, e, deadline): 8191 tries += 1 8192 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8193 continue 8194 raise plumbing.convert_error_to_porcelain(e) from e 8195 break 8196 8197 resp = models.WorkflowApproversCreateResponse() 8198 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8199 plumbing_response.rate_limit) 8200 resp.workflow_approver = plumbing.convert_workflow_approver_to_porcelain( 8201 plumbing_response.workflow_approver) 8202 return resp 8203 8204 def get(self, id, timeout=None): 8205 ''' 8206 Get reads one workflow approver by ID. 8207 ''' 8208 deadline = None if timeout is None else time.time() + timeout 8209 req = WorkflowApproverGetRequest() 8210 if self.parent.snapshot_datetime is not None: 8211 req.meta.CopyFrom(GetRequestMetadata()) 8212 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8213 8214 req.id = (id) 8215 tries = 0 8216 plumbing_response = None 8217 while True: 8218 t = None if deadline is None else deadline - time.time() 8219 try: 8220 plumbing_response = self.stub.Get( 8221 req, 8222 metadata=self.parent.get_metadata('WorkflowApprovers.Get', 8223 req), 8224 timeout=t) 8225 except Exception as e: 8226 if self.parent.shouldRetry(tries, e, deadline): 8227 tries += 1 8228 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8229 continue 8230 raise plumbing.convert_error_to_porcelain(e) from e 8231 break 8232 8233 resp = models.WorkflowApproverGetResponse() 8234 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 8235 plumbing_response.meta) 8236 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8237 plumbing_response.rate_limit) 8238 resp.workflow_approver = plumbing.convert_workflow_approver_to_porcelain( 8239 plumbing_response.workflow_approver) 8240 return resp 8241 8242 def delete(self, id, timeout=None): 8243 ''' 8244 Delete deletes a workflow approver 8245 ''' 8246 deadline = None if timeout is None else time.time() + timeout 8247 req = WorkflowApproversDeleteRequest() 8248 8249 req.id = (id) 8250 tries = 0 8251 plumbing_response = None 8252 while True: 8253 t = None if deadline is None else deadline - time.time() 8254 try: 8255 plumbing_response = self.stub.Delete( 8256 req, 8257 metadata=self.parent.get_metadata( 8258 'WorkflowApprovers.Delete', req), 8259 timeout=t) 8260 except Exception as e: 8261 if self.parent.shouldRetry(tries, e, deadline): 8262 tries += 1 8263 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8264 continue 8265 raise plumbing.convert_error_to_porcelain(e) from e 8266 break 8267 8268 resp = models.WorkflowApproversDeleteResponse() 8269 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8270 plumbing_response.rate_limit) 8271 return resp 8272 8273 def list(self, filter, *args, timeout=None): 8274 ''' 8275 Lists existing workflow approvers. 8276 ''' 8277 deadline = None if timeout is None else time.time() + timeout 8278 req = WorkflowApproversListRequest() 8279 req.meta.CopyFrom(ListRequestMetadata()) 8280 if self.parent.page_limit > 0: 8281 req.meta.limit = self.parent.page_limit 8282 if self.parent.snapshot_datetime is not None: 8283 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8284 8285 req.filter = plumbing.quote_filter_args(filter, *args) 8286 8287 def generator(svc, req): 8288 tries = 0 8289 while True: 8290 t = None if deadline is None else deadline - time.time() 8291 try: 8292 plumbing_response = svc.stub.List( 8293 req, 8294 metadata=svc.parent.get_metadata( 8295 'WorkflowApprovers.List', req), 8296 timeout=t) 8297 except Exception as e: 8298 if self.parent.shouldRetry(tries, e, deadline): 8299 tries += 1 8300 time.sleep( 8301 self.parent.exponentialBackoff(tries, deadline)) 8302 continue 8303 raise plumbing.convert_error_to_porcelain(e) from e 8304 tries = 0 8305 for plumbing_item in plumbing_response.workflow_approvers: 8306 yield plumbing.convert_workflow_approver_to_porcelain( 8307 plumbing_item) 8308 if plumbing_response.meta.next_cursor == '': 8309 break 8310 req.meta.cursor = plumbing_response.meta.next_cursor 8311 8312 return generator(self, req) 8313 8314 8315class SnapshotWorkflowApprovers: 8316 ''' 8317 SnapshotWorkflowApprovers exposes the read only methods of the WorkflowApprovers 8318 service for historical queries. 8319 ''' 8320 def __init__(self, workflow_approvers): 8321 self.workflow_approvers = workflow_approvers 8322 8323 def get(self, id, timeout=None): 8324 ''' 8325 Get reads one workflow approver by ID. 8326 ''' 8327 return self.workflow_approvers.get(id, timeout=timeout) 8328 8329 def list(self, filter, *args, timeout=None): 8330 ''' 8331 Lists existing workflow approvers. 8332 ''' 8333 return self.workflow_approvers.list(filter, *args, timeout=timeout) 8334 8335 8336class WorkflowApproversHistory: 8337 ''' 8338 WorkflowApproversHistory provides records of all changes to the state of a WorkflowApprover. 8339 See `strongdm.models.WorkflowApproverHistory`. 8340 ''' 8341 def __init__(self, channel, client): 8342 self.parent = client 8343 self.stub = WorkflowApproversHistoryStub(channel) 8344 8345 def list(self, filter, *args, timeout=None): 8346 ''' 8347 List gets a list of WorkflowApproversHistory records matching a given set of criteria. 8348 ''' 8349 deadline = None if timeout is None else time.time() + timeout 8350 req = WorkflowApproversHistoryListRequest() 8351 req.meta.CopyFrom(ListRequestMetadata()) 8352 if self.parent.page_limit > 0: 8353 req.meta.limit = self.parent.page_limit 8354 if self.parent.snapshot_datetime is not None: 8355 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8356 8357 req.filter = plumbing.quote_filter_args(filter, *args) 8358 8359 def generator(svc, req): 8360 tries = 0 8361 while True: 8362 t = None if deadline is None else deadline - time.time() 8363 try: 8364 plumbing_response = svc.stub.List( 8365 req, 8366 metadata=svc.parent.get_metadata( 8367 'WorkflowApproversHistory.List', req), 8368 timeout=t) 8369 except Exception as e: 8370 if self.parent.shouldRetry(tries, e, deadline): 8371 tries += 1 8372 time.sleep( 8373 self.parent.exponentialBackoff(tries, deadline)) 8374 continue 8375 raise plumbing.convert_error_to_porcelain(e) from e 8376 tries = 0 8377 for plumbing_item in plumbing_response.history: 8378 yield plumbing.convert_workflow_approver_history_to_porcelain( 8379 plumbing_item) 8380 if plumbing_response.meta.next_cursor == '': 8381 break 8382 req.meta.cursor = plumbing_response.meta.next_cursor 8383 8384 return generator(self, req) 8385 8386 8387class WorkflowRoles: 8388 ''' 8389 WorkflowRole links a role to a workflow. The linked roles indicate which roles a user must be a part of 8390 to request access to a resource via the workflow. 8391 See `strongdm.models.WorkflowRole`. 8392 ''' 8393 def __init__(self, channel, client): 8394 self.parent = client 8395 self.stub = WorkflowRolesStub(channel) 8396 8397 def create(self, workflow_role, timeout=None): 8398 ''' 8399 Create creates a new workflow role 8400 ''' 8401 deadline = None if timeout is None else time.time() + timeout 8402 req = WorkflowRolesCreateRequest() 8403 8404 if workflow_role is not None: 8405 req.workflow_role.CopyFrom( 8406 plumbing.convert_workflow_role_to_plumbing(workflow_role)) 8407 tries = 0 8408 plumbing_response = None 8409 while True: 8410 t = None if deadline is None else deadline - time.time() 8411 try: 8412 plumbing_response = self.stub.Create( 8413 req, 8414 metadata=self.parent.get_metadata('WorkflowRoles.Create', 8415 req), 8416 timeout=t) 8417 except Exception as e: 8418 if self.parent.shouldRetry(tries, e, deadline): 8419 tries += 1 8420 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8421 continue 8422 raise plumbing.convert_error_to_porcelain(e) from e 8423 break 8424 8425 resp = models.WorkflowRolesCreateResponse() 8426 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8427 plumbing_response.rate_limit) 8428 resp.workflow_role = plumbing.convert_workflow_role_to_porcelain( 8429 plumbing_response.workflow_role) 8430 return resp 8431 8432 def get(self, id, timeout=None): 8433 ''' 8434 Get reads one workflow role by ID. 8435 ''' 8436 deadline = None if timeout is None else time.time() + timeout 8437 req = WorkflowRoleGetRequest() 8438 if self.parent.snapshot_datetime is not None: 8439 req.meta.CopyFrom(GetRequestMetadata()) 8440 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8441 8442 req.id = (id) 8443 tries = 0 8444 plumbing_response = None 8445 while True: 8446 t = None if deadline is None else deadline - time.time() 8447 try: 8448 plumbing_response = self.stub.Get( 8449 req, 8450 metadata=self.parent.get_metadata('WorkflowRoles.Get', 8451 req), 8452 timeout=t) 8453 except Exception as e: 8454 if self.parent.shouldRetry(tries, e, deadline): 8455 tries += 1 8456 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8457 continue 8458 raise plumbing.convert_error_to_porcelain(e) from e 8459 break 8460 8461 resp = models.WorkflowRoleGetResponse() 8462 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 8463 plumbing_response.meta) 8464 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8465 plumbing_response.rate_limit) 8466 resp.workflow_role = plumbing.convert_workflow_role_to_porcelain( 8467 plumbing_response.workflow_role) 8468 return resp 8469 8470 def delete(self, id, timeout=None): 8471 ''' 8472 Delete deletes a workflow role 8473 ''' 8474 deadline = None if timeout is None else time.time() + timeout 8475 req = WorkflowRolesDeleteRequest() 8476 8477 req.id = (id) 8478 tries = 0 8479 plumbing_response = None 8480 while True: 8481 t = None if deadline is None else deadline - time.time() 8482 try: 8483 plumbing_response = self.stub.Delete( 8484 req, 8485 metadata=self.parent.get_metadata('WorkflowRoles.Delete', 8486 req), 8487 timeout=t) 8488 except Exception as e: 8489 if self.parent.shouldRetry(tries, e, deadline): 8490 tries += 1 8491 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8492 continue 8493 raise plumbing.convert_error_to_porcelain(e) from e 8494 break 8495 8496 resp = models.WorkflowRolesDeleteResponse() 8497 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8498 plumbing_response.rate_limit) 8499 return resp 8500 8501 def list(self, filter, *args, timeout=None): 8502 ''' 8503 Lists existing workflow roles. 8504 ''' 8505 deadline = None if timeout is None else time.time() + timeout 8506 req = WorkflowRolesListRequest() 8507 req.meta.CopyFrom(ListRequestMetadata()) 8508 if self.parent.page_limit > 0: 8509 req.meta.limit = self.parent.page_limit 8510 if self.parent.snapshot_datetime is not None: 8511 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8512 8513 req.filter = plumbing.quote_filter_args(filter, *args) 8514 8515 def generator(svc, req): 8516 tries = 0 8517 while True: 8518 t = None if deadline is None else deadline - time.time() 8519 try: 8520 plumbing_response = svc.stub.List( 8521 req, 8522 metadata=svc.parent.get_metadata( 8523 'WorkflowRoles.List', req), 8524 timeout=t) 8525 except Exception as e: 8526 if self.parent.shouldRetry(tries, e, deadline): 8527 tries += 1 8528 time.sleep( 8529 self.parent.exponentialBackoff(tries, deadline)) 8530 continue 8531 raise plumbing.convert_error_to_porcelain(e) from e 8532 tries = 0 8533 for plumbing_item in plumbing_response.workflow_role: 8534 yield plumbing.convert_workflow_role_to_porcelain( 8535 plumbing_item) 8536 if plumbing_response.meta.next_cursor == '': 8537 break 8538 req.meta.cursor = plumbing_response.meta.next_cursor 8539 8540 return generator(self, req) 8541 8542 8543class SnapshotWorkflowRoles: 8544 ''' 8545 SnapshotWorkflowRoles exposes the read only methods of the WorkflowRoles 8546 service for historical queries. 8547 ''' 8548 def __init__(self, workflow_roles): 8549 self.workflow_roles = workflow_roles 8550 8551 def get(self, id, timeout=None): 8552 ''' 8553 Get reads one workflow role by ID. 8554 ''' 8555 return self.workflow_roles.get(id, timeout=timeout) 8556 8557 def list(self, filter, *args, timeout=None): 8558 ''' 8559 Lists existing workflow roles. 8560 ''' 8561 return self.workflow_roles.list(filter, *args, timeout=timeout) 8562 8563 8564class WorkflowRolesHistory: 8565 ''' 8566 WorkflowRolesHistory provides records of all changes to the state of a WorkflowRole 8567 See `strongdm.models.WorkflowRoleHistory`. 8568 ''' 8569 def __init__(self, channel, client): 8570 self.parent = client 8571 self.stub = WorkflowRolesHistoryStub(channel) 8572 8573 def list(self, filter, *args, timeout=None): 8574 ''' 8575 List gets a list of WorkflowRolesHistory records matching a given set of criteria. 8576 ''' 8577 deadline = None if timeout is None else time.time() + timeout 8578 req = WorkflowRolesHistoryListRequest() 8579 req.meta.CopyFrom(ListRequestMetadata()) 8580 if self.parent.page_limit > 0: 8581 req.meta.limit = self.parent.page_limit 8582 if self.parent.snapshot_datetime is not None: 8583 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8584 8585 req.filter = plumbing.quote_filter_args(filter, *args) 8586 8587 def generator(svc, req): 8588 tries = 0 8589 while True: 8590 t = None if deadline is None else deadline - time.time() 8591 try: 8592 plumbing_response = svc.stub.List( 8593 req, 8594 metadata=svc.parent.get_metadata( 8595 'WorkflowRolesHistory.List', req), 8596 timeout=t) 8597 except Exception as e: 8598 if self.parent.shouldRetry(tries, e, deadline): 8599 tries += 1 8600 time.sleep( 8601 self.parent.exponentialBackoff(tries, deadline)) 8602 continue 8603 raise plumbing.convert_error_to_porcelain(e) from e 8604 tries = 0 8605 for plumbing_item in plumbing_response.history: 8606 yield plumbing.convert_workflow_role_history_to_porcelain( 8607 plumbing_item) 8608 if plumbing_response.meta.next_cursor == '': 8609 break 8610 req.meta.cursor = plumbing_response.meta.next_cursor 8611 8612 return generator(self, req) 8613 8614 8615class Workflows: 8616 ''' 8617 Workflows are the collection of rules that define the resources to which access can be requested, 8618 the users that can request that access, and the mechanism for approving those requests which can either 8619 be automatic approval or a set of users authorized to approve the requests. 8620 See `strongdm.models.Workflow`. 8621 ''' 8622 def __init__(self, channel, client): 8623 self.parent = client 8624 self.stub = WorkflowsStub(channel) 8625 8626 def create(self, workflow, timeout=None): 8627 ''' 8628 Create creates a new workflow and requires a name for the workflow. 8629 ''' 8630 deadline = None if timeout is None else time.time() + timeout 8631 req = WorkflowCreateRequest() 8632 8633 if workflow is not None: 8634 req.workflow.CopyFrom( 8635 plumbing.convert_workflow_to_plumbing(workflow)) 8636 tries = 0 8637 plumbing_response = None 8638 while True: 8639 t = None if deadline is None else deadline - time.time() 8640 try: 8641 plumbing_response = self.stub.Create( 8642 req, 8643 metadata=self.parent.get_metadata('Workflows.Create', req), 8644 timeout=t) 8645 except Exception as e: 8646 if self.parent.shouldRetry(tries, e, deadline): 8647 tries += 1 8648 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8649 continue 8650 raise plumbing.convert_error_to_porcelain(e) from e 8651 break 8652 8653 resp = models.WorkflowCreateResponse() 8654 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8655 plumbing_response.rate_limit) 8656 resp.workflow = plumbing.convert_workflow_to_porcelain( 8657 plumbing_response.workflow) 8658 return resp 8659 8660 def get(self, id, timeout=None): 8661 ''' 8662 Get reads one workflow by ID. 8663 ''' 8664 deadline = None if timeout is None else time.time() + timeout 8665 req = WorkflowGetRequest() 8666 if self.parent.snapshot_datetime is not None: 8667 req.meta.CopyFrom(GetRequestMetadata()) 8668 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8669 8670 req.id = (id) 8671 tries = 0 8672 plumbing_response = None 8673 while True: 8674 t = None if deadline is None else deadline - time.time() 8675 try: 8676 plumbing_response = self.stub.Get( 8677 req, 8678 metadata=self.parent.get_metadata('Workflows.Get', req), 8679 timeout=t) 8680 except Exception as e: 8681 if self.parent.shouldRetry(tries, e, deadline): 8682 tries += 1 8683 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8684 continue 8685 raise plumbing.convert_error_to_porcelain(e) from e 8686 break 8687 8688 resp = models.WorkflowGetResponse() 8689 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 8690 plumbing_response.meta) 8691 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8692 plumbing_response.rate_limit) 8693 resp.workflow = plumbing.convert_workflow_to_porcelain( 8694 plumbing_response.workflow) 8695 return resp 8696 8697 def delete(self, id, timeout=None): 8698 ''' 8699 Delete deletes an existing workflow. 8700 ''' 8701 deadline = None if timeout is None else time.time() + timeout 8702 req = WorkflowDeleteRequest() 8703 8704 req.id = (id) 8705 tries = 0 8706 plumbing_response = None 8707 while True: 8708 t = None if deadline is None else deadline - time.time() 8709 try: 8710 plumbing_response = self.stub.Delete( 8711 req, 8712 metadata=self.parent.get_metadata('Workflows.Delete', req), 8713 timeout=t) 8714 except Exception as e: 8715 if self.parent.shouldRetry(tries, e, deadline): 8716 tries += 1 8717 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8718 continue 8719 raise plumbing.convert_error_to_porcelain(e) from e 8720 break 8721 8722 resp = models.WorkflowDeleteResponse() 8723 resp.id = (plumbing_response.id) 8724 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8725 plumbing_response.rate_limit) 8726 return resp 8727 8728 def update(self, workflow, timeout=None): 8729 ''' 8730 Update updates an existing workflow. 8731 ''' 8732 deadline = None if timeout is None else time.time() + timeout 8733 req = WorkflowUpdateRequest() 8734 8735 if workflow is not None: 8736 req.workflow.CopyFrom( 8737 plumbing.convert_workflow_to_plumbing(workflow)) 8738 tries = 0 8739 plumbing_response = None 8740 while True: 8741 t = None if deadline is None else deadline - time.time() 8742 try: 8743 plumbing_response = self.stub.Update( 8744 req, 8745 metadata=self.parent.get_metadata('Workflows.Update', req), 8746 timeout=t) 8747 except Exception as e: 8748 if self.parent.shouldRetry(tries, e, deadline): 8749 tries += 1 8750 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8751 continue 8752 raise plumbing.convert_error_to_porcelain(e) from e 8753 break 8754 8755 resp = models.WorkflowUpdateResponse() 8756 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8757 plumbing_response.rate_limit) 8758 resp.workflow = plumbing.convert_workflow_to_porcelain( 8759 plumbing_response.workflow) 8760 return resp 8761 8762 def list(self, filter, *args, timeout=None): 8763 ''' 8764 Lists existing workflows. 8765 ''' 8766 deadline = None if timeout is None else time.time() + timeout 8767 req = WorkflowListRequest() 8768 req.meta.CopyFrom(ListRequestMetadata()) 8769 if self.parent.page_limit > 0: 8770 req.meta.limit = self.parent.page_limit 8771 if self.parent.snapshot_datetime is not None: 8772 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8773 8774 req.filter = plumbing.quote_filter_args(filter, *args) 8775 8776 def generator(svc, req): 8777 tries = 0 8778 while True: 8779 t = None if deadline is None else deadline - time.time() 8780 try: 8781 plumbing_response = svc.stub.List( 8782 req, 8783 metadata=svc.parent.get_metadata( 8784 'Workflows.List', req), 8785 timeout=t) 8786 except Exception as e: 8787 if self.parent.shouldRetry(tries, e, deadline): 8788 tries += 1 8789 time.sleep( 8790 self.parent.exponentialBackoff(tries, deadline)) 8791 continue 8792 raise plumbing.convert_error_to_porcelain(e) from e 8793 tries = 0 8794 for plumbing_item in plumbing_response.workflows: 8795 yield plumbing.convert_workflow_to_porcelain(plumbing_item) 8796 if plumbing_response.meta.next_cursor == '': 8797 break 8798 req.meta.cursor = plumbing_response.meta.next_cursor 8799 8800 return generator(self, req) 8801 8802 8803class SnapshotWorkflows: 8804 ''' 8805 SnapshotWorkflows exposes the read only methods of the Workflows 8806 service for historical queries. 8807 ''' 8808 def __init__(self, workflows): 8809 self.workflows = workflows 8810 8811 def get(self, id, timeout=None): 8812 ''' 8813 Get reads one workflow by ID. 8814 ''' 8815 return self.workflows.get(id, timeout=timeout) 8816 8817 def list(self, filter, *args, timeout=None): 8818 ''' 8819 Lists existing workflows. 8820 ''' 8821 return self.workflows.list(filter, *args, timeout=timeout) 8822 8823 8824class WorkflowsHistory: 8825 ''' 8826 WorkflowsHistory provides records of all changes to the state of a Workflow. 8827 See `strongdm.models.WorkflowHistory`. 8828 ''' 8829 def __init__(self, channel, client): 8830 self.parent = client 8831 self.stub = WorkflowsHistoryStub(channel) 8832 8833 def list(self, filter, *args, timeout=None): 8834 ''' 8835 List gets a list of WorkflowHistory records matching a given set of criteria. 8836 ''' 8837 deadline = None if timeout is None else time.time() + timeout 8838 req = WorkflowHistoryListRequest() 8839 req.meta.CopyFrom(ListRequestMetadata()) 8840 if self.parent.page_limit > 0: 8841 req.meta.limit = self.parent.page_limit 8842 if self.parent.snapshot_datetime is not None: 8843 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8844 8845 req.filter = plumbing.quote_filter_args(filter, *args) 8846 8847 def generator(svc, req): 8848 tries = 0 8849 while True: 8850 t = None if deadline is None else deadline - time.time() 8851 try: 8852 plumbing_response = svc.stub.List( 8853 req, 8854 metadata=svc.parent.get_metadata( 8855 'WorkflowsHistory.List', req), 8856 timeout=t) 8857 except Exception as e: 8858 if self.parent.shouldRetry(tries, e, deadline): 8859 tries += 1 8860 time.sleep( 8861 self.parent.exponentialBackoff(tries, deadline)) 8862 continue 8863 raise plumbing.convert_error_to_porcelain(e) from e 8864 tries = 0 8865 for plumbing_item in plumbing_response.history: 8866 yield plumbing.convert_workflow_history_to_porcelain( 8867 plumbing_item) 8868 if plumbing_response.meta.next_cursor == '': 8869 break 8870 req.meta.cursor = plumbing_response.meta.next_cursor 8871 8872 return generator(self, req)
def
deprecated(func)
191def deprecated(func): 192 """This is a decorator which can be used to mark functions 193 as deprecated. It will result in a warning being emitted 194 when the function is used.""" 195 @functools.wraps(func) 196 def new_func(*args, **kwargs): 197 warnings.warn("Call to deprecated function {}.".format(func.__name__), 198 category=DeprecationWarning, 199 stacklevel=2) 200 return func(*args, **kwargs) 201 202 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:
205class AccessRequests: 206 ''' 207 AccessRequests are requests for access to a resource that may match a Workflow. 208 See `strongdm.models.AccessRequest`. 209 ''' 210 def __init__(self, channel, client): 211 self.parent = client 212 self.stub = AccessRequestsStub(channel) 213 214 def list(self, filter, *args, timeout=None): 215 ''' 216 Lists existing access requests. 217 ''' 218 deadline = None if timeout is None else time.time() + timeout 219 req = AccessRequestListRequest() 220 req.meta.CopyFrom(ListRequestMetadata()) 221 if self.parent.page_limit > 0: 222 req.meta.limit = self.parent.page_limit 223 if self.parent.snapshot_datetime is not None: 224 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 225 226 req.filter = plumbing.quote_filter_args(filter, *args) 227 228 def generator(svc, req): 229 tries = 0 230 while True: 231 t = None if deadline is None else deadline - time.time() 232 try: 233 plumbing_response = svc.stub.List( 234 req, 235 metadata=svc.parent.get_metadata( 236 'AccessRequests.List', req), 237 timeout=t) 238 except Exception as e: 239 if self.parent.shouldRetry(tries, e, deadline): 240 tries += 1 241 time.sleep( 242 self.parent.exponentialBackoff(tries, deadline)) 243 continue 244 raise plumbing.convert_error_to_porcelain(e) from e 245 tries = 0 246 for plumbing_item in plumbing_response.access_requests: 247 yield plumbing.convert_access_request_to_porcelain( 248 plumbing_item) 249 if plumbing_response.meta.next_cursor == '': 250 break 251 req.meta.cursor = plumbing_response.meta.next_cursor 252 253 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)
214 def list(self, filter, *args, timeout=None): 215 ''' 216 Lists existing access requests. 217 ''' 218 deadline = None if timeout is None else time.time() + timeout 219 req = AccessRequestListRequest() 220 req.meta.CopyFrom(ListRequestMetadata()) 221 if self.parent.page_limit > 0: 222 req.meta.limit = self.parent.page_limit 223 if self.parent.snapshot_datetime is not None: 224 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 225 226 req.filter = plumbing.quote_filter_args(filter, *args) 227 228 def generator(svc, req): 229 tries = 0 230 while True: 231 t = None if deadline is None else deadline - time.time() 232 try: 233 plumbing_response = svc.stub.List( 234 req, 235 metadata=svc.parent.get_metadata( 236 'AccessRequests.List', req), 237 timeout=t) 238 except Exception as e: 239 if self.parent.shouldRetry(tries, e, deadline): 240 tries += 1 241 time.sleep( 242 self.parent.exponentialBackoff(tries, deadline)) 243 continue 244 raise plumbing.convert_error_to_porcelain(e) from e 245 tries = 0 246 for plumbing_item in plumbing_response.access_requests: 247 yield plumbing.convert_access_request_to_porcelain( 248 plumbing_item) 249 if plumbing_response.meta.next_cursor == '': 250 break 251 req.meta.cursor = plumbing_response.meta.next_cursor 252 253 return generator(self, req)
Lists existing access requests.
class
SnapshotAccessRequests:
256class SnapshotAccessRequests: 257 ''' 258 SnapshotAccessRequests exposes the read only methods of the AccessRequests 259 service for historical queries. 260 ''' 261 def __init__(self, access_requests): 262 self.access_requests = access_requests 263 264 def list(self, filter, *args, timeout=None): 265 ''' 266 Lists existing access requests. 267 ''' 268 return self.access_requests.list(filter, *args, timeout=timeout)
SnapshotAccessRequests exposes the read only methods of the AccessRequests service for historical queries.
class
AccessRequestEventsHistory:
271class AccessRequestEventsHistory: 272 ''' 273 AccessRequestEventsHistory provides records of all changes to the state of an AccessRequest. 274 See `strongdm.models.AccessRequestEventHistory`. 275 ''' 276 def __init__(self, channel, client): 277 self.parent = client 278 self.stub = AccessRequestEventsHistoryStub(channel) 279 280 def list(self, filter, *args, timeout=None): 281 ''' 282 List gets a list of AccessRequestEventHistory records matching a given set of criteria. 283 ''' 284 deadline = None if timeout is None else time.time() + timeout 285 req = AccessRequestEventHistoryListRequest() 286 req.meta.CopyFrom(ListRequestMetadata()) 287 if self.parent.page_limit > 0: 288 req.meta.limit = self.parent.page_limit 289 if self.parent.snapshot_datetime is not None: 290 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 291 292 req.filter = plumbing.quote_filter_args(filter, *args) 293 294 def generator(svc, req): 295 tries = 0 296 while True: 297 t = None if deadline is None else deadline - time.time() 298 try: 299 plumbing_response = svc.stub.List( 300 req, 301 metadata=svc.parent.get_metadata( 302 'AccessRequestEventsHistory.List', req), 303 timeout=t) 304 except Exception as e: 305 if self.parent.shouldRetry(tries, e, deadline): 306 tries += 1 307 time.sleep( 308 self.parent.exponentialBackoff(tries, deadline)) 309 continue 310 raise plumbing.convert_error_to_porcelain(e) from e 311 tries = 0 312 for plumbing_item in plumbing_response.history: 313 yield plumbing.convert_access_request_event_history_to_porcelain( 314 plumbing_item) 315 if plumbing_response.meta.next_cursor == '': 316 break 317 req.meta.cursor = plumbing_response.meta.next_cursor 318 319 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)
280 def list(self, filter, *args, timeout=None): 281 ''' 282 List gets a list of AccessRequestEventHistory records matching a given set of criteria. 283 ''' 284 deadline = None if timeout is None else time.time() + timeout 285 req = AccessRequestEventHistoryListRequest() 286 req.meta.CopyFrom(ListRequestMetadata()) 287 if self.parent.page_limit > 0: 288 req.meta.limit = self.parent.page_limit 289 if self.parent.snapshot_datetime is not None: 290 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 291 292 req.filter = plumbing.quote_filter_args(filter, *args) 293 294 def generator(svc, req): 295 tries = 0 296 while True: 297 t = None if deadline is None else deadline - time.time() 298 try: 299 plumbing_response = svc.stub.List( 300 req, 301 metadata=svc.parent.get_metadata( 302 'AccessRequestEventsHistory.List', req), 303 timeout=t) 304 except Exception as e: 305 if self.parent.shouldRetry(tries, e, deadline): 306 tries += 1 307 time.sleep( 308 self.parent.exponentialBackoff(tries, deadline)) 309 continue 310 raise plumbing.convert_error_to_porcelain(e) from e 311 tries = 0 312 for plumbing_item in plumbing_response.history: 313 yield plumbing.convert_access_request_event_history_to_porcelain( 314 plumbing_item) 315 if plumbing_response.meta.next_cursor == '': 316 break 317 req.meta.cursor = plumbing_response.meta.next_cursor 318 319 return generator(self, req)
List gets a list of AccessRequestEventHistory records matching a given set of criteria.
class
AccessRequestsHistory:
322class AccessRequestsHistory: 323 ''' 324 AccessRequestsHistory provides records of all changes to the state of an AccessRequest. 325 See `strongdm.models.AccessRequestHistory`. 326 ''' 327 def __init__(self, channel, client): 328 self.parent = client 329 self.stub = AccessRequestsHistoryStub(channel) 330 331 def list(self, filter, *args, timeout=None): 332 ''' 333 List gets a list of AccessRequestHistory records matching a given set of criteria. 334 ''' 335 deadline = None if timeout is None else time.time() + timeout 336 req = AccessRequestHistoryListRequest() 337 req.meta.CopyFrom(ListRequestMetadata()) 338 if self.parent.page_limit > 0: 339 req.meta.limit = self.parent.page_limit 340 if self.parent.snapshot_datetime is not None: 341 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 342 343 req.filter = plumbing.quote_filter_args(filter, *args) 344 345 def generator(svc, req): 346 tries = 0 347 while True: 348 t = None if deadline is None else deadline - time.time() 349 try: 350 plumbing_response = svc.stub.List( 351 req, 352 metadata=svc.parent.get_metadata( 353 'AccessRequestsHistory.List', req), 354 timeout=t) 355 except Exception as e: 356 if self.parent.shouldRetry(tries, e, deadline): 357 tries += 1 358 time.sleep( 359 self.parent.exponentialBackoff(tries, deadline)) 360 continue 361 raise plumbing.convert_error_to_porcelain(e) from e 362 tries = 0 363 for plumbing_item in plumbing_response.history: 364 yield plumbing.convert_access_request_history_to_porcelain( 365 plumbing_item) 366 if plumbing_response.meta.next_cursor == '': 367 break 368 req.meta.cursor = plumbing_response.meta.next_cursor 369 370 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)
331 def list(self, filter, *args, timeout=None): 332 ''' 333 List gets a list of AccessRequestHistory records matching a given set of criteria. 334 ''' 335 deadline = None if timeout is None else time.time() + timeout 336 req = AccessRequestHistoryListRequest() 337 req.meta.CopyFrom(ListRequestMetadata()) 338 if self.parent.page_limit > 0: 339 req.meta.limit = self.parent.page_limit 340 if self.parent.snapshot_datetime is not None: 341 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 342 343 req.filter = plumbing.quote_filter_args(filter, *args) 344 345 def generator(svc, req): 346 tries = 0 347 while True: 348 t = None if deadline is None else deadline - time.time() 349 try: 350 plumbing_response = svc.stub.List( 351 req, 352 metadata=svc.parent.get_metadata( 353 'AccessRequestsHistory.List', req), 354 timeout=t) 355 except Exception as e: 356 if self.parent.shouldRetry(tries, e, deadline): 357 tries += 1 358 time.sleep( 359 self.parent.exponentialBackoff(tries, deadline)) 360 continue 361 raise plumbing.convert_error_to_porcelain(e) from e 362 tries = 0 363 for plumbing_item in plumbing_response.history: 364 yield plumbing.convert_access_request_history_to_porcelain( 365 plumbing_item) 366 if plumbing_response.meta.next_cursor == '': 367 break 368 req.meta.cursor = plumbing_response.meta.next_cursor 369 370 return generator(self, req)
List gets a list of AccessRequestHistory records matching a given set of criteria.
class
AccountAttachments:
373class AccountAttachments: 374 ''' 375 AccountAttachments assign an account to a role. 376 See `strongdm.models.AccountAttachment`. 377 ''' 378 def __init__(self, channel, client): 379 self.parent = client 380 self.stub = AccountAttachmentsStub(channel) 381 382 def create(self, account_attachment, timeout=None): 383 ''' 384 Create registers a new AccountAttachment. 385 ''' 386 deadline = None if timeout is None else time.time() + timeout 387 req = AccountAttachmentCreateRequest() 388 389 if account_attachment is not None: 390 req.account_attachment.CopyFrom( 391 plumbing.convert_account_attachment_to_plumbing( 392 account_attachment)) 393 tries = 0 394 plumbing_response = None 395 while True: 396 t = None if deadline is None else deadline - time.time() 397 try: 398 plumbing_response = self.stub.Create( 399 req, 400 metadata=self.parent.get_metadata( 401 'AccountAttachments.Create', req), 402 timeout=t) 403 except Exception as e: 404 if self.parent.shouldRetry(tries, e, deadline): 405 tries += 1 406 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 407 continue 408 raise plumbing.convert_error_to_porcelain(e) from e 409 break 410 411 resp = models.AccountAttachmentCreateResponse() 412 resp.account_attachment = plumbing.convert_account_attachment_to_porcelain( 413 plumbing_response.account_attachment) 414 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 415 plumbing_response.meta) 416 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 417 plumbing_response.rate_limit) 418 return resp 419 420 def get(self, id, timeout=None): 421 ''' 422 Get reads one AccountAttachment by ID. 423 ''' 424 deadline = None if timeout is None else time.time() + timeout 425 req = AccountAttachmentGetRequest() 426 if self.parent.snapshot_datetime is not None: 427 req.meta.CopyFrom(GetRequestMetadata()) 428 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 429 430 req.id = (id) 431 tries = 0 432 plumbing_response = None 433 while True: 434 t = None if deadline is None else deadline - time.time() 435 try: 436 plumbing_response = self.stub.Get( 437 req, 438 metadata=self.parent.get_metadata('AccountAttachments.Get', 439 req), 440 timeout=t) 441 except Exception as e: 442 if self.parent.shouldRetry(tries, e, deadline): 443 tries += 1 444 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 445 continue 446 raise plumbing.convert_error_to_porcelain(e) from e 447 break 448 449 resp = models.AccountAttachmentGetResponse() 450 resp.account_attachment = plumbing.convert_account_attachment_to_porcelain( 451 plumbing_response.account_attachment) 452 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 453 plumbing_response.meta) 454 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 455 plumbing_response.rate_limit) 456 return resp 457 458 def delete(self, id, timeout=None): 459 ''' 460 Delete removes a AccountAttachment by ID. 461 ''' 462 deadline = None if timeout is None else time.time() + timeout 463 req = AccountAttachmentDeleteRequest() 464 465 req.id = (id) 466 tries = 0 467 plumbing_response = None 468 while True: 469 t = None if deadline is None else deadline - time.time() 470 try: 471 plumbing_response = self.stub.Delete( 472 req, 473 metadata=self.parent.get_metadata( 474 'AccountAttachments.Delete', req), 475 timeout=t) 476 except Exception as e: 477 if self.parent.shouldRetry(tries, e, deadline): 478 tries += 1 479 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 480 continue 481 raise plumbing.convert_error_to_porcelain(e) from e 482 break 483 484 resp = models.AccountAttachmentDeleteResponse() 485 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 486 plumbing_response.meta) 487 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 488 plumbing_response.rate_limit) 489 return resp 490 491 def list(self, filter, *args, timeout=None): 492 ''' 493 List gets a list of AccountAttachments matching a given set of criteria. 494 ''' 495 deadline = None if timeout is None else time.time() + timeout 496 req = AccountAttachmentListRequest() 497 req.meta.CopyFrom(ListRequestMetadata()) 498 if self.parent.page_limit > 0: 499 req.meta.limit = self.parent.page_limit 500 if self.parent.snapshot_datetime is not None: 501 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 502 503 req.filter = plumbing.quote_filter_args(filter, *args) 504 505 def generator(svc, req): 506 tries = 0 507 while True: 508 t = None if deadline is None else deadline - time.time() 509 try: 510 plumbing_response = svc.stub.List( 511 req, 512 metadata=svc.parent.get_metadata( 513 'AccountAttachments.List', req), 514 timeout=t) 515 except Exception as e: 516 if self.parent.shouldRetry(tries, e, deadline): 517 tries += 1 518 time.sleep( 519 self.parent.exponentialBackoff(tries, deadline)) 520 continue 521 raise plumbing.convert_error_to_porcelain(e) from e 522 tries = 0 523 for plumbing_item in plumbing_response.account_attachments: 524 yield plumbing.convert_account_attachment_to_porcelain( 525 plumbing_item) 526 if plumbing_response.meta.next_cursor == '': 527 break 528 req.meta.cursor = plumbing_response.meta.next_cursor 529 530 return generator(self, req)
AccountAttachments assign an account to a role.
See strongdm.models.AccountAttachment.
def
create(self, account_attachment, timeout=None)
382 def create(self, account_attachment, timeout=None): 383 ''' 384 Create registers a new AccountAttachment. 385 ''' 386 deadline = None if timeout is None else time.time() + timeout 387 req = AccountAttachmentCreateRequest() 388 389 if account_attachment is not None: 390 req.account_attachment.CopyFrom( 391 plumbing.convert_account_attachment_to_plumbing( 392 account_attachment)) 393 tries = 0 394 plumbing_response = None 395 while True: 396 t = None if deadline is None else deadline - time.time() 397 try: 398 plumbing_response = self.stub.Create( 399 req, 400 metadata=self.parent.get_metadata( 401 'AccountAttachments.Create', req), 402 timeout=t) 403 except Exception as e: 404 if self.parent.shouldRetry(tries, e, deadline): 405 tries += 1 406 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 407 continue 408 raise plumbing.convert_error_to_porcelain(e) from e 409 break 410 411 resp = models.AccountAttachmentCreateResponse() 412 resp.account_attachment = plumbing.convert_account_attachment_to_porcelain( 413 plumbing_response.account_attachment) 414 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 415 plumbing_response.meta) 416 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 417 plumbing_response.rate_limit) 418 return resp
Create registers a new AccountAttachment.
def
get(self, id, timeout=None)
420 def get(self, id, timeout=None): 421 ''' 422 Get reads one AccountAttachment by ID. 423 ''' 424 deadline = None if timeout is None else time.time() + timeout 425 req = AccountAttachmentGetRequest() 426 if self.parent.snapshot_datetime is not None: 427 req.meta.CopyFrom(GetRequestMetadata()) 428 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 429 430 req.id = (id) 431 tries = 0 432 plumbing_response = None 433 while True: 434 t = None if deadline is None else deadline - time.time() 435 try: 436 plumbing_response = self.stub.Get( 437 req, 438 metadata=self.parent.get_metadata('AccountAttachments.Get', 439 req), 440 timeout=t) 441 except Exception as e: 442 if self.parent.shouldRetry(tries, e, deadline): 443 tries += 1 444 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 445 continue 446 raise plumbing.convert_error_to_porcelain(e) from e 447 break 448 449 resp = models.AccountAttachmentGetResponse() 450 resp.account_attachment = plumbing.convert_account_attachment_to_porcelain( 451 plumbing_response.account_attachment) 452 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 453 plumbing_response.meta) 454 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 455 plumbing_response.rate_limit) 456 return resp
Get reads one AccountAttachment by ID.
def
delete(self, id, timeout=None)
458 def delete(self, id, timeout=None): 459 ''' 460 Delete removes a AccountAttachment by ID. 461 ''' 462 deadline = None if timeout is None else time.time() + timeout 463 req = AccountAttachmentDeleteRequest() 464 465 req.id = (id) 466 tries = 0 467 plumbing_response = None 468 while True: 469 t = None if deadline is None else deadline - time.time() 470 try: 471 plumbing_response = self.stub.Delete( 472 req, 473 metadata=self.parent.get_metadata( 474 'AccountAttachments.Delete', req), 475 timeout=t) 476 except Exception as e: 477 if self.parent.shouldRetry(tries, e, deadline): 478 tries += 1 479 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 480 continue 481 raise plumbing.convert_error_to_porcelain(e) from e 482 break 483 484 resp = models.AccountAttachmentDeleteResponse() 485 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 486 plumbing_response.meta) 487 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 488 plumbing_response.rate_limit) 489 return resp
Delete removes a AccountAttachment by ID.
def
list(self, filter, *args, timeout=None)
491 def list(self, filter, *args, timeout=None): 492 ''' 493 List gets a list of AccountAttachments matching a given set of criteria. 494 ''' 495 deadline = None if timeout is None else time.time() + timeout 496 req = AccountAttachmentListRequest() 497 req.meta.CopyFrom(ListRequestMetadata()) 498 if self.parent.page_limit > 0: 499 req.meta.limit = self.parent.page_limit 500 if self.parent.snapshot_datetime is not None: 501 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 502 503 req.filter = plumbing.quote_filter_args(filter, *args) 504 505 def generator(svc, req): 506 tries = 0 507 while True: 508 t = None if deadline is None else deadline - time.time() 509 try: 510 plumbing_response = svc.stub.List( 511 req, 512 metadata=svc.parent.get_metadata( 513 'AccountAttachments.List', req), 514 timeout=t) 515 except Exception as e: 516 if self.parent.shouldRetry(tries, e, deadline): 517 tries += 1 518 time.sleep( 519 self.parent.exponentialBackoff(tries, deadline)) 520 continue 521 raise plumbing.convert_error_to_porcelain(e) from e 522 tries = 0 523 for plumbing_item in plumbing_response.account_attachments: 524 yield plumbing.convert_account_attachment_to_porcelain( 525 plumbing_item) 526 if plumbing_response.meta.next_cursor == '': 527 break 528 req.meta.cursor = plumbing_response.meta.next_cursor 529 530 return generator(self, req)
List gets a list of AccountAttachments matching a given set of criteria.
class
SnapshotAccountAttachments:
533class SnapshotAccountAttachments: 534 ''' 535 SnapshotAccountAttachments exposes the read only methods of the AccountAttachments 536 service for historical queries. 537 ''' 538 def __init__(self, account_attachments): 539 self.account_attachments = account_attachments 540 541 def get(self, id, timeout=None): 542 ''' 543 Get reads one AccountAttachment by ID. 544 ''' 545 return self.account_attachments.get(id, timeout=timeout) 546 547 def list(self, filter, *args, timeout=None): 548 ''' 549 List gets a list of AccountAttachments matching a given set of criteria. 550 ''' 551 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)
541 def get(self, id, timeout=None): 542 ''' 543 Get reads one AccountAttachment by ID. 544 ''' 545 return self.account_attachments.get(id, timeout=timeout)
Get reads one AccountAttachment by ID.
def
list(self, filter, *args, timeout=None)
547 def list(self, filter, *args, timeout=None): 548 ''' 549 List gets a list of AccountAttachments matching a given set of criteria. 550 ''' 551 return self.account_attachments.list(filter, *args, timeout=timeout)
List gets a list of AccountAttachments matching a given set of criteria.
class
AccountAttachmentsHistory:
554class AccountAttachmentsHistory: 555 ''' 556 AccountAttachmentsHistory records all changes to the state of an AccountAttachment. 557 See `strongdm.models.AccountAttachmentHistory`. 558 ''' 559 def __init__(self, channel, client): 560 self.parent = client 561 self.stub = AccountAttachmentsHistoryStub(channel) 562 563 def list(self, filter, *args, timeout=None): 564 ''' 565 List gets a list of AccountAttachmentHistory records matching a given set of criteria. 566 ''' 567 deadline = None if timeout is None else time.time() + timeout 568 req = AccountAttachmentHistoryListRequest() 569 req.meta.CopyFrom(ListRequestMetadata()) 570 if self.parent.page_limit > 0: 571 req.meta.limit = self.parent.page_limit 572 if self.parent.snapshot_datetime is not None: 573 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 574 575 req.filter = plumbing.quote_filter_args(filter, *args) 576 577 def generator(svc, req): 578 tries = 0 579 while True: 580 t = None if deadline is None else deadline - time.time() 581 try: 582 plumbing_response = svc.stub.List( 583 req, 584 metadata=svc.parent.get_metadata( 585 'AccountAttachmentsHistory.List', req), 586 timeout=t) 587 except Exception as e: 588 if self.parent.shouldRetry(tries, e, deadline): 589 tries += 1 590 time.sleep( 591 self.parent.exponentialBackoff(tries, deadline)) 592 continue 593 raise plumbing.convert_error_to_porcelain(e) from e 594 tries = 0 595 for plumbing_item in plumbing_response.history: 596 yield plumbing.convert_account_attachment_history_to_porcelain( 597 plumbing_item) 598 if plumbing_response.meta.next_cursor == '': 599 break 600 req.meta.cursor = plumbing_response.meta.next_cursor 601 602 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)
563 def list(self, filter, *args, timeout=None): 564 ''' 565 List gets a list of AccountAttachmentHistory records matching a given set of criteria. 566 ''' 567 deadline = None if timeout is None else time.time() + timeout 568 req = AccountAttachmentHistoryListRequest() 569 req.meta.CopyFrom(ListRequestMetadata()) 570 if self.parent.page_limit > 0: 571 req.meta.limit = self.parent.page_limit 572 if self.parent.snapshot_datetime is not None: 573 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 574 575 req.filter = plumbing.quote_filter_args(filter, *args) 576 577 def generator(svc, req): 578 tries = 0 579 while True: 580 t = None if deadline is None else deadline - time.time() 581 try: 582 plumbing_response = svc.stub.List( 583 req, 584 metadata=svc.parent.get_metadata( 585 'AccountAttachmentsHistory.List', req), 586 timeout=t) 587 except Exception as e: 588 if self.parent.shouldRetry(tries, e, deadline): 589 tries += 1 590 time.sleep( 591 self.parent.exponentialBackoff(tries, deadline)) 592 continue 593 raise plumbing.convert_error_to_porcelain(e) from e 594 tries = 0 595 for plumbing_item in plumbing_response.history: 596 yield plumbing.convert_account_attachment_history_to_porcelain( 597 plumbing_item) 598 if plumbing_response.meta.next_cursor == '': 599 break 600 req.meta.cursor = plumbing_response.meta.next_cursor 601 602 return generator(self, req)
List gets a list of AccountAttachmentHistory records matching a given set of criteria.
class
AccountGrants:
605class AccountGrants: 606 ''' 607 AccountGrants assign a resource directly to an account, giving the account the permission to connect to that resource. 608 See `strongdm.models.AccountGrant`. 609 ''' 610 def __init__(self, channel, client): 611 self.parent = client 612 self.stub = AccountGrantsStub(channel) 613 614 def create(self, account_grant, timeout=None): 615 ''' 616 Create registers a new AccountGrant. 617 ''' 618 deadline = None if timeout is None else time.time() + timeout 619 req = AccountGrantCreateRequest() 620 621 if account_grant is not None: 622 req.account_grant.CopyFrom( 623 plumbing.convert_account_grant_to_plumbing(account_grant)) 624 tries = 0 625 plumbing_response = None 626 while True: 627 t = None if deadline is None else deadline - time.time() 628 try: 629 plumbing_response = self.stub.Create( 630 req, 631 metadata=self.parent.get_metadata('AccountGrants.Create', 632 req), 633 timeout=t) 634 except Exception as e: 635 if self.parent.shouldRetry(tries, e, deadline): 636 tries += 1 637 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 638 continue 639 raise plumbing.convert_error_to_porcelain(e) from e 640 break 641 642 resp = models.AccountGrantCreateResponse() 643 resp.account_grant = plumbing.convert_account_grant_to_porcelain( 644 plumbing_response.account_grant) 645 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 646 plumbing_response.meta) 647 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 648 plumbing_response.rate_limit) 649 return resp 650 651 def get(self, id, timeout=None): 652 ''' 653 Get reads one AccountGrant by ID. 654 ''' 655 deadline = None if timeout is None else time.time() + timeout 656 req = AccountGrantGetRequest() 657 if self.parent.snapshot_datetime is not None: 658 req.meta.CopyFrom(GetRequestMetadata()) 659 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 660 661 req.id = (id) 662 tries = 0 663 plumbing_response = None 664 while True: 665 t = None if deadline is None else deadline - time.time() 666 try: 667 plumbing_response = self.stub.Get( 668 req, 669 metadata=self.parent.get_metadata('AccountGrants.Get', 670 req), 671 timeout=t) 672 except Exception as e: 673 if self.parent.shouldRetry(tries, e, deadline): 674 tries += 1 675 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 676 continue 677 raise plumbing.convert_error_to_porcelain(e) from e 678 break 679 680 resp = models.AccountGrantGetResponse() 681 resp.account_grant = plumbing.convert_account_grant_to_porcelain( 682 plumbing_response.account_grant) 683 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 684 plumbing_response.meta) 685 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 686 plumbing_response.rate_limit) 687 return resp 688 689 def delete(self, id, timeout=None): 690 ''' 691 Delete removes a AccountGrant by ID. 692 ''' 693 deadline = None if timeout is None else time.time() + timeout 694 req = AccountGrantDeleteRequest() 695 696 req.id = (id) 697 tries = 0 698 plumbing_response = None 699 while True: 700 t = None if deadline is None else deadline - time.time() 701 try: 702 plumbing_response = self.stub.Delete( 703 req, 704 metadata=self.parent.get_metadata('AccountGrants.Delete', 705 req), 706 timeout=t) 707 except Exception as e: 708 if self.parent.shouldRetry(tries, e, deadline): 709 tries += 1 710 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 711 continue 712 raise plumbing.convert_error_to_porcelain(e) from e 713 break 714 715 resp = models.AccountGrantDeleteResponse() 716 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 717 plumbing_response.meta) 718 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 719 plumbing_response.rate_limit) 720 return resp 721 722 def list(self, filter, *args, timeout=None): 723 ''' 724 List gets a list of AccountGrants matching a given set of criteria. 725 ''' 726 deadline = None if timeout is None else time.time() + timeout 727 req = AccountGrantListRequest() 728 req.meta.CopyFrom(ListRequestMetadata()) 729 if self.parent.page_limit > 0: 730 req.meta.limit = self.parent.page_limit 731 if self.parent.snapshot_datetime is not None: 732 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 733 734 req.filter = plumbing.quote_filter_args(filter, *args) 735 736 def generator(svc, req): 737 tries = 0 738 while True: 739 t = None if deadline is None else deadline - time.time() 740 try: 741 plumbing_response = svc.stub.List( 742 req, 743 metadata=svc.parent.get_metadata( 744 'AccountGrants.List', req), 745 timeout=t) 746 except Exception as e: 747 if self.parent.shouldRetry(tries, e, deadline): 748 tries += 1 749 time.sleep( 750 self.parent.exponentialBackoff(tries, deadline)) 751 continue 752 raise plumbing.convert_error_to_porcelain(e) from e 753 tries = 0 754 for plumbing_item in plumbing_response.account_grants: 755 yield plumbing.convert_account_grant_to_porcelain( 756 plumbing_item) 757 if plumbing_response.meta.next_cursor == '': 758 break 759 req.meta.cursor = plumbing_response.meta.next_cursor 760 761 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)
614 def create(self, account_grant, timeout=None): 615 ''' 616 Create registers a new AccountGrant. 617 ''' 618 deadline = None if timeout is None else time.time() + timeout 619 req = AccountGrantCreateRequest() 620 621 if account_grant is not None: 622 req.account_grant.CopyFrom( 623 plumbing.convert_account_grant_to_plumbing(account_grant)) 624 tries = 0 625 plumbing_response = None 626 while True: 627 t = None if deadline is None else deadline - time.time() 628 try: 629 plumbing_response = self.stub.Create( 630 req, 631 metadata=self.parent.get_metadata('AccountGrants.Create', 632 req), 633 timeout=t) 634 except Exception as e: 635 if self.parent.shouldRetry(tries, e, deadline): 636 tries += 1 637 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 638 continue 639 raise plumbing.convert_error_to_porcelain(e) from e 640 break 641 642 resp = models.AccountGrantCreateResponse() 643 resp.account_grant = plumbing.convert_account_grant_to_porcelain( 644 plumbing_response.account_grant) 645 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 646 plumbing_response.meta) 647 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 648 plumbing_response.rate_limit) 649 return resp
Create registers a new AccountGrant.
def
get(self, id, timeout=None)
651 def get(self, id, timeout=None): 652 ''' 653 Get reads one AccountGrant by ID. 654 ''' 655 deadline = None if timeout is None else time.time() + timeout 656 req = AccountGrantGetRequest() 657 if self.parent.snapshot_datetime is not None: 658 req.meta.CopyFrom(GetRequestMetadata()) 659 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 660 661 req.id = (id) 662 tries = 0 663 plumbing_response = None 664 while True: 665 t = None if deadline is None else deadline - time.time() 666 try: 667 plumbing_response = self.stub.Get( 668 req, 669 metadata=self.parent.get_metadata('AccountGrants.Get', 670 req), 671 timeout=t) 672 except Exception as e: 673 if self.parent.shouldRetry(tries, e, deadline): 674 tries += 1 675 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 676 continue 677 raise plumbing.convert_error_to_porcelain(e) from e 678 break 679 680 resp = models.AccountGrantGetResponse() 681 resp.account_grant = plumbing.convert_account_grant_to_porcelain( 682 plumbing_response.account_grant) 683 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 684 plumbing_response.meta) 685 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 686 plumbing_response.rate_limit) 687 return resp
Get reads one AccountGrant by ID.
def
delete(self, id, timeout=None)
689 def delete(self, id, timeout=None): 690 ''' 691 Delete removes a AccountGrant by ID. 692 ''' 693 deadline = None if timeout is None else time.time() + timeout 694 req = AccountGrantDeleteRequest() 695 696 req.id = (id) 697 tries = 0 698 plumbing_response = None 699 while True: 700 t = None if deadline is None else deadline - time.time() 701 try: 702 plumbing_response = self.stub.Delete( 703 req, 704 metadata=self.parent.get_metadata('AccountGrants.Delete', 705 req), 706 timeout=t) 707 except Exception as e: 708 if self.parent.shouldRetry(tries, e, deadline): 709 tries += 1 710 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 711 continue 712 raise plumbing.convert_error_to_porcelain(e) from e 713 break 714 715 resp = models.AccountGrantDeleteResponse() 716 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 717 plumbing_response.meta) 718 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 719 plumbing_response.rate_limit) 720 return resp
Delete removes a AccountGrant by ID.
def
list(self, filter, *args, timeout=None)
722 def list(self, filter, *args, timeout=None): 723 ''' 724 List gets a list of AccountGrants matching a given set of criteria. 725 ''' 726 deadline = None if timeout is None else time.time() + timeout 727 req = AccountGrantListRequest() 728 req.meta.CopyFrom(ListRequestMetadata()) 729 if self.parent.page_limit > 0: 730 req.meta.limit = self.parent.page_limit 731 if self.parent.snapshot_datetime is not None: 732 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 733 734 req.filter = plumbing.quote_filter_args(filter, *args) 735 736 def generator(svc, req): 737 tries = 0 738 while True: 739 t = None if deadline is None else deadline - time.time() 740 try: 741 plumbing_response = svc.stub.List( 742 req, 743 metadata=svc.parent.get_metadata( 744 'AccountGrants.List', req), 745 timeout=t) 746 except Exception as e: 747 if self.parent.shouldRetry(tries, e, deadline): 748 tries += 1 749 time.sleep( 750 self.parent.exponentialBackoff(tries, deadline)) 751 continue 752 raise plumbing.convert_error_to_porcelain(e) from e 753 tries = 0 754 for plumbing_item in plumbing_response.account_grants: 755 yield plumbing.convert_account_grant_to_porcelain( 756 plumbing_item) 757 if plumbing_response.meta.next_cursor == '': 758 break 759 req.meta.cursor = plumbing_response.meta.next_cursor 760 761 return generator(self, req)
List gets a list of AccountGrants matching a given set of criteria.
class
SnapshotAccountGrants:
764class SnapshotAccountGrants: 765 ''' 766 SnapshotAccountGrants exposes the read only methods of the AccountGrants 767 service for historical queries. 768 ''' 769 def __init__(self, account_grants): 770 self.account_grants = account_grants 771 772 def get(self, id, timeout=None): 773 ''' 774 Get reads one AccountGrant by ID. 775 ''' 776 return self.account_grants.get(id, timeout=timeout) 777 778 def list(self, filter, *args, timeout=None): 779 ''' 780 List gets a list of AccountGrants matching a given set of criteria. 781 ''' 782 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)
772 def get(self, id, timeout=None): 773 ''' 774 Get reads one AccountGrant by ID. 775 ''' 776 return self.account_grants.get(id, timeout=timeout)
Get reads one AccountGrant by ID.
def
list(self, filter, *args, timeout=None)
778 def list(self, filter, *args, timeout=None): 779 ''' 780 List gets a list of AccountGrants matching a given set of criteria. 781 ''' 782 return self.account_grants.list(filter, *args, timeout=timeout)
List gets a list of AccountGrants matching a given set of criteria.
class
AccountGrantsHistory:
785class AccountGrantsHistory: 786 ''' 787 AccountGrantsHistory records all changes to the state of an AccountGrant. 788 See `strongdm.models.AccountGrantHistory`. 789 ''' 790 def __init__(self, channel, client): 791 self.parent = client 792 self.stub = AccountGrantsHistoryStub(channel) 793 794 def list(self, filter, *args, timeout=None): 795 ''' 796 List gets a list of AccountGrantHistory records matching a given set of criteria. 797 ''' 798 deadline = None if timeout is None else time.time() + timeout 799 req = AccountGrantHistoryListRequest() 800 req.meta.CopyFrom(ListRequestMetadata()) 801 if self.parent.page_limit > 0: 802 req.meta.limit = self.parent.page_limit 803 if self.parent.snapshot_datetime is not None: 804 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 805 806 req.filter = plumbing.quote_filter_args(filter, *args) 807 808 def generator(svc, req): 809 tries = 0 810 while True: 811 t = None if deadline is None else deadline - time.time() 812 try: 813 plumbing_response = svc.stub.List( 814 req, 815 metadata=svc.parent.get_metadata( 816 'AccountGrantsHistory.List', req), 817 timeout=t) 818 except Exception as e: 819 if self.parent.shouldRetry(tries, e, deadline): 820 tries += 1 821 time.sleep( 822 self.parent.exponentialBackoff(tries, deadline)) 823 continue 824 raise plumbing.convert_error_to_porcelain(e) from e 825 tries = 0 826 for plumbing_item in plumbing_response.history: 827 yield plumbing.convert_account_grant_history_to_porcelain( 828 plumbing_item) 829 if plumbing_response.meta.next_cursor == '': 830 break 831 req.meta.cursor = plumbing_response.meta.next_cursor 832 833 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)
794 def list(self, filter, *args, timeout=None): 795 ''' 796 List gets a list of AccountGrantHistory records matching a given set of criteria. 797 ''' 798 deadline = None if timeout is None else time.time() + timeout 799 req = AccountGrantHistoryListRequest() 800 req.meta.CopyFrom(ListRequestMetadata()) 801 if self.parent.page_limit > 0: 802 req.meta.limit = self.parent.page_limit 803 if self.parent.snapshot_datetime is not None: 804 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 805 806 req.filter = plumbing.quote_filter_args(filter, *args) 807 808 def generator(svc, req): 809 tries = 0 810 while True: 811 t = None if deadline is None else deadline - time.time() 812 try: 813 plumbing_response = svc.stub.List( 814 req, 815 metadata=svc.parent.get_metadata( 816 'AccountGrantsHistory.List', req), 817 timeout=t) 818 except Exception as e: 819 if self.parent.shouldRetry(tries, e, deadline): 820 tries += 1 821 time.sleep( 822 self.parent.exponentialBackoff(tries, deadline)) 823 continue 824 raise plumbing.convert_error_to_porcelain(e) from e 825 tries = 0 826 for plumbing_item in plumbing_response.history: 827 yield plumbing.convert_account_grant_history_to_porcelain( 828 plumbing_item) 829 if plumbing_response.meta.next_cursor == '': 830 break 831 req.meta.cursor = plumbing_response.meta.next_cursor 832 833 return generator(self, req)
List gets a list of AccountGrantHistory records matching a given set of criteria.
class
AccountPermissions:
836class AccountPermissions: 837 ''' 838 AccountPermissions records the granular permissions accounts have, allowing them to execute 839 relevant commands via StrongDM's APIs. 840 See `strongdm.models.AccountPermission`. 841 ''' 842 def __init__(self, channel, client): 843 self.parent = client 844 self.stub = AccountPermissionsStub(channel) 845 846 def list(self, filter, *args, timeout=None): 847 ''' 848 List gets a list of Permission records matching a given set of criteria. 849 ''' 850 deadline = None if timeout is None else time.time() + timeout 851 req = AccountPermissionListRequest() 852 req.meta.CopyFrom(ListRequestMetadata()) 853 if self.parent.page_limit > 0: 854 req.meta.limit = self.parent.page_limit 855 if self.parent.snapshot_datetime is not None: 856 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 857 858 req.filter = plumbing.quote_filter_args(filter, *args) 859 860 def generator(svc, req): 861 tries = 0 862 while True: 863 t = None if deadline is None else deadline - time.time() 864 try: 865 plumbing_response = svc.stub.List( 866 req, 867 metadata=svc.parent.get_metadata( 868 'AccountPermissions.List', req), 869 timeout=t) 870 except Exception as e: 871 if self.parent.shouldRetry(tries, e, deadline): 872 tries += 1 873 time.sleep( 874 self.parent.exponentialBackoff(tries, deadline)) 875 continue 876 raise plumbing.convert_error_to_porcelain(e) from e 877 tries = 0 878 for plumbing_item in plumbing_response.permissions: 879 yield plumbing.convert_account_permission_to_porcelain( 880 plumbing_item) 881 if plumbing_response.meta.next_cursor == '': 882 break 883 req.meta.cursor = plumbing_response.meta.next_cursor 884 885 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)
846 def list(self, filter, *args, timeout=None): 847 ''' 848 List gets a list of Permission records matching a given set of criteria. 849 ''' 850 deadline = None if timeout is None else time.time() + timeout 851 req = AccountPermissionListRequest() 852 req.meta.CopyFrom(ListRequestMetadata()) 853 if self.parent.page_limit > 0: 854 req.meta.limit = self.parent.page_limit 855 if self.parent.snapshot_datetime is not None: 856 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 857 858 req.filter = plumbing.quote_filter_args(filter, *args) 859 860 def generator(svc, req): 861 tries = 0 862 while True: 863 t = None if deadline is None else deadline - time.time() 864 try: 865 plumbing_response = svc.stub.List( 866 req, 867 metadata=svc.parent.get_metadata( 868 'AccountPermissions.List', req), 869 timeout=t) 870 except Exception as e: 871 if self.parent.shouldRetry(tries, e, deadline): 872 tries += 1 873 time.sleep( 874 self.parent.exponentialBackoff(tries, deadline)) 875 continue 876 raise plumbing.convert_error_to_porcelain(e) from e 877 tries = 0 878 for plumbing_item in plumbing_response.permissions: 879 yield plumbing.convert_account_permission_to_porcelain( 880 plumbing_item) 881 if plumbing_response.meta.next_cursor == '': 882 break 883 req.meta.cursor = plumbing_response.meta.next_cursor 884 885 return generator(self, req)
List gets a list of Permission records matching a given set of criteria.
class
SnapshotAccountPermissions:
888class SnapshotAccountPermissions: 889 ''' 890 SnapshotAccountPermissions exposes the read only methods of the AccountPermissions 891 service for historical queries. 892 ''' 893 def __init__(self, account_permissions): 894 self.account_permissions = account_permissions 895 896 def list(self, filter, *args, timeout=None): 897 ''' 898 List gets a list of Permission records matching a given set of criteria. 899 ''' 900 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)
896 def list(self, filter, *args, timeout=None): 897 ''' 898 List gets a list of Permission records matching a given set of criteria. 899 ''' 900 return self.account_permissions.list(filter, *args, timeout=timeout)
List gets a list of Permission records matching a given set of criteria.
class
AccountResources:
903class AccountResources: 904 ''' 905 AccountResources enumerates the resources to which accounts have access. 906 The AccountResources service is read-only. 907 See `strongdm.models.AccountResource`. 908 ''' 909 def __init__(self, channel, client): 910 self.parent = client 911 self.stub = AccountResourcesStub(channel) 912 913 def list(self, filter, *args, timeout=None): 914 ''' 915 List gets a list of AccountResource records matching a given set of criteria. 916 ''' 917 deadline = None if timeout is None else time.time() + timeout 918 req = AccountResourceListRequest() 919 req.meta.CopyFrom(ListRequestMetadata()) 920 if self.parent.page_limit > 0: 921 req.meta.limit = self.parent.page_limit 922 if self.parent.snapshot_datetime is not None: 923 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 924 925 req.filter = plumbing.quote_filter_args(filter, *args) 926 927 def generator(svc, req): 928 tries = 0 929 while True: 930 t = None if deadline is None else deadline - time.time() 931 try: 932 plumbing_response = svc.stub.List( 933 req, 934 metadata=svc.parent.get_metadata( 935 'AccountResources.List', req), 936 timeout=t) 937 except Exception as e: 938 if self.parent.shouldRetry(tries, e, deadline): 939 tries += 1 940 time.sleep( 941 self.parent.exponentialBackoff(tries, deadline)) 942 continue 943 raise plumbing.convert_error_to_porcelain(e) from e 944 tries = 0 945 for plumbing_item in plumbing_response.account_resources: 946 yield plumbing.convert_account_resource_to_porcelain( 947 plumbing_item) 948 if plumbing_response.meta.next_cursor == '': 949 break 950 req.meta.cursor = plumbing_response.meta.next_cursor 951 952 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)
913 def list(self, filter, *args, timeout=None): 914 ''' 915 List gets a list of AccountResource records matching a given set of criteria. 916 ''' 917 deadline = None if timeout is None else time.time() + timeout 918 req = AccountResourceListRequest() 919 req.meta.CopyFrom(ListRequestMetadata()) 920 if self.parent.page_limit > 0: 921 req.meta.limit = self.parent.page_limit 922 if self.parent.snapshot_datetime is not None: 923 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 924 925 req.filter = plumbing.quote_filter_args(filter, *args) 926 927 def generator(svc, req): 928 tries = 0 929 while True: 930 t = None if deadline is None else deadline - time.time() 931 try: 932 plumbing_response = svc.stub.List( 933 req, 934 metadata=svc.parent.get_metadata( 935 'AccountResources.List', req), 936 timeout=t) 937 except Exception as e: 938 if self.parent.shouldRetry(tries, e, deadline): 939 tries += 1 940 time.sleep( 941 self.parent.exponentialBackoff(tries, deadline)) 942 continue 943 raise plumbing.convert_error_to_porcelain(e) from e 944 tries = 0 945 for plumbing_item in plumbing_response.account_resources: 946 yield plumbing.convert_account_resource_to_porcelain( 947 plumbing_item) 948 if plumbing_response.meta.next_cursor == '': 949 break 950 req.meta.cursor = plumbing_response.meta.next_cursor 951 952 return generator(self, req)
List gets a list of AccountResource records matching a given set of criteria.
class
SnapshotAccountResources:
955class SnapshotAccountResources: 956 ''' 957 SnapshotAccountResources exposes the read only methods of the AccountResources 958 service for historical queries. 959 ''' 960 def __init__(self, account_resources): 961 self.account_resources = account_resources 962 963 def list(self, filter, *args, timeout=None): 964 ''' 965 List gets a list of AccountResource records matching a given set of criteria. 966 ''' 967 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)
963 def list(self, filter, *args, timeout=None): 964 ''' 965 List gets a list of AccountResource records matching a given set of criteria. 966 ''' 967 return self.account_resources.list(filter, *args, timeout=timeout)
List gets a list of AccountResource records matching a given set of criteria.
class
AccountResourcesHistory:
970class AccountResourcesHistory: 971 ''' 972 AccountResourcesHistory records all changes to the state of a AccountResource. 973 See `strongdm.models.AccountResourceHistory`. 974 ''' 975 def __init__(self, channel, client): 976 self.parent = client 977 self.stub = AccountResourcesHistoryStub(channel) 978 979 def list(self, filter, *args, timeout=None): 980 ''' 981 List gets a list of AccountResourceHistory records matching a given set of criteria. 982 ''' 983 deadline = None if timeout is None else time.time() + timeout 984 req = AccountResourceHistoryListRequest() 985 req.meta.CopyFrom(ListRequestMetadata()) 986 if self.parent.page_limit > 0: 987 req.meta.limit = self.parent.page_limit 988 if self.parent.snapshot_datetime is not None: 989 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 990 991 req.filter = plumbing.quote_filter_args(filter, *args) 992 993 def generator(svc, req): 994 tries = 0 995 while True: 996 t = None if deadline is None else deadline - time.time() 997 try: 998 plumbing_response = svc.stub.List( 999 req, 1000 metadata=svc.parent.get_metadata( 1001 'AccountResourcesHistory.List', req), 1002 timeout=t) 1003 except Exception as e: 1004 if self.parent.shouldRetry(tries, e, deadline): 1005 tries += 1 1006 time.sleep( 1007 self.parent.exponentialBackoff(tries, deadline)) 1008 continue 1009 raise plumbing.convert_error_to_porcelain(e) from e 1010 tries = 0 1011 for plumbing_item in plumbing_response.history: 1012 yield plumbing.convert_account_resource_history_to_porcelain( 1013 plumbing_item) 1014 if plumbing_response.meta.next_cursor == '': 1015 break 1016 req.meta.cursor = plumbing_response.meta.next_cursor 1017 1018 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)
979 def list(self, filter, *args, timeout=None): 980 ''' 981 List gets a list of AccountResourceHistory records matching a given set of criteria. 982 ''' 983 deadline = None if timeout is None else time.time() + timeout 984 req = AccountResourceHistoryListRequest() 985 req.meta.CopyFrom(ListRequestMetadata()) 986 if self.parent.page_limit > 0: 987 req.meta.limit = self.parent.page_limit 988 if self.parent.snapshot_datetime is not None: 989 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 990 991 req.filter = plumbing.quote_filter_args(filter, *args) 992 993 def generator(svc, req): 994 tries = 0 995 while True: 996 t = None if deadline is None else deadline - time.time() 997 try: 998 plumbing_response = svc.stub.List( 999 req, 1000 metadata=svc.parent.get_metadata( 1001 'AccountResourcesHistory.List', req), 1002 timeout=t) 1003 except Exception as e: 1004 if self.parent.shouldRetry(tries, e, deadline): 1005 tries += 1 1006 time.sleep( 1007 self.parent.exponentialBackoff(tries, deadline)) 1008 continue 1009 raise plumbing.convert_error_to_porcelain(e) from e 1010 tries = 0 1011 for plumbing_item in plumbing_response.history: 1012 yield plumbing.convert_account_resource_history_to_porcelain( 1013 plumbing_item) 1014 if plumbing_response.meta.next_cursor == '': 1015 break 1016 req.meta.cursor = plumbing_response.meta.next_cursor 1017 1018 return generator(self, req)
List gets a list of AccountResourceHistory records matching a given set of criteria.
class
Accounts:
1021class Accounts: 1022 ''' 1023 Accounts are users that have access to strongDM. There are two types of accounts: 1024 1. **Users:** humans who are authenticated through username and password or SSO. 1025 2. **Service Accounts:** machines that are authenticated using a service token. 1026 3. **Tokens** are access keys with permissions that can be used for authentication. 1027 See: 1028 `strongdm.models.Service` 1029 `strongdm.models.Token` 1030 `strongdm.models.User` 1031 ''' 1032 def __init__(self, channel, client): 1033 self.parent = client 1034 self.stub = AccountsStub(channel) 1035 1036 def create(self, account, timeout=None): 1037 ''' 1038 Create registers a new Account. 1039 ''' 1040 deadline = None if timeout is None else time.time() + timeout 1041 req = AccountCreateRequest() 1042 1043 if account is not None: 1044 req.account.CopyFrom(plumbing.convert_account_to_plumbing(account)) 1045 tries = 0 1046 plumbing_response = None 1047 while True: 1048 t = None if deadline is None else deadline - time.time() 1049 try: 1050 plumbing_response = self.stub.Create( 1051 req, 1052 metadata=self.parent.get_metadata('Accounts.Create', req), 1053 timeout=t) 1054 except Exception as e: 1055 if self.parent.shouldRetry(tries, e, deadline): 1056 tries += 1 1057 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1058 continue 1059 raise plumbing.convert_error_to_porcelain(e) from e 1060 break 1061 1062 resp = models.AccountCreateResponse() 1063 resp.access_key = (plumbing_response.access_key) 1064 resp.account = plumbing.convert_account_to_porcelain( 1065 plumbing_response.account) 1066 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 1067 plumbing_response.meta) 1068 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1069 plumbing_response.rate_limit) 1070 resp.secret_key = (plumbing_response.secret_key) 1071 resp.token = (plumbing_response.token) 1072 return resp 1073 1074 def get(self, id, timeout=None): 1075 ''' 1076 Get reads one Account by ID. 1077 ''' 1078 deadline = None if timeout is None else time.time() + timeout 1079 req = AccountGetRequest() 1080 if self.parent.snapshot_datetime is not None: 1081 req.meta.CopyFrom(GetRequestMetadata()) 1082 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1083 1084 req.id = (id) 1085 tries = 0 1086 plumbing_response = None 1087 while True: 1088 t = None if deadline is None else deadline - time.time() 1089 try: 1090 plumbing_response = self.stub.Get( 1091 req, 1092 metadata=self.parent.get_metadata('Accounts.Get', req), 1093 timeout=t) 1094 except Exception as e: 1095 if self.parent.shouldRetry(tries, e, deadline): 1096 tries += 1 1097 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1098 continue 1099 raise plumbing.convert_error_to_porcelain(e) from e 1100 break 1101 1102 resp = models.AccountGetResponse() 1103 resp.account = plumbing.convert_account_to_porcelain( 1104 plumbing_response.account) 1105 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1106 plumbing_response.meta) 1107 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1108 plumbing_response.rate_limit) 1109 return resp 1110 1111 def update(self, account, timeout=None): 1112 ''' 1113 Update replaces all the fields of an Account by ID. 1114 ''' 1115 deadline = None if timeout is None else time.time() + timeout 1116 req = AccountUpdateRequest() 1117 1118 if account is not None: 1119 req.account.CopyFrom(plumbing.convert_account_to_plumbing(account)) 1120 tries = 0 1121 plumbing_response = None 1122 while True: 1123 t = None if deadline is None else deadline - time.time() 1124 try: 1125 plumbing_response = self.stub.Update( 1126 req, 1127 metadata=self.parent.get_metadata('Accounts.Update', req), 1128 timeout=t) 1129 except Exception as e: 1130 if self.parent.shouldRetry(tries, e, deadline): 1131 tries += 1 1132 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1133 continue 1134 raise plumbing.convert_error_to_porcelain(e) from e 1135 break 1136 1137 resp = models.AccountUpdateResponse() 1138 resp.account = plumbing.convert_account_to_porcelain( 1139 plumbing_response.account) 1140 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 1141 plumbing_response.meta) 1142 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1143 plumbing_response.rate_limit) 1144 return resp 1145 1146 def delete(self, id, timeout=None): 1147 ''' 1148 Delete removes an Account by ID. 1149 ''' 1150 deadline = None if timeout is None else time.time() + timeout 1151 req = AccountDeleteRequest() 1152 1153 req.id = (id) 1154 tries = 0 1155 plumbing_response = None 1156 while True: 1157 t = None if deadline is None else deadline - time.time() 1158 try: 1159 plumbing_response = self.stub.Delete( 1160 req, 1161 metadata=self.parent.get_metadata('Accounts.Delete', req), 1162 timeout=t) 1163 except Exception as e: 1164 if self.parent.shouldRetry(tries, e, deadline): 1165 tries += 1 1166 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1167 continue 1168 raise plumbing.convert_error_to_porcelain(e) from e 1169 break 1170 1171 resp = models.AccountDeleteResponse() 1172 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 1173 plumbing_response.meta) 1174 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1175 plumbing_response.rate_limit) 1176 return resp 1177 1178 def list(self, filter, *args, timeout=None): 1179 ''' 1180 List gets a list of Accounts matching a given set of criteria. 1181 ''' 1182 deadline = None if timeout is None else time.time() + timeout 1183 req = AccountListRequest() 1184 req.meta.CopyFrom(ListRequestMetadata()) 1185 if self.parent.page_limit > 0: 1186 req.meta.limit = self.parent.page_limit 1187 if self.parent.snapshot_datetime is not None: 1188 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1189 1190 req.filter = plumbing.quote_filter_args(filter, *args) 1191 1192 def generator(svc, req): 1193 tries = 0 1194 while True: 1195 t = None if deadline is None else deadline - time.time() 1196 try: 1197 plumbing_response = svc.stub.List( 1198 req, 1199 metadata=svc.parent.get_metadata('Accounts.List', req), 1200 timeout=t) 1201 except Exception as e: 1202 if self.parent.shouldRetry(tries, e, deadline): 1203 tries += 1 1204 time.sleep( 1205 self.parent.exponentialBackoff(tries, deadline)) 1206 continue 1207 raise plumbing.convert_error_to_porcelain(e) from e 1208 tries = 0 1209 for plumbing_item in plumbing_response.accounts: 1210 yield plumbing.convert_account_to_porcelain(plumbing_item) 1211 if plumbing_response.meta.next_cursor == '': 1212 break 1213 req.meta.cursor = plumbing_response.meta.next_cursor 1214 1215 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)
1036 def create(self, account, timeout=None): 1037 ''' 1038 Create registers a new Account. 1039 ''' 1040 deadline = None if timeout is None else time.time() + timeout 1041 req = AccountCreateRequest() 1042 1043 if account is not None: 1044 req.account.CopyFrom(plumbing.convert_account_to_plumbing(account)) 1045 tries = 0 1046 plumbing_response = None 1047 while True: 1048 t = None if deadline is None else deadline - time.time() 1049 try: 1050 plumbing_response = self.stub.Create( 1051 req, 1052 metadata=self.parent.get_metadata('Accounts.Create', req), 1053 timeout=t) 1054 except Exception as e: 1055 if self.parent.shouldRetry(tries, e, deadline): 1056 tries += 1 1057 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1058 continue 1059 raise plumbing.convert_error_to_porcelain(e) from e 1060 break 1061 1062 resp = models.AccountCreateResponse() 1063 resp.access_key = (plumbing_response.access_key) 1064 resp.account = plumbing.convert_account_to_porcelain( 1065 plumbing_response.account) 1066 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 1067 plumbing_response.meta) 1068 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1069 plumbing_response.rate_limit) 1070 resp.secret_key = (plumbing_response.secret_key) 1071 resp.token = (plumbing_response.token) 1072 return resp
Create registers a new Account.
def
get(self, id, timeout=None)
1074 def get(self, id, timeout=None): 1075 ''' 1076 Get reads one Account by ID. 1077 ''' 1078 deadline = None if timeout is None else time.time() + timeout 1079 req = AccountGetRequest() 1080 if self.parent.snapshot_datetime is not None: 1081 req.meta.CopyFrom(GetRequestMetadata()) 1082 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1083 1084 req.id = (id) 1085 tries = 0 1086 plumbing_response = None 1087 while True: 1088 t = None if deadline is None else deadline - time.time() 1089 try: 1090 plumbing_response = self.stub.Get( 1091 req, 1092 metadata=self.parent.get_metadata('Accounts.Get', req), 1093 timeout=t) 1094 except Exception as e: 1095 if self.parent.shouldRetry(tries, e, deadline): 1096 tries += 1 1097 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1098 continue 1099 raise plumbing.convert_error_to_porcelain(e) from e 1100 break 1101 1102 resp = models.AccountGetResponse() 1103 resp.account = plumbing.convert_account_to_porcelain( 1104 plumbing_response.account) 1105 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1106 plumbing_response.meta) 1107 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1108 plumbing_response.rate_limit) 1109 return resp
Get reads one Account by ID.
def
update(self, account, timeout=None)
1111 def update(self, account, timeout=None): 1112 ''' 1113 Update replaces all the fields of an Account by ID. 1114 ''' 1115 deadline = None if timeout is None else time.time() + timeout 1116 req = AccountUpdateRequest() 1117 1118 if account is not None: 1119 req.account.CopyFrom(plumbing.convert_account_to_plumbing(account)) 1120 tries = 0 1121 plumbing_response = None 1122 while True: 1123 t = None if deadline is None else deadline - time.time() 1124 try: 1125 plumbing_response = self.stub.Update( 1126 req, 1127 metadata=self.parent.get_metadata('Accounts.Update', req), 1128 timeout=t) 1129 except Exception as e: 1130 if self.parent.shouldRetry(tries, e, deadline): 1131 tries += 1 1132 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1133 continue 1134 raise plumbing.convert_error_to_porcelain(e) from e 1135 break 1136 1137 resp = models.AccountUpdateResponse() 1138 resp.account = plumbing.convert_account_to_porcelain( 1139 plumbing_response.account) 1140 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 1141 plumbing_response.meta) 1142 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1143 plumbing_response.rate_limit) 1144 return resp
Update replaces all the fields of an Account by ID.
def
delete(self, id, timeout=None)
1146 def delete(self, id, timeout=None): 1147 ''' 1148 Delete removes an Account by ID. 1149 ''' 1150 deadline = None if timeout is None else time.time() + timeout 1151 req = AccountDeleteRequest() 1152 1153 req.id = (id) 1154 tries = 0 1155 plumbing_response = None 1156 while True: 1157 t = None if deadline is None else deadline - time.time() 1158 try: 1159 plumbing_response = self.stub.Delete( 1160 req, 1161 metadata=self.parent.get_metadata('Accounts.Delete', req), 1162 timeout=t) 1163 except Exception as e: 1164 if self.parent.shouldRetry(tries, e, deadline): 1165 tries += 1 1166 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1167 continue 1168 raise plumbing.convert_error_to_porcelain(e) from e 1169 break 1170 1171 resp = models.AccountDeleteResponse() 1172 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 1173 plumbing_response.meta) 1174 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1175 plumbing_response.rate_limit) 1176 return resp
Delete removes an Account by ID.
def
list(self, filter, *args, timeout=None)
1178 def list(self, filter, *args, timeout=None): 1179 ''' 1180 List gets a list of Accounts matching a given set of criteria. 1181 ''' 1182 deadline = None if timeout is None else time.time() + timeout 1183 req = AccountListRequest() 1184 req.meta.CopyFrom(ListRequestMetadata()) 1185 if self.parent.page_limit > 0: 1186 req.meta.limit = self.parent.page_limit 1187 if self.parent.snapshot_datetime is not None: 1188 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1189 1190 req.filter = plumbing.quote_filter_args(filter, *args) 1191 1192 def generator(svc, req): 1193 tries = 0 1194 while True: 1195 t = None if deadline is None else deadline - time.time() 1196 try: 1197 plumbing_response = svc.stub.List( 1198 req, 1199 metadata=svc.parent.get_metadata('Accounts.List', req), 1200 timeout=t) 1201 except Exception as e: 1202 if self.parent.shouldRetry(tries, e, deadline): 1203 tries += 1 1204 time.sleep( 1205 self.parent.exponentialBackoff(tries, deadline)) 1206 continue 1207 raise plumbing.convert_error_to_porcelain(e) from e 1208 tries = 0 1209 for plumbing_item in plumbing_response.accounts: 1210 yield plumbing.convert_account_to_porcelain(plumbing_item) 1211 if plumbing_response.meta.next_cursor == '': 1212 break 1213 req.meta.cursor = plumbing_response.meta.next_cursor 1214 1215 return generator(self, req)
List gets a list of Accounts matching a given set of criteria.
class
SnapshotAccounts:
1218class SnapshotAccounts: 1219 ''' 1220 SnapshotAccounts exposes the read only methods of the Accounts 1221 service for historical queries. 1222 ''' 1223 def __init__(self, accounts): 1224 self.accounts = accounts 1225 1226 def get(self, id, timeout=None): 1227 ''' 1228 Get reads one Account by ID. 1229 ''' 1230 return self.accounts.get(id, timeout=timeout) 1231 1232 def list(self, filter, *args, timeout=None): 1233 ''' 1234 List gets a list of Accounts matching a given set of criteria. 1235 ''' 1236 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)
1226 def get(self, id, timeout=None): 1227 ''' 1228 Get reads one Account by ID. 1229 ''' 1230 return self.accounts.get(id, timeout=timeout)
Get reads one Account by ID.
def
list(self, filter, *args, timeout=None)
1232 def list(self, filter, *args, timeout=None): 1233 ''' 1234 List gets a list of Accounts matching a given set of criteria. 1235 ''' 1236 return self.accounts.list(filter, *args, timeout=timeout)
List gets a list of Accounts matching a given set of criteria.
class
AccountsGroups:
1239class AccountsGroups: 1240 ''' 1241 An AccountGroup links an account and a group. 1242 See `strongdm.models.AccountGroup`. 1243 ''' 1244 def __init__(self, channel, client): 1245 self.parent = client 1246 self.stub = AccountsGroupsStub(channel) 1247 1248 def create(self, account_group, timeout=None): 1249 ''' 1250 Create create a new AccountGroup. 1251 ''' 1252 deadline = None if timeout is None else time.time() + timeout 1253 req = AccountGroupCreateRequest() 1254 1255 if account_group is not None: 1256 req.account_group.CopyFrom( 1257 plumbing.convert_account_group_to_plumbing(account_group)) 1258 tries = 0 1259 plumbing_response = None 1260 while True: 1261 t = None if deadline is None else deadline - time.time() 1262 try: 1263 plumbing_response = self.stub.Create( 1264 req, 1265 metadata=self.parent.get_metadata('AccountsGroups.Create', 1266 req), 1267 timeout=t) 1268 except Exception as e: 1269 if self.parent.shouldRetry(tries, e, deadline): 1270 tries += 1 1271 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1272 continue 1273 raise plumbing.convert_error_to_porcelain(e) from e 1274 break 1275 1276 resp = models.AccountGroupCreateResponse() 1277 resp.account_group = plumbing.convert_account_group_to_porcelain( 1278 plumbing_response.account_group) 1279 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1280 plumbing_response.rate_limit) 1281 return resp 1282 1283 def get(self, id, timeout=None): 1284 ''' 1285 Get reads one AccountGroup by ID. 1286 ''' 1287 deadline = None if timeout is None else time.time() + timeout 1288 req = AccountGroupGetRequest() 1289 if self.parent.snapshot_datetime is not None: 1290 req.meta.CopyFrom(GetRequestMetadata()) 1291 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1292 1293 req.id = (id) 1294 tries = 0 1295 plumbing_response = None 1296 while True: 1297 t = None if deadline is None else deadline - time.time() 1298 try: 1299 plumbing_response = self.stub.Get( 1300 req, 1301 metadata=self.parent.get_metadata('AccountsGroups.Get', 1302 req), 1303 timeout=t) 1304 except Exception as e: 1305 if self.parent.shouldRetry(tries, e, deadline): 1306 tries += 1 1307 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1308 continue 1309 raise plumbing.convert_error_to_porcelain(e) from e 1310 break 1311 1312 resp = models.AccountGroupGetResponse() 1313 resp.account_group = plumbing.convert_account_group_to_porcelain( 1314 plumbing_response.account_group) 1315 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1316 plumbing_response.meta) 1317 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1318 plumbing_response.rate_limit) 1319 return resp 1320 1321 def delete(self, id, timeout=None): 1322 ''' 1323 Delete removes an AccountGroup by ID. 1324 ''' 1325 deadline = None if timeout is None else time.time() + timeout 1326 req = AccountGroupDeleteRequest() 1327 1328 req.id = (id) 1329 tries = 0 1330 plumbing_response = None 1331 while True: 1332 t = None if deadline is None else deadline - time.time() 1333 try: 1334 plumbing_response = self.stub.Delete( 1335 req, 1336 metadata=self.parent.get_metadata('AccountsGroups.Delete', 1337 req), 1338 timeout=t) 1339 except Exception as e: 1340 if self.parent.shouldRetry(tries, e, deadline): 1341 tries += 1 1342 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1343 continue 1344 raise plumbing.convert_error_to_porcelain(e) from e 1345 break 1346 1347 resp = models.AccountGroupDeleteResponse() 1348 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 1349 plumbing_response.meta) 1350 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1351 plumbing_response.rate_limit) 1352 return resp 1353 1354 def list(self, filter, *args, timeout=None): 1355 ''' 1356 List gets a list of AccountGroups matching a given set of criteria. 1357 ''' 1358 deadline = None if timeout is None else time.time() + timeout 1359 req = AccountGroupListRequest() 1360 req.meta.CopyFrom(ListRequestMetadata()) 1361 if self.parent.page_limit > 0: 1362 req.meta.limit = self.parent.page_limit 1363 if self.parent.snapshot_datetime is not None: 1364 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1365 1366 req.filter = plumbing.quote_filter_args(filter, *args) 1367 1368 def generator(svc, req): 1369 tries = 0 1370 while True: 1371 t = None if deadline is None else deadline - time.time() 1372 try: 1373 plumbing_response = svc.stub.List( 1374 req, 1375 metadata=svc.parent.get_metadata( 1376 'AccountsGroups.List', req), 1377 timeout=t) 1378 except Exception as e: 1379 if self.parent.shouldRetry(tries, e, deadline): 1380 tries += 1 1381 time.sleep( 1382 self.parent.exponentialBackoff(tries, deadline)) 1383 continue 1384 raise plumbing.convert_error_to_porcelain(e) from e 1385 tries = 0 1386 for plumbing_item in plumbing_response.account_groups: 1387 yield plumbing.convert_account_group_to_porcelain( 1388 plumbing_item) 1389 if plumbing_response.meta.next_cursor == '': 1390 break 1391 req.meta.cursor = plumbing_response.meta.next_cursor 1392 1393 return generator(self, req)
An AccountGroup links an account and a group.
See strongdm.models.AccountGroup.
def
create(self, account_group, timeout=None)
1248 def create(self, account_group, timeout=None): 1249 ''' 1250 Create create a new AccountGroup. 1251 ''' 1252 deadline = None if timeout is None else time.time() + timeout 1253 req = AccountGroupCreateRequest() 1254 1255 if account_group is not None: 1256 req.account_group.CopyFrom( 1257 plumbing.convert_account_group_to_plumbing(account_group)) 1258 tries = 0 1259 plumbing_response = None 1260 while True: 1261 t = None if deadline is None else deadline - time.time() 1262 try: 1263 plumbing_response = self.stub.Create( 1264 req, 1265 metadata=self.parent.get_metadata('AccountsGroups.Create', 1266 req), 1267 timeout=t) 1268 except Exception as e: 1269 if self.parent.shouldRetry(tries, e, deadline): 1270 tries += 1 1271 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1272 continue 1273 raise plumbing.convert_error_to_porcelain(e) from e 1274 break 1275 1276 resp = models.AccountGroupCreateResponse() 1277 resp.account_group = plumbing.convert_account_group_to_porcelain( 1278 plumbing_response.account_group) 1279 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1280 plumbing_response.rate_limit) 1281 return resp
Create create a new AccountGroup.
def
get(self, id, timeout=None)
1283 def get(self, id, timeout=None): 1284 ''' 1285 Get reads one AccountGroup by ID. 1286 ''' 1287 deadline = None if timeout is None else time.time() + timeout 1288 req = AccountGroupGetRequest() 1289 if self.parent.snapshot_datetime is not None: 1290 req.meta.CopyFrom(GetRequestMetadata()) 1291 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1292 1293 req.id = (id) 1294 tries = 0 1295 plumbing_response = None 1296 while True: 1297 t = None if deadline is None else deadline - time.time() 1298 try: 1299 plumbing_response = self.stub.Get( 1300 req, 1301 metadata=self.parent.get_metadata('AccountsGroups.Get', 1302 req), 1303 timeout=t) 1304 except Exception as e: 1305 if self.parent.shouldRetry(tries, e, deadline): 1306 tries += 1 1307 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1308 continue 1309 raise plumbing.convert_error_to_porcelain(e) from e 1310 break 1311 1312 resp = models.AccountGroupGetResponse() 1313 resp.account_group = plumbing.convert_account_group_to_porcelain( 1314 plumbing_response.account_group) 1315 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1316 plumbing_response.meta) 1317 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1318 plumbing_response.rate_limit) 1319 return resp
Get reads one AccountGroup by ID.
def
delete(self, id, timeout=None)
1321 def delete(self, id, timeout=None): 1322 ''' 1323 Delete removes an AccountGroup by ID. 1324 ''' 1325 deadline = None if timeout is None else time.time() + timeout 1326 req = AccountGroupDeleteRequest() 1327 1328 req.id = (id) 1329 tries = 0 1330 plumbing_response = None 1331 while True: 1332 t = None if deadline is None else deadline - time.time() 1333 try: 1334 plumbing_response = self.stub.Delete( 1335 req, 1336 metadata=self.parent.get_metadata('AccountsGroups.Delete', 1337 req), 1338 timeout=t) 1339 except Exception as e: 1340 if self.parent.shouldRetry(tries, e, deadline): 1341 tries += 1 1342 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1343 continue 1344 raise plumbing.convert_error_to_porcelain(e) from e 1345 break 1346 1347 resp = models.AccountGroupDeleteResponse() 1348 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 1349 plumbing_response.meta) 1350 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1351 plumbing_response.rate_limit) 1352 return resp
Delete removes an AccountGroup by ID.
def
list(self, filter, *args, timeout=None)
1354 def list(self, filter, *args, timeout=None): 1355 ''' 1356 List gets a list of AccountGroups matching a given set of criteria. 1357 ''' 1358 deadline = None if timeout is None else time.time() + timeout 1359 req = AccountGroupListRequest() 1360 req.meta.CopyFrom(ListRequestMetadata()) 1361 if self.parent.page_limit > 0: 1362 req.meta.limit = self.parent.page_limit 1363 if self.parent.snapshot_datetime is not None: 1364 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1365 1366 req.filter = plumbing.quote_filter_args(filter, *args) 1367 1368 def generator(svc, req): 1369 tries = 0 1370 while True: 1371 t = None if deadline is None else deadline - time.time() 1372 try: 1373 plumbing_response = svc.stub.List( 1374 req, 1375 metadata=svc.parent.get_metadata( 1376 'AccountsGroups.List', req), 1377 timeout=t) 1378 except Exception as e: 1379 if self.parent.shouldRetry(tries, e, deadline): 1380 tries += 1 1381 time.sleep( 1382 self.parent.exponentialBackoff(tries, deadline)) 1383 continue 1384 raise plumbing.convert_error_to_porcelain(e) from e 1385 tries = 0 1386 for plumbing_item in plumbing_response.account_groups: 1387 yield plumbing.convert_account_group_to_porcelain( 1388 plumbing_item) 1389 if plumbing_response.meta.next_cursor == '': 1390 break 1391 req.meta.cursor = plumbing_response.meta.next_cursor 1392 1393 return generator(self, req)
List gets a list of AccountGroups matching a given set of criteria.
class
SnapshotAccountsGroups:
1396class SnapshotAccountsGroups: 1397 ''' 1398 SnapshotAccountsGroups exposes the read only methods of the AccountsGroups 1399 service for historical queries. 1400 ''' 1401 def __init__(self, accounts_groups): 1402 self.accounts_groups = accounts_groups 1403 1404 def get(self, id, timeout=None): 1405 ''' 1406 Get reads one AccountGroup by ID. 1407 ''' 1408 return self.accounts_groups.get(id, timeout=timeout) 1409 1410 def list(self, filter, *args, timeout=None): 1411 ''' 1412 List gets a list of AccountGroups matching a given set of criteria. 1413 ''' 1414 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)
1404 def get(self, id, timeout=None): 1405 ''' 1406 Get reads one AccountGroup by ID. 1407 ''' 1408 return self.accounts_groups.get(id, timeout=timeout)
Get reads one AccountGroup by ID.
def
list(self, filter, *args, timeout=None)
1410 def list(self, filter, *args, timeout=None): 1411 ''' 1412 List gets a list of AccountGroups matching a given set of criteria. 1413 ''' 1414 return self.accounts_groups.list(filter, *args, timeout=timeout)
List gets a list of AccountGroups matching a given set of criteria.
class
AccountsGroupsHistory:
1417class AccountsGroupsHistory: 1418 ''' 1419 AccountsGroupsHistory records all changes to the state of an AccountGroup. 1420 See `strongdm.models.AccountGroupHistory`. 1421 ''' 1422 def __init__(self, channel, client): 1423 self.parent = client 1424 self.stub = AccountsGroupsHistoryStub(channel) 1425 1426 def list(self, filter, *args, timeout=None): 1427 ''' 1428 List gets a list of AccountGroupHistory records matching a given set of criteria. 1429 ''' 1430 deadline = None if timeout is None else time.time() + timeout 1431 req = AccountGroupHistoryListRequest() 1432 req.meta.CopyFrom(ListRequestMetadata()) 1433 if self.parent.page_limit > 0: 1434 req.meta.limit = self.parent.page_limit 1435 if self.parent.snapshot_datetime is not None: 1436 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1437 1438 req.filter = plumbing.quote_filter_args(filter, *args) 1439 1440 def generator(svc, req): 1441 tries = 0 1442 while True: 1443 t = None if deadline is None else deadline - time.time() 1444 try: 1445 plumbing_response = svc.stub.List( 1446 req, 1447 metadata=svc.parent.get_metadata( 1448 'AccountsGroupsHistory.List', req), 1449 timeout=t) 1450 except Exception as e: 1451 if self.parent.shouldRetry(tries, e, deadline): 1452 tries += 1 1453 time.sleep( 1454 self.parent.exponentialBackoff(tries, deadline)) 1455 continue 1456 raise plumbing.convert_error_to_porcelain(e) from e 1457 tries = 0 1458 for plumbing_item in plumbing_response.history: 1459 yield plumbing.convert_account_group_history_to_porcelain( 1460 plumbing_item) 1461 if plumbing_response.meta.next_cursor == '': 1462 break 1463 req.meta.cursor = plumbing_response.meta.next_cursor 1464 1465 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)
1426 def list(self, filter, *args, timeout=None): 1427 ''' 1428 List gets a list of AccountGroupHistory records matching a given set of criteria. 1429 ''' 1430 deadline = None if timeout is None else time.time() + timeout 1431 req = AccountGroupHistoryListRequest() 1432 req.meta.CopyFrom(ListRequestMetadata()) 1433 if self.parent.page_limit > 0: 1434 req.meta.limit = self.parent.page_limit 1435 if self.parent.snapshot_datetime is not None: 1436 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1437 1438 req.filter = plumbing.quote_filter_args(filter, *args) 1439 1440 def generator(svc, req): 1441 tries = 0 1442 while True: 1443 t = None if deadline is None else deadline - time.time() 1444 try: 1445 plumbing_response = svc.stub.List( 1446 req, 1447 metadata=svc.parent.get_metadata( 1448 'AccountsGroupsHistory.List', req), 1449 timeout=t) 1450 except Exception as e: 1451 if self.parent.shouldRetry(tries, e, deadline): 1452 tries += 1 1453 time.sleep( 1454 self.parent.exponentialBackoff(tries, deadline)) 1455 continue 1456 raise plumbing.convert_error_to_porcelain(e) from e 1457 tries = 0 1458 for plumbing_item in plumbing_response.history: 1459 yield plumbing.convert_account_group_history_to_porcelain( 1460 plumbing_item) 1461 if plumbing_response.meta.next_cursor == '': 1462 break 1463 req.meta.cursor = plumbing_response.meta.next_cursor 1464 1465 return generator(self, req)
List gets a list of AccountGroupHistory records matching a given set of criteria.
class
AccountsHistory:
1468class AccountsHistory: 1469 ''' 1470 AccountsHistory records all changes to the state of an Account. 1471 See `strongdm.models.AccountHistory`. 1472 ''' 1473 def __init__(self, channel, client): 1474 self.parent = client 1475 self.stub = AccountsHistoryStub(channel) 1476 1477 def list(self, filter, *args, timeout=None): 1478 ''' 1479 List gets a list of AccountHistory records matching a given set of criteria. 1480 ''' 1481 deadline = None if timeout is None else time.time() + timeout 1482 req = AccountHistoryListRequest() 1483 req.meta.CopyFrom(ListRequestMetadata()) 1484 if self.parent.page_limit > 0: 1485 req.meta.limit = self.parent.page_limit 1486 if self.parent.snapshot_datetime is not None: 1487 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1488 1489 req.filter = plumbing.quote_filter_args(filter, *args) 1490 1491 def generator(svc, req): 1492 tries = 0 1493 while True: 1494 t = None if deadline is None else deadline - time.time() 1495 try: 1496 plumbing_response = svc.stub.List( 1497 req, 1498 metadata=svc.parent.get_metadata( 1499 'AccountsHistory.List', req), 1500 timeout=t) 1501 except Exception as e: 1502 if self.parent.shouldRetry(tries, e, deadline): 1503 tries += 1 1504 time.sleep( 1505 self.parent.exponentialBackoff(tries, deadline)) 1506 continue 1507 raise plumbing.convert_error_to_porcelain(e) from e 1508 tries = 0 1509 for plumbing_item in plumbing_response.history: 1510 yield plumbing.convert_account_history_to_porcelain( 1511 plumbing_item) 1512 if plumbing_response.meta.next_cursor == '': 1513 break 1514 req.meta.cursor = plumbing_response.meta.next_cursor 1515 1516 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)
1477 def list(self, filter, *args, timeout=None): 1478 ''' 1479 List gets a list of AccountHistory records matching a given set of criteria. 1480 ''' 1481 deadline = None if timeout is None else time.time() + timeout 1482 req = AccountHistoryListRequest() 1483 req.meta.CopyFrom(ListRequestMetadata()) 1484 if self.parent.page_limit > 0: 1485 req.meta.limit = self.parent.page_limit 1486 if self.parent.snapshot_datetime is not None: 1487 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1488 1489 req.filter = plumbing.quote_filter_args(filter, *args) 1490 1491 def generator(svc, req): 1492 tries = 0 1493 while True: 1494 t = None if deadline is None else deadline - time.time() 1495 try: 1496 plumbing_response = svc.stub.List( 1497 req, 1498 metadata=svc.parent.get_metadata( 1499 'AccountsHistory.List', req), 1500 timeout=t) 1501 except Exception as e: 1502 if self.parent.shouldRetry(tries, e, deadline): 1503 tries += 1 1504 time.sleep( 1505 self.parent.exponentialBackoff(tries, deadline)) 1506 continue 1507 raise plumbing.convert_error_to_porcelain(e) from e 1508 tries = 0 1509 for plumbing_item in plumbing_response.history: 1510 yield plumbing.convert_account_history_to_porcelain( 1511 plumbing_item) 1512 if plumbing_response.meta.next_cursor == '': 1513 break 1514 req.meta.cursor = plumbing_response.meta.next_cursor 1515 1516 return generator(self, req)
List gets a list of AccountHistory records matching a given set of criteria.
class
Activities:
1519class Activities: 1520 ''' 1521 An Activity is a record of an action taken against a strongDM deployment, e.g. 1522 a user creation, resource deletion, sso configuration change, etc. The Activities 1523 service is read-only. 1524 See `strongdm.models.Activity`. 1525 ''' 1526 def __init__(self, channel, client): 1527 self.parent = client 1528 self.stub = ActivitiesStub(channel) 1529 1530 def get(self, id, timeout=None): 1531 ''' 1532 Get reads one Activity by ID. 1533 ''' 1534 deadline = None if timeout is None else time.time() + timeout 1535 req = ActivityGetRequest() 1536 if self.parent.snapshot_datetime is not None: 1537 req.meta.CopyFrom(GetRequestMetadata()) 1538 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1539 1540 req.id = (id) 1541 tries = 0 1542 plumbing_response = None 1543 while True: 1544 t = None if deadline is None else deadline - time.time() 1545 try: 1546 plumbing_response = self.stub.Get( 1547 req, 1548 metadata=self.parent.get_metadata('Activities.Get', req), 1549 timeout=t) 1550 except Exception as e: 1551 if self.parent.shouldRetry(tries, e, deadline): 1552 tries += 1 1553 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1554 continue 1555 raise plumbing.convert_error_to_porcelain(e) from e 1556 break 1557 1558 resp = models.ActivityGetResponse() 1559 resp.activity = plumbing.convert_activity_to_porcelain( 1560 plumbing_response.activity) 1561 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1562 plumbing_response.meta) 1563 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1564 plumbing_response.rate_limit) 1565 return resp 1566 1567 def list(self, filter, *args, timeout=None): 1568 ''' 1569 List gets a list of Activities matching a given set of criteria. 1570 The 'before' and 'after' filters can be used to control the time 1571 range of the output activities. If not provided, one week of back 1572 of activities will be returned. 1573 ''' 1574 deadline = None if timeout is None else time.time() + timeout 1575 req = ActivityListRequest() 1576 req.meta.CopyFrom(ListRequestMetadata()) 1577 if self.parent.page_limit > 0: 1578 req.meta.limit = self.parent.page_limit 1579 if self.parent.snapshot_datetime is not None: 1580 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1581 1582 req.filter = plumbing.quote_filter_args(filter, *args) 1583 1584 def generator(svc, req): 1585 tries = 0 1586 while True: 1587 t = None if deadline is None else deadline - time.time() 1588 try: 1589 plumbing_response = svc.stub.List( 1590 req, 1591 metadata=svc.parent.get_metadata( 1592 'Activities.List', req), 1593 timeout=t) 1594 except Exception as e: 1595 if self.parent.shouldRetry(tries, e, deadline): 1596 tries += 1 1597 time.sleep( 1598 self.parent.exponentialBackoff(tries, deadline)) 1599 continue 1600 raise plumbing.convert_error_to_porcelain(e) from e 1601 tries = 0 1602 for plumbing_item in plumbing_response.activities: 1603 yield plumbing.convert_activity_to_porcelain(plumbing_item) 1604 if plumbing_response.meta.next_cursor == '': 1605 break 1606 req.meta.cursor = plumbing_response.meta.next_cursor 1607 1608 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)
1530 def get(self, id, timeout=None): 1531 ''' 1532 Get reads one Activity by ID. 1533 ''' 1534 deadline = None if timeout is None else time.time() + timeout 1535 req = ActivityGetRequest() 1536 if self.parent.snapshot_datetime is not None: 1537 req.meta.CopyFrom(GetRequestMetadata()) 1538 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1539 1540 req.id = (id) 1541 tries = 0 1542 plumbing_response = None 1543 while True: 1544 t = None if deadline is None else deadline - time.time() 1545 try: 1546 plumbing_response = self.stub.Get( 1547 req, 1548 metadata=self.parent.get_metadata('Activities.Get', req), 1549 timeout=t) 1550 except Exception as e: 1551 if self.parent.shouldRetry(tries, e, deadline): 1552 tries += 1 1553 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1554 continue 1555 raise plumbing.convert_error_to_porcelain(e) from e 1556 break 1557 1558 resp = models.ActivityGetResponse() 1559 resp.activity = plumbing.convert_activity_to_porcelain( 1560 plumbing_response.activity) 1561 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1562 plumbing_response.meta) 1563 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1564 plumbing_response.rate_limit) 1565 return resp
Get reads one Activity by ID.
def
list(self, filter, *args, timeout=None)
1567 def list(self, filter, *args, timeout=None): 1568 ''' 1569 List gets a list of Activities matching a given set of criteria. 1570 The 'before' and 'after' filters can be used to control the time 1571 range of the output activities. If not provided, one week of back 1572 of activities will be returned. 1573 ''' 1574 deadline = None if timeout is None else time.time() + timeout 1575 req = ActivityListRequest() 1576 req.meta.CopyFrom(ListRequestMetadata()) 1577 if self.parent.page_limit > 0: 1578 req.meta.limit = self.parent.page_limit 1579 if self.parent.snapshot_datetime is not None: 1580 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1581 1582 req.filter = plumbing.quote_filter_args(filter, *args) 1583 1584 def generator(svc, req): 1585 tries = 0 1586 while True: 1587 t = None if deadline is None else deadline - time.time() 1588 try: 1589 plumbing_response = svc.stub.List( 1590 req, 1591 metadata=svc.parent.get_metadata( 1592 'Activities.List', req), 1593 timeout=t) 1594 except Exception as e: 1595 if self.parent.shouldRetry(tries, e, deadline): 1596 tries += 1 1597 time.sleep( 1598 self.parent.exponentialBackoff(tries, deadline)) 1599 continue 1600 raise plumbing.convert_error_to_porcelain(e) from e 1601 tries = 0 1602 for plumbing_item in plumbing_response.activities: 1603 yield plumbing.convert_activity_to_porcelain(plumbing_item) 1604 if plumbing_response.meta.next_cursor == '': 1605 break 1606 req.meta.cursor = plumbing_response.meta.next_cursor 1607 1608 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:
1611class ApprovalWorkflowApprovers: 1612 ''' 1613 ApprovalWorkflowApprovers link approval workflow approvers to an ApprovalWorkflowStep 1614 See `strongdm.models.ApprovalWorkflowApprover`. 1615 ''' 1616 def __init__(self, channel, client): 1617 self.parent = client 1618 self.stub = ApprovalWorkflowApproversStub(channel) 1619 1620 def create(self, approval_workflow_approver, timeout=None): 1621 ''' 1622 Deprecated: Create creates a new approval workflow approver. 1623 ''' 1624 deadline = None if timeout is None else time.time() + timeout 1625 req = ApprovalWorkflowApproverCreateRequest() 1626 1627 if approval_workflow_approver is not None: 1628 req.approval_workflow_approver.CopyFrom( 1629 plumbing.convert_approval_workflow_approver_to_plumbing( 1630 approval_workflow_approver)) 1631 tries = 0 1632 plumbing_response = None 1633 while True: 1634 t = None if deadline is None else deadline - time.time() 1635 try: 1636 plumbing_response = self.stub.Create( 1637 req, 1638 metadata=self.parent.get_metadata( 1639 'ApprovalWorkflowApprovers.Create', req), 1640 timeout=t) 1641 except Exception as e: 1642 if self.parent.shouldRetry(tries, e, deadline): 1643 tries += 1 1644 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1645 continue 1646 raise plumbing.convert_error_to_porcelain(e) from e 1647 break 1648 1649 resp = models.ApprovalWorkflowApproverCreateResponse() 1650 resp.approval_workflow_approver = plumbing.convert_approval_workflow_approver_to_porcelain( 1651 plumbing_response.approval_workflow_approver) 1652 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1653 plumbing_response.rate_limit) 1654 return resp 1655 1656 def get(self, id, timeout=None): 1657 ''' 1658 Deprecated: Get reads one approval workflow approver by ID. 1659 ''' 1660 deadline = None if timeout is None else time.time() + timeout 1661 req = ApprovalWorkflowApproverGetRequest() 1662 if self.parent.snapshot_datetime is not None: 1663 req.meta.CopyFrom(GetRequestMetadata()) 1664 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1665 1666 req.id = (id) 1667 tries = 0 1668 plumbing_response = None 1669 while True: 1670 t = None if deadline is None else deadline - time.time() 1671 try: 1672 plumbing_response = self.stub.Get( 1673 req, 1674 metadata=self.parent.get_metadata( 1675 'ApprovalWorkflowApprovers.Get', req), 1676 timeout=t) 1677 except Exception as e: 1678 if self.parent.shouldRetry(tries, e, deadline): 1679 tries += 1 1680 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1681 continue 1682 raise plumbing.convert_error_to_porcelain(e) from e 1683 break 1684 1685 resp = models.ApprovalWorkflowApproverGetResponse() 1686 resp.approval_workflow_approver = plumbing.convert_approval_workflow_approver_to_porcelain( 1687 plumbing_response.approval_workflow_approver) 1688 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1689 plumbing_response.meta) 1690 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1691 plumbing_response.rate_limit) 1692 return resp 1693 1694 def delete(self, id, timeout=None): 1695 ''' 1696 Deprecated: Delete deletes an existing approval workflow approver. 1697 ''' 1698 deadline = None if timeout is None else time.time() + timeout 1699 req = ApprovalWorkflowApproverDeleteRequest() 1700 1701 req.id = (id) 1702 tries = 0 1703 plumbing_response = None 1704 while True: 1705 t = None if deadline is None else deadline - time.time() 1706 try: 1707 plumbing_response = self.stub.Delete( 1708 req, 1709 metadata=self.parent.get_metadata( 1710 'ApprovalWorkflowApprovers.Delete', req), 1711 timeout=t) 1712 except Exception as e: 1713 if self.parent.shouldRetry(tries, e, deadline): 1714 tries += 1 1715 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1716 continue 1717 raise plumbing.convert_error_to_porcelain(e) from e 1718 break 1719 1720 resp = models.ApprovalWorkflowApproverDeleteResponse() 1721 resp.id = (plumbing_response.id) 1722 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1723 plumbing_response.rate_limit) 1724 return resp 1725 1726 def list(self, filter, *args, timeout=None): 1727 ''' 1728 Deprecated: Lists existing approval workflow approvers. 1729 ''' 1730 deadline = None if timeout is None else time.time() + timeout 1731 req = ApprovalWorkflowApproverListRequest() 1732 req.meta.CopyFrom(ListRequestMetadata()) 1733 if self.parent.page_limit > 0: 1734 req.meta.limit = self.parent.page_limit 1735 if self.parent.snapshot_datetime is not None: 1736 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1737 1738 req.filter = plumbing.quote_filter_args(filter, *args) 1739 1740 def generator(svc, req): 1741 tries = 0 1742 while True: 1743 t = None if deadline is None else deadline - time.time() 1744 try: 1745 plumbing_response = svc.stub.List( 1746 req, 1747 metadata=svc.parent.get_metadata( 1748 'ApprovalWorkflowApprovers.List', req), 1749 timeout=t) 1750 except Exception as e: 1751 if self.parent.shouldRetry(tries, e, deadline): 1752 tries += 1 1753 time.sleep( 1754 self.parent.exponentialBackoff(tries, deadline)) 1755 continue 1756 raise plumbing.convert_error_to_porcelain(e) from e 1757 tries = 0 1758 for plumbing_item in plumbing_response.approval_workflow_approvers: 1759 yield plumbing.convert_approval_workflow_approver_to_porcelain( 1760 plumbing_item) 1761 if plumbing_response.meta.next_cursor == '': 1762 break 1763 req.meta.cursor = plumbing_response.meta.next_cursor 1764 1765 return generator(self, req)
ApprovalWorkflowApprovers link approval workflow approvers to an ApprovalWorkflowStep
See strongdm.models.ApprovalWorkflowApprover.
def
create(self, approval_workflow_approver, timeout=None)
1620 def create(self, approval_workflow_approver, timeout=None): 1621 ''' 1622 Deprecated: Create creates a new approval workflow approver. 1623 ''' 1624 deadline = None if timeout is None else time.time() + timeout 1625 req = ApprovalWorkflowApproverCreateRequest() 1626 1627 if approval_workflow_approver is not None: 1628 req.approval_workflow_approver.CopyFrom( 1629 plumbing.convert_approval_workflow_approver_to_plumbing( 1630 approval_workflow_approver)) 1631 tries = 0 1632 plumbing_response = None 1633 while True: 1634 t = None if deadline is None else deadline - time.time() 1635 try: 1636 plumbing_response = self.stub.Create( 1637 req, 1638 metadata=self.parent.get_metadata( 1639 'ApprovalWorkflowApprovers.Create', req), 1640 timeout=t) 1641 except Exception as e: 1642 if self.parent.shouldRetry(tries, e, deadline): 1643 tries += 1 1644 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1645 continue 1646 raise plumbing.convert_error_to_porcelain(e) from e 1647 break 1648 1649 resp = models.ApprovalWorkflowApproverCreateResponse() 1650 resp.approval_workflow_approver = plumbing.convert_approval_workflow_approver_to_porcelain( 1651 plumbing_response.approval_workflow_approver) 1652 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1653 plumbing_response.rate_limit) 1654 return resp
Deprecated: Create creates a new approval workflow approver.
def
get(self, id, timeout=None)
1656 def get(self, id, timeout=None): 1657 ''' 1658 Deprecated: Get reads one approval workflow approver by ID. 1659 ''' 1660 deadline = None if timeout is None else time.time() + timeout 1661 req = ApprovalWorkflowApproverGetRequest() 1662 if self.parent.snapshot_datetime is not None: 1663 req.meta.CopyFrom(GetRequestMetadata()) 1664 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1665 1666 req.id = (id) 1667 tries = 0 1668 plumbing_response = None 1669 while True: 1670 t = None if deadline is None else deadline - time.time() 1671 try: 1672 plumbing_response = self.stub.Get( 1673 req, 1674 metadata=self.parent.get_metadata( 1675 'ApprovalWorkflowApprovers.Get', req), 1676 timeout=t) 1677 except Exception as e: 1678 if self.parent.shouldRetry(tries, e, deadline): 1679 tries += 1 1680 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1681 continue 1682 raise plumbing.convert_error_to_porcelain(e) from e 1683 break 1684 1685 resp = models.ApprovalWorkflowApproverGetResponse() 1686 resp.approval_workflow_approver = plumbing.convert_approval_workflow_approver_to_porcelain( 1687 plumbing_response.approval_workflow_approver) 1688 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1689 plumbing_response.meta) 1690 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1691 plumbing_response.rate_limit) 1692 return resp
Deprecated: Get reads one approval workflow approver by ID.
def
delete(self, id, timeout=None)
1694 def delete(self, id, timeout=None): 1695 ''' 1696 Deprecated: Delete deletes an existing approval workflow approver. 1697 ''' 1698 deadline = None if timeout is None else time.time() + timeout 1699 req = ApprovalWorkflowApproverDeleteRequest() 1700 1701 req.id = (id) 1702 tries = 0 1703 plumbing_response = None 1704 while True: 1705 t = None if deadline is None else deadline - time.time() 1706 try: 1707 plumbing_response = self.stub.Delete( 1708 req, 1709 metadata=self.parent.get_metadata( 1710 'ApprovalWorkflowApprovers.Delete', req), 1711 timeout=t) 1712 except Exception as e: 1713 if self.parent.shouldRetry(tries, e, deadline): 1714 tries += 1 1715 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1716 continue 1717 raise plumbing.convert_error_to_porcelain(e) from e 1718 break 1719 1720 resp = models.ApprovalWorkflowApproverDeleteResponse() 1721 resp.id = (plumbing_response.id) 1722 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1723 plumbing_response.rate_limit) 1724 return resp
Deprecated: Delete deletes an existing approval workflow approver.
def
list(self, filter, *args, timeout=None)
1726 def list(self, filter, *args, timeout=None): 1727 ''' 1728 Deprecated: Lists existing approval workflow approvers. 1729 ''' 1730 deadline = None if timeout is None else time.time() + timeout 1731 req = ApprovalWorkflowApproverListRequest() 1732 req.meta.CopyFrom(ListRequestMetadata()) 1733 if self.parent.page_limit > 0: 1734 req.meta.limit = self.parent.page_limit 1735 if self.parent.snapshot_datetime is not None: 1736 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1737 1738 req.filter = plumbing.quote_filter_args(filter, *args) 1739 1740 def generator(svc, req): 1741 tries = 0 1742 while True: 1743 t = None if deadline is None else deadline - time.time() 1744 try: 1745 plumbing_response = svc.stub.List( 1746 req, 1747 metadata=svc.parent.get_metadata( 1748 'ApprovalWorkflowApprovers.List', req), 1749 timeout=t) 1750 except Exception as e: 1751 if self.parent.shouldRetry(tries, e, deadline): 1752 tries += 1 1753 time.sleep( 1754 self.parent.exponentialBackoff(tries, deadline)) 1755 continue 1756 raise plumbing.convert_error_to_porcelain(e) from e 1757 tries = 0 1758 for plumbing_item in plumbing_response.approval_workflow_approvers: 1759 yield plumbing.convert_approval_workflow_approver_to_porcelain( 1760 plumbing_item) 1761 if plumbing_response.meta.next_cursor == '': 1762 break 1763 req.meta.cursor = plumbing_response.meta.next_cursor 1764 1765 return generator(self, req)
Deprecated: Lists existing approval workflow approvers.
class
SnapshotApprovalWorkflowApprovers:
1768class SnapshotApprovalWorkflowApprovers: 1769 ''' 1770 SnapshotApprovalWorkflowApprovers exposes the read only methods of the ApprovalWorkflowApprovers 1771 service for historical queries. 1772 ''' 1773 def __init__(self, approval_workflow_approvers): 1774 self.approval_workflow_approvers = approval_workflow_approvers 1775 1776 def get(self, id, timeout=None): 1777 ''' 1778 Deprecated: Get reads one approval workflow approver by ID. 1779 ''' 1780 return self.approval_workflow_approvers.get(id, timeout=timeout) 1781 1782 def list(self, filter, *args, timeout=None): 1783 ''' 1784 Deprecated: Lists existing approval workflow approvers. 1785 ''' 1786 return self.approval_workflow_approvers.list(filter, 1787 *args, 1788 timeout=timeout)
SnapshotApprovalWorkflowApprovers exposes the read only methods of the ApprovalWorkflowApprovers service for historical queries.
def
get(self, id, timeout=None)
1776 def get(self, id, timeout=None): 1777 ''' 1778 Deprecated: Get reads one approval workflow approver by ID. 1779 ''' 1780 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)
1782 def list(self, filter, *args, timeout=None): 1783 ''' 1784 Deprecated: Lists existing approval workflow approvers. 1785 ''' 1786 return self.approval_workflow_approvers.list(filter, 1787 *args, 1788 timeout=timeout)
Deprecated: Lists existing approval workflow approvers.
class
ApprovalWorkflowApproversHistory:
1791class ApprovalWorkflowApproversHistory: 1792 ''' 1793 ApprovalWorkflowApproversHistory records all changes to the state of an ApprovalWorkflowApprover. 1794 See `strongdm.models.ApprovalWorkflowApproverHistory`. 1795 ''' 1796 def __init__(self, channel, client): 1797 self.parent = client 1798 self.stub = ApprovalWorkflowApproversHistoryStub(channel) 1799 1800 def list(self, filter, *args, timeout=None): 1801 ''' 1802 List gets a list of ApprovalWorkflowApproverHistory records matching a given set of criteria. 1803 ''' 1804 deadline = None if timeout is None else time.time() + timeout 1805 req = ApprovalWorkflowApproverHistoryListRequest() 1806 req.meta.CopyFrom(ListRequestMetadata()) 1807 if self.parent.page_limit > 0: 1808 req.meta.limit = self.parent.page_limit 1809 if self.parent.snapshot_datetime is not None: 1810 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1811 1812 req.filter = plumbing.quote_filter_args(filter, *args) 1813 1814 def generator(svc, req): 1815 tries = 0 1816 while True: 1817 t = None if deadline is None else deadline - time.time() 1818 try: 1819 plumbing_response = svc.stub.List( 1820 req, 1821 metadata=svc.parent.get_metadata( 1822 'ApprovalWorkflowApproversHistory.List', req), 1823 timeout=t) 1824 except Exception as e: 1825 if self.parent.shouldRetry(tries, e, deadline): 1826 tries += 1 1827 time.sleep( 1828 self.parent.exponentialBackoff(tries, deadline)) 1829 continue 1830 raise plumbing.convert_error_to_porcelain(e) from e 1831 tries = 0 1832 for plumbing_item in plumbing_response.history: 1833 yield plumbing.convert_approval_workflow_approver_history_to_porcelain( 1834 plumbing_item) 1835 if plumbing_response.meta.next_cursor == '': 1836 break 1837 req.meta.cursor = plumbing_response.meta.next_cursor 1838 1839 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)
1800 def list(self, filter, *args, timeout=None): 1801 ''' 1802 List gets a list of ApprovalWorkflowApproverHistory records matching a given set of criteria. 1803 ''' 1804 deadline = None if timeout is None else time.time() + timeout 1805 req = ApprovalWorkflowApproverHistoryListRequest() 1806 req.meta.CopyFrom(ListRequestMetadata()) 1807 if self.parent.page_limit > 0: 1808 req.meta.limit = self.parent.page_limit 1809 if self.parent.snapshot_datetime is not None: 1810 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1811 1812 req.filter = plumbing.quote_filter_args(filter, *args) 1813 1814 def generator(svc, req): 1815 tries = 0 1816 while True: 1817 t = None if deadline is None else deadline - time.time() 1818 try: 1819 plumbing_response = svc.stub.List( 1820 req, 1821 metadata=svc.parent.get_metadata( 1822 'ApprovalWorkflowApproversHistory.List', req), 1823 timeout=t) 1824 except Exception as e: 1825 if self.parent.shouldRetry(tries, e, deadline): 1826 tries += 1 1827 time.sleep( 1828 self.parent.exponentialBackoff(tries, deadline)) 1829 continue 1830 raise plumbing.convert_error_to_porcelain(e) from e 1831 tries = 0 1832 for plumbing_item in plumbing_response.history: 1833 yield plumbing.convert_approval_workflow_approver_history_to_porcelain( 1834 plumbing_item) 1835 if plumbing_response.meta.next_cursor == '': 1836 break 1837 req.meta.cursor = plumbing_response.meta.next_cursor 1838 1839 return generator(self, req)
List gets a list of ApprovalWorkflowApproverHistory records matching a given set of criteria.
class
ApprovalWorkflowSteps:
1842class ApprovalWorkflowSteps: 1843 ''' 1844 ApprovalWorkflowSteps link approval workflow steps to an ApprovalWorkflow 1845 See `strongdm.models.ApprovalWorkflowStep`. 1846 ''' 1847 def __init__(self, channel, client): 1848 self.parent = client 1849 self.stub = ApprovalWorkflowStepsStub(channel) 1850 1851 def create(self, approval_workflow_step, timeout=None): 1852 ''' 1853 Deprecated: Create creates a new approval workflow step. 1854 ''' 1855 deadline = None if timeout is None else time.time() + timeout 1856 req = ApprovalWorkflowStepCreateRequest() 1857 1858 if approval_workflow_step is not None: 1859 req.approval_workflow_step.CopyFrom( 1860 plumbing.convert_approval_workflow_step_to_plumbing( 1861 approval_workflow_step)) 1862 tries = 0 1863 plumbing_response = None 1864 while True: 1865 t = None if deadline is None else deadline - time.time() 1866 try: 1867 plumbing_response = self.stub.Create( 1868 req, 1869 metadata=self.parent.get_metadata( 1870 'ApprovalWorkflowSteps.Create', req), 1871 timeout=t) 1872 except Exception as e: 1873 if self.parent.shouldRetry(tries, e, deadline): 1874 tries += 1 1875 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1876 continue 1877 raise plumbing.convert_error_to_porcelain(e) from e 1878 break 1879 1880 resp = models.ApprovalWorkflowStepCreateResponse() 1881 resp.approval_workflow_step = plumbing.convert_approval_workflow_step_to_porcelain( 1882 plumbing_response.approval_workflow_step) 1883 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1884 plumbing_response.rate_limit) 1885 return resp 1886 1887 def get(self, id, timeout=None): 1888 ''' 1889 Deprecated: Get reads one approval workflow step by ID. 1890 ''' 1891 deadline = None if timeout is None else time.time() + timeout 1892 req = ApprovalWorkflowStepGetRequest() 1893 if self.parent.snapshot_datetime is not None: 1894 req.meta.CopyFrom(GetRequestMetadata()) 1895 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1896 1897 req.id = (id) 1898 tries = 0 1899 plumbing_response = None 1900 while True: 1901 t = None if deadline is None else deadline - time.time() 1902 try: 1903 plumbing_response = self.stub.Get( 1904 req, 1905 metadata=self.parent.get_metadata( 1906 'ApprovalWorkflowSteps.Get', req), 1907 timeout=t) 1908 except Exception as e: 1909 if self.parent.shouldRetry(tries, e, deadline): 1910 tries += 1 1911 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1912 continue 1913 raise plumbing.convert_error_to_porcelain(e) from e 1914 break 1915 1916 resp = models.ApprovalWorkflowStepGetResponse() 1917 resp.approval_workflow_step = plumbing.convert_approval_workflow_step_to_porcelain( 1918 plumbing_response.approval_workflow_step) 1919 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1920 plumbing_response.meta) 1921 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1922 plumbing_response.rate_limit) 1923 return resp 1924 1925 def delete(self, id, timeout=None): 1926 ''' 1927 Deprecated: Delete deletes an existing approval workflow step. 1928 ''' 1929 deadline = None if timeout is None else time.time() + timeout 1930 req = ApprovalWorkflowStepDeleteRequest() 1931 1932 req.id = (id) 1933 tries = 0 1934 plumbing_response = None 1935 while True: 1936 t = None if deadline is None else deadline - time.time() 1937 try: 1938 plumbing_response = self.stub.Delete( 1939 req, 1940 metadata=self.parent.get_metadata( 1941 'ApprovalWorkflowSteps.Delete', req), 1942 timeout=t) 1943 except Exception as e: 1944 if self.parent.shouldRetry(tries, e, deadline): 1945 tries += 1 1946 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1947 continue 1948 raise plumbing.convert_error_to_porcelain(e) from e 1949 break 1950 1951 resp = models.ApprovalWorkflowStepDeleteResponse() 1952 resp.id = (plumbing_response.id) 1953 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1954 plumbing_response.rate_limit) 1955 return resp 1956 1957 def list(self, filter, *args, timeout=None): 1958 ''' 1959 Deprecated: Lists existing approval workflow steps. 1960 ''' 1961 deadline = None if timeout is None else time.time() + timeout 1962 req = ApprovalWorkflowStepListRequest() 1963 req.meta.CopyFrom(ListRequestMetadata()) 1964 if self.parent.page_limit > 0: 1965 req.meta.limit = self.parent.page_limit 1966 if self.parent.snapshot_datetime is not None: 1967 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1968 1969 req.filter = plumbing.quote_filter_args(filter, *args) 1970 1971 def generator(svc, req): 1972 tries = 0 1973 while True: 1974 t = None if deadline is None else deadline - time.time() 1975 try: 1976 plumbing_response = svc.stub.List( 1977 req, 1978 metadata=svc.parent.get_metadata( 1979 'ApprovalWorkflowSteps.List', req), 1980 timeout=t) 1981 except Exception as e: 1982 if self.parent.shouldRetry(tries, e, deadline): 1983 tries += 1 1984 time.sleep( 1985 self.parent.exponentialBackoff(tries, deadline)) 1986 continue 1987 raise plumbing.convert_error_to_porcelain(e) from e 1988 tries = 0 1989 for plumbing_item in plumbing_response.approval_workflow_steps: 1990 yield plumbing.convert_approval_workflow_step_to_porcelain( 1991 plumbing_item) 1992 if plumbing_response.meta.next_cursor == '': 1993 break 1994 req.meta.cursor = plumbing_response.meta.next_cursor 1995 1996 return generator(self, req)
ApprovalWorkflowSteps link approval workflow steps to an ApprovalWorkflow
See strongdm.models.ApprovalWorkflowStep.
def
create(self, approval_workflow_step, timeout=None)
1851 def create(self, approval_workflow_step, timeout=None): 1852 ''' 1853 Deprecated: Create creates a new approval workflow step. 1854 ''' 1855 deadline = None if timeout is None else time.time() + timeout 1856 req = ApprovalWorkflowStepCreateRequest() 1857 1858 if approval_workflow_step is not None: 1859 req.approval_workflow_step.CopyFrom( 1860 plumbing.convert_approval_workflow_step_to_plumbing( 1861 approval_workflow_step)) 1862 tries = 0 1863 plumbing_response = None 1864 while True: 1865 t = None if deadline is None else deadline - time.time() 1866 try: 1867 plumbing_response = self.stub.Create( 1868 req, 1869 metadata=self.parent.get_metadata( 1870 'ApprovalWorkflowSteps.Create', req), 1871 timeout=t) 1872 except Exception as e: 1873 if self.parent.shouldRetry(tries, e, deadline): 1874 tries += 1 1875 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1876 continue 1877 raise plumbing.convert_error_to_porcelain(e) from e 1878 break 1879 1880 resp = models.ApprovalWorkflowStepCreateResponse() 1881 resp.approval_workflow_step = plumbing.convert_approval_workflow_step_to_porcelain( 1882 plumbing_response.approval_workflow_step) 1883 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1884 plumbing_response.rate_limit) 1885 return resp
Deprecated: Create creates a new approval workflow step.
def
get(self, id, timeout=None)
1887 def get(self, id, timeout=None): 1888 ''' 1889 Deprecated: Get reads one approval workflow step by ID. 1890 ''' 1891 deadline = None if timeout is None else time.time() + timeout 1892 req = ApprovalWorkflowStepGetRequest() 1893 if self.parent.snapshot_datetime is not None: 1894 req.meta.CopyFrom(GetRequestMetadata()) 1895 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1896 1897 req.id = (id) 1898 tries = 0 1899 plumbing_response = None 1900 while True: 1901 t = None if deadline is None else deadline - time.time() 1902 try: 1903 plumbing_response = self.stub.Get( 1904 req, 1905 metadata=self.parent.get_metadata( 1906 'ApprovalWorkflowSteps.Get', req), 1907 timeout=t) 1908 except Exception as e: 1909 if self.parent.shouldRetry(tries, e, deadline): 1910 tries += 1 1911 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1912 continue 1913 raise plumbing.convert_error_to_porcelain(e) from e 1914 break 1915 1916 resp = models.ApprovalWorkflowStepGetResponse() 1917 resp.approval_workflow_step = plumbing.convert_approval_workflow_step_to_porcelain( 1918 plumbing_response.approval_workflow_step) 1919 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1920 plumbing_response.meta) 1921 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1922 plumbing_response.rate_limit) 1923 return resp
Deprecated: Get reads one approval workflow step by ID.
def
delete(self, id, timeout=None)
1925 def delete(self, id, timeout=None): 1926 ''' 1927 Deprecated: Delete deletes an existing approval workflow step. 1928 ''' 1929 deadline = None if timeout is None else time.time() + timeout 1930 req = ApprovalWorkflowStepDeleteRequest() 1931 1932 req.id = (id) 1933 tries = 0 1934 plumbing_response = None 1935 while True: 1936 t = None if deadline is None else deadline - time.time() 1937 try: 1938 plumbing_response = self.stub.Delete( 1939 req, 1940 metadata=self.parent.get_metadata( 1941 'ApprovalWorkflowSteps.Delete', req), 1942 timeout=t) 1943 except Exception as e: 1944 if self.parent.shouldRetry(tries, e, deadline): 1945 tries += 1 1946 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1947 continue 1948 raise plumbing.convert_error_to_porcelain(e) from e 1949 break 1950 1951 resp = models.ApprovalWorkflowStepDeleteResponse() 1952 resp.id = (plumbing_response.id) 1953 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1954 plumbing_response.rate_limit) 1955 return resp
Deprecated: Delete deletes an existing approval workflow step.
def
list(self, filter, *args, timeout=None)
1957 def list(self, filter, *args, timeout=None): 1958 ''' 1959 Deprecated: Lists existing approval workflow steps. 1960 ''' 1961 deadline = None if timeout is None else time.time() + timeout 1962 req = ApprovalWorkflowStepListRequest() 1963 req.meta.CopyFrom(ListRequestMetadata()) 1964 if self.parent.page_limit > 0: 1965 req.meta.limit = self.parent.page_limit 1966 if self.parent.snapshot_datetime is not None: 1967 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1968 1969 req.filter = plumbing.quote_filter_args(filter, *args) 1970 1971 def generator(svc, req): 1972 tries = 0 1973 while True: 1974 t = None if deadline is None else deadline - time.time() 1975 try: 1976 plumbing_response = svc.stub.List( 1977 req, 1978 metadata=svc.parent.get_metadata( 1979 'ApprovalWorkflowSteps.List', req), 1980 timeout=t) 1981 except Exception as e: 1982 if self.parent.shouldRetry(tries, e, deadline): 1983 tries += 1 1984 time.sleep( 1985 self.parent.exponentialBackoff(tries, deadline)) 1986 continue 1987 raise plumbing.convert_error_to_porcelain(e) from e 1988 tries = 0 1989 for plumbing_item in plumbing_response.approval_workflow_steps: 1990 yield plumbing.convert_approval_workflow_step_to_porcelain( 1991 plumbing_item) 1992 if plumbing_response.meta.next_cursor == '': 1993 break 1994 req.meta.cursor = plumbing_response.meta.next_cursor 1995 1996 return generator(self, req)
Deprecated: Lists existing approval workflow steps.
class
SnapshotApprovalWorkflowSteps:
1999class SnapshotApprovalWorkflowSteps: 2000 ''' 2001 SnapshotApprovalWorkflowSteps exposes the read only methods of the ApprovalWorkflowSteps 2002 service for historical queries. 2003 ''' 2004 def __init__(self, approval_workflow_steps): 2005 self.approval_workflow_steps = approval_workflow_steps 2006 2007 def get(self, id, timeout=None): 2008 ''' 2009 Deprecated: Get reads one approval workflow step by ID. 2010 ''' 2011 return self.approval_workflow_steps.get(id, timeout=timeout) 2012 2013 def list(self, filter, *args, timeout=None): 2014 ''' 2015 Deprecated: Lists existing approval workflow steps. 2016 ''' 2017 return self.approval_workflow_steps.list(filter, 2018 *args, 2019 timeout=timeout)
SnapshotApprovalWorkflowSteps exposes the read only methods of the ApprovalWorkflowSteps service for historical queries.
def
get(self, id, timeout=None)
2007 def get(self, id, timeout=None): 2008 ''' 2009 Deprecated: Get reads one approval workflow step by ID. 2010 ''' 2011 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)
2013 def list(self, filter, *args, timeout=None): 2014 ''' 2015 Deprecated: Lists existing approval workflow steps. 2016 ''' 2017 return self.approval_workflow_steps.list(filter, 2018 *args, 2019 timeout=timeout)
Deprecated: Lists existing approval workflow steps.
class
ApprovalWorkflowStepsHistory:
2022class ApprovalWorkflowStepsHistory: 2023 ''' 2024 ApprovalWorkflowStepsHistory records all changes to the state of an ApprovalWorkflowStep. 2025 See `strongdm.models.ApprovalWorkflowStepHistory`. 2026 ''' 2027 def __init__(self, channel, client): 2028 self.parent = client 2029 self.stub = ApprovalWorkflowStepsHistoryStub(channel) 2030 2031 def list(self, filter, *args, timeout=None): 2032 ''' 2033 List gets a list of ApprovalWorkflowStepHistory records matching a given set of criteria. 2034 ''' 2035 deadline = None if timeout is None else time.time() + timeout 2036 req = ApprovalWorkflowStepHistoryListRequest() 2037 req.meta.CopyFrom(ListRequestMetadata()) 2038 if self.parent.page_limit > 0: 2039 req.meta.limit = self.parent.page_limit 2040 if self.parent.snapshot_datetime is not None: 2041 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2042 2043 req.filter = plumbing.quote_filter_args(filter, *args) 2044 2045 def generator(svc, req): 2046 tries = 0 2047 while True: 2048 t = None if deadline is None else deadline - time.time() 2049 try: 2050 plumbing_response = svc.stub.List( 2051 req, 2052 metadata=svc.parent.get_metadata( 2053 'ApprovalWorkflowStepsHistory.List', req), 2054 timeout=t) 2055 except Exception as e: 2056 if self.parent.shouldRetry(tries, e, deadline): 2057 tries += 1 2058 time.sleep( 2059 self.parent.exponentialBackoff(tries, deadline)) 2060 continue 2061 raise plumbing.convert_error_to_porcelain(e) from e 2062 tries = 0 2063 for plumbing_item in plumbing_response.history: 2064 yield plumbing.convert_approval_workflow_step_history_to_porcelain( 2065 plumbing_item) 2066 if plumbing_response.meta.next_cursor == '': 2067 break 2068 req.meta.cursor = plumbing_response.meta.next_cursor 2069 2070 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)
2031 def list(self, filter, *args, timeout=None): 2032 ''' 2033 List gets a list of ApprovalWorkflowStepHistory records matching a given set of criteria. 2034 ''' 2035 deadline = None if timeout is None else time.time() + timeout 2036 req = ApprovalWorkflowStepHistoryListRequest() 2037 req.meta.CopyFrom(ListRequestMetadata()) 2038 if self.parent.page_limit > 0: 2039 req.meta.limit = self.parent.page_limit 2040 if self.parent.snapshot_datetime is not None: 2041 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2042 2043 req.filter = plumbing.quote_filter_args(filter, *args) 2044 2045 def generator(svc, req): 2046 tries = 0 2047 while True: 2048 t = None if deadline is None else deadline - time.time() 2049 try: 2050 plumbing_response = svc.stub.List( 2051 req, 2052 metadata=svc.parent.get_metadata( 2053 'ApprovalWorkflowStepsHistory.List', req), 2054 timeout=t) 2055 except Exception as e: 2056 if self.parent.shouldRetry(tries, e, deadline): 2057 tries += 1 2058 time.sleep( 2059 self.parent.exponentialBackoff(tries, deadline)) 2060 continue 2061 raise plumbing.convert_error_to_porcelain(e) from e 2062 tries = 0 2063 for plumbing_item in plumbing_response.history: 2064 yield plumbing.convert_approval_workflow_step_history_to_porcelain( 2065 plumbing_item) 2066 if plumbing_response.meta.next_cursor == '': 2067 break 2068 req.meta.cursor = plumbing_response.meta.next_cursor 2069 2070 return generator(self, req)
List gets a list of ApprovalWorkflowStepHistory records matching a given set of criteria.
class
ApprovalWorkflows:
2073class ApprovalWorkflows: 2074 ''' 2075 ApprovalWorkflows are the mechanism by which requests for access can be viewed by authorized 2076 approvers and be approved or denied. 2077 See `strongdm.models.ApprovalWorkflow`. 2078 ''' 2079 def __init__(self, channel, client): 2080 self.parent = client 2081 self.stub = ApprovalWorkflowsStub(channel) 2082 2083 def create(self, approval_workflow, timeout=None): 2084 ''' 2085 Create creates a new approval workflow and requires a name and approval mode for the approval workflow. 2086 ''' 2087 deadline = None if timeout is None else time.time() + timeout 2088 req = ApprovalWorkflowCreateRequest() 2089 2090 if approval_workflow is not None: 2091 req.approval_workflow.CopyFrom( 2092 plumbing.convert_approval_workflow_to_plumbing( 2093 approval_workflow)) 2094 tries = 0 2095 plumbing_response = None 2096 while True: 2097 t = None if deadline is None else deadline - time.time() 2098 try: 2099 plumbing_response = self.stub.Create( 2100 req, 2101 metadata=self.parent.get_metadata( 2102 'ApprovalWorkflows.Create', req), 2103 timeout=t) 2104 except Exception as e: 2105 if self.parent.shouldRetry(tries, e, deadline): 2106 tries += 1 2107 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2108 continue 2109 raise plumbing.convert_error_to_porcelain(e) from e 2110 break 2111 2112 resp = models.ApprovalWorkflowCreateResponse() 2113 resp.approval_workflow = plumbing.convert_approval_workflow_to_porcelain( 2114 plumbing_response.approval_workflow) 2115 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2116 plumbing_response.rate_limit) 2117 return resp 2118 2119 def get(self, id, timeout=None): 2120 ''' 2121 Get reads one approval workflow by ID. 2122 ''' 2123 deadline = None if timeout is None else time.time() + timeout 2124 req = ApprovalWorkflowGetRequest() 2125 if self.parent.snapshot_datetime is not None: 2126 req.meta.CopyFrom(GetRequestMetadata()) 2127 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2128 2129 req.id = (id) 2130 tries = 0 2131 plumbing_response = None 2132 while True: 2133 t = None if deadline is None else deadline - time.time() 2134 try: 2135 plumbing_response = self.stub.Get( 2136 req, 2137 metadata=self.parent.get_metadata('ApprovalWorkflows.Get', 2138 req), 2139 timeout=t) 2140 except Exception as e: 2141 if self.parent.shouldRetry(tries, e, deadline): 2142 tries += 1 2143 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2144 continue 2145 raise plumbing.convert_error_to_porcelain(e) from e 2146 break 2147 2148 resp = models.ApprovalWorkflowGetResponse() 2149 resp.approval_workflow = plumbing.convert_approval_workflow_to_porcelain( 2150 plumbing_response.approval_workflow) 2151 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2152 plumbing_response.meta) 2153 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2154 plumbing_response.rate_limit) 2155 return resp 2156 2157 def delete(self, id, timeout=None): 2158 ''' 2159 Delete deletes an existing approval workflow. 2160 ''' 2161 deadline = None if timeout is None else time.time() + timeout 2162 req = ApprovalWorkflowDeleteRequest() 2163 2164 req.id = (id) 2165 tries = 0 2166 plumbing_response = None 2167 while True: 2168 t = None if deadline is None else deadline - time.time() 2169 try: 2170 plumbing_response = self.stub.Delete( 2171 req, 2172 metadata=self.parent.get_metadata( 2173 'ApprovalWorkflows.Delete', req), 2174 timeout=t) 2175 except Exception as e: 2176 if self.parent.shouldRetry(tries, e, deadline): 2177 tries += 1 2178 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2179 continue 2180 raise plumbing.convert_error_to_porcelain(e) from e 2181 break 2182 2183 resp = models.ApprovalWorkflowDeleteResponse() 2184 resp.id = (plumbing_response.id) 2185 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2186 plumbing_response.rate_limit) 2187 return resp 2188 2189 def update(self, approval_workflow, timeout=None): 2190 ''' 2191 Update updates an existing approval workflow. 2192 ''' 2193 deadline = None if timeout is None else time.time() + timeout 2194 req = ApprovalWorkflowUpdateRequest() 2195 2196 if approval_workflow is not None: 2197 req.approval_workflow.CopyFrom( 2198 plumbing.convert_approval_workflow_to_plumbing( 2199 approval_workflow)) 2200 tries = 0 2201 plumbing_response = None 2202 while True: 2203 t = None if deadline is None else deadline - time.time() 2204 try: 2205 plumbing_response = self.stub.Update( 2206 req, 2207 metadata=self.parent.get_metadata( 2208 'ApprovalWorkflows.Update', req), 2209 timeout=t) 2210 except Exception as e: 2211 if self.parent.shouldRetry(tries, e, deadline): 2212 tries += 1 2213 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2214 continue 2215 raise plumbing.convert_error_to_porcelain(e) from e 2216 break 2217 2218 resp = models.ApprovalWorkflowUpdateResponse() 2219 resp.approval_workflow = plumbing.convert_approval_workflow_to_porcelain( 2220 plumbing_response.approval_workflow) 2221 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2222 plumbing_response.rate_limit) 2223 return resp 2224 2225 def list(self, filter, *args, timeout=None): 2226 ''' 2227 Lists existing approval workflows. 2228 ''' 2229 deadline = None if timeout is None else time.time() + timeout 2230 req = ApprovalWorkflowListRequest() 2231 req.meta.CopyFrom(ListRequestMetadata()) 2232 if self.parent.page_limit > 0: 2233 req.meta.limit = self.parent.page_limit 2234 if self.parent.snapshot_datetime is not None: 2235 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2236 2237 req.filter = plumbing.quote_filter_args(filter, *args) 2238 2239 def generator(svc, req): 2240 tries = 0 2241 while True: 2242 t = None if deadline is None else deadline - time.time() 2243 try: 2244 plumbing_response = svc.stub.List( 2245 req, 2246 metadata=svc.parent.get_metadata( 2247 'ApprovalWorkflows.List', req), 2248 timeout=t) 2249 except Exception as e: 2250 if self.parent.shouldRetry(tries, e, deadline): 2251 tries += 1 2252 time.sleep( 2253 self.parent.exponentialBackoff(tries, deadline)) 2254 continue 2255 raise plumbing.convert_error_to_porcelain(e) from e 2256 tries = 0 2257 for plumbing_item in plumbing_response.approval_workflows: 2258 yield plumbing.convert_approval_workflow_to_porcelain( 2259 plumbing_item) 2260 if plumbing_response.meta.next_cursor == '': 2261 break 2262 req.meta.cursor = plumbing_response.meta.next_cursor 2263 2264 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)
2083 def create(self, approval_workflow, timeout=None): 2084 ''' 2085 Create creates a new approval workflow and requires a name and approval mode for the approval workflow. 2086 ''' 2087 deadline = None if timeout is None else time.time() + timeout 2088 req = ApprovalWorkflowCreateRequest() 2089 2090 if approval_workflow is not None: 2091 req.approval_workflow.CopyFrom( 2092 plumbing.convert_approval_workflow_to_plumbing( 2093 approval_workflow)) 2094 tries = 0 2095 plumbing_response = None 2096 while True: 2097 t = None if deadline is None else deadline - time.time() 2098 try: 2099 plumbing_response = self.stub.Create( 2100 req, 2101 metadata=self.parent.get_metadata( 2102 'ApprovalWorkflows.Create', req), 2103 timeout=t) 2104 except Exception as e: 2105 if self.parent.shouldRetry(tries, e, deadline): 2106 tries += 1 2107 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2108 continue 2109 raise plumbing.convert_error_to_porcelain(e) from e 2110 break 2111 2112 resp = models.ApprovalWorkflowCreateResponse() 2113 resp.approval_workflow = plumbing.convert_approval_workflow_to_porcelain( 2114 plumbing_response.approval_workflow) 2115 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2116 plumbing_response.rate_limit) 2117 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)
2119 def get(self, id, timeout=None): 2120 ''' 2121 Get reads one approval workflow by ID. 2122 ''' 2123 deadline = None if timeout is None else time.time() + timeout 2124 req = ApprovalWorkflowGetRequest() 2125 if self.parent.snapshot_datetime is not None: 2126 req.meta.CopyFrom(GetRequestMetadata()) 2127 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2128 2129 req.id = (id) 2130 tries = 0 2131 plumbing_response = None 2132 while True: 2133 t = None if deadline is None else deadline - time.time() 2134 try: 2135 plumbing_response = self.stub.Get( 2136 req, 2137 metadata=self.parent.get_metadata('ApprovalWorkflows.Get', 2138 req), 2139 timeout=t) 2140 except Exception as e: 2141 if self.parent.shouldRetry(tries, e, deadline): 2142 tries += 1 2143 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2144 continue 2145 raise plumbing.convert_error_to_porcelain(e) from e 2146 break 2147 2148 resp = models.ApprovalWorkflowGetResponse() 2149 resp.approval_workflow = plumbing.convert_approval_workflow_to_porcelain( 2150 plumbing_response.approval_workflow) 2151 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2152 plumbing_response.meta) 2153 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2154 plumbing_response.rate_limit) 2155 return resp
Get reads one approval workflow by ID.
def
delete(self, id, timeout=None)
2157 def delete(self, id, timeout=None): 2158 ''' 2159 Delete deletes an existing approval workflow. 2160 ''' 2161 deadline = None if timeout is None else time.time() + timeout 2162 req = ApprovalWorkflowDeleteRequest() 2163 2164 req.id = (id) 2165 tries = 0 2166 plumbing_response = None 2167 while True: 2168 t = None if deadline is None else deadline - time.time() 2169 try: 2170 plumbing_response = self.stub.Delete( 2171 req, 2172 metadata=self.parent.get_metadata( 2173 'ApprovalWorkflows.Delete', req), 2174 timeout=t) 2175 except Exception as e: 2176 if self.parent.shouldRetry(tries, e, deadline): 2177 tries += 1 2178 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2179 continue 2180 raise plumbing.convert_error_to_porcelain(e) from e 2181 break 2182 2183 resp = models.ApprovalWorkflowDeleteResponse() 2184 resp.id = (plumbing_response.id) 2185 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2186 plumbing_response.rate_limit) 2187 return resp
Delete deletes an existing approval workflow.
def
update(self, approval_workflow, timeout=None)
2189 def update(self, approval_workflow, timeout=None): 2190 ''' 2191 Update updates an existing approval workflow. 2192 ''' 2193 deadline = None if timeout is None else time.time() + timeout 2194 req = ApprovalWorkflowUpdateRequest() 2195 2196 if approval_workflow is not None: 2197 req.approval_workflow.CopyFrom( 2198 plumbing.convert_approval_workflow_to_plumbing( 2199 approval_workflow)) 2200 tries = 0 2201 plumbing_response = None 2202 while True: 2203 t = None if deadline is None else deadline - time.time() 2204 try: 2205 plumbing_response = self.stub.Update( 2206 req, 2207 metadata=self.parent.get_metadata( 2208 'ApprovalWorkflows.Update', req), 2209 timeout=t) 2210 except Exception as e: 2211 if self.parent.shouldRetry(tries, e, deadline): 2212 tries += 1 2213 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2214 continue 2215 raise plumbing.convert_error_to_porcelain(e) from e 2216 break 2217 2218 resp = models.ApprovalWorkflowUpdateResponse() 2219 resp.approval_workflow = plumbing.convert_approval_workflow_to_porcelain( 2220 plumbing_response.approval_workflow) 2221 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2222 plumbing_response.rate_limit) 2223 return resp
Update updates an existing approval workflow.
def
list(self, filter, *args, timeout=None)
2225 def list(self, filter, *args, timeout=None): 2226 ''' 2227 Lists existing approval workflows. 2228 ''' 2229 deadline = None if timeout is None else time.time() + timeout 2230 req = ApprovalWorkflowListRequest() 2231 req.meta.CopyFrom(ListRequestMetadata()) 2232 if self.parent.page_limit > 0: 2233 req.meta.limit = self.parent.page_limit 2234 if self.parent.snapshot_datetime is not None: 2235 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2236 2237 req.filter = plumbing.quote_filter_args(filter, *args) 2238 2239 def generator(svc, req): 2240 tries = 0 2241 while True: 2242 t = None if deadline is None else deadline - time.time() 2243 try: 2244 plumbing_response = svc.stub.List( 2245 req, 2246 metadata=svc.parent.get_metadata( 2247 'ApprovalWorkflows.List', req), 2248 timeout=t) 2249 except Exception as e: 2250 if self.parent.shouldRetry(tries, e, deadline): 2251 tries += 1 2252 time.sleep( 2253 self.parent.exponentialBackoff(tries, deadline)) 2254 continue 2255 raise plumbing.convert_error_to_porcelain(e) from e 2256 tries = 0 2257 for plumbing_item in plumbing_response.approval_workflows: 2258 yield plumbing.convert_approval_workflow_to_porcelain( 2259 plumbing_item) 2260 if plumbing_response.meta.next_cursor == '': 2261 break 2262 req.meta.cursor = plumbing_response.meta.next_cursor 2263 2264 return generator(self, req)
Lists existing approval workflows.
class
SnapshotApprovalWorkflows:
2267class SnapshotApprovalWorkflows: 2268 ''' 2269 SnapshotApprovalWorkflows exposes the read only methods of the ApprovalWorkflows 2270 service for historical queries. 2271 ''' 2272 def __init__(self, approval_workflows): 2273 self.approval_workflows = approval_workflows 2274 2275 def get(self, id, timeout=None): 2276 ''' 2277 Get reads one approval workflow by ID. 2278 ''' 2279 return self.approval_workflows.get(id, timeout=timeout) 2280 2281 def list(self, filter, *args, timeout=None): 2282 ''' 2283 Lists existing approval workflows. 2284 ''' 2285 return self.approval_workflows.list(filter, *args, timeout=timeout)
SnapshotApprovalWorkflows exposes the read only methods of the ApprovalWorkflows service for historical queries.
class
ApprovalWorkflowsHistory:
2288class ApprovalWorkflowsHistory: 2289 ''' 2290 ApprovalWorkflowsHistory records all changes to the state of an ApprovalWorkflow. 2291 See `strongdm.models.ApprovalWorkflowHistory`. 2292 ''' 2293 def __init__(self, channel, client): 2294 self.parent = client 2295 self.stub = ApprovalWorkflowsHistoryStub(channel) 2296 2297 def list(self, filter, *args, timeout=None): 2298 ''' 2299 List gets a list of ApprovalWorkflowHistory records matching a given set of criteria. 2300 ''' 2301 deadline = None if timeout is None else time.time() + timeout 2302 req = ApprovalWorkflowHistoryListRequest() 2303 req.meta.CopyFrom(ListRequestMetadata()) 2304 if self.parent.page_limit > 0: 2305 req.meta.limit = self.parent.page_limit 2306 if self.parent.snapshot_datetime is not None: 2307 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2308 2309 req.filter = plumbing.quote_filter_args(filter, *args) 2310 2311 def generator(svc, req): 2312 tries = 0 2313 while True: 2314 t = None if deadline is None else deadline - time.time() 2315 try: 2316 plumbing_response = svc.stub.List( 2317 req, 2318 metadata=svc.parent.get_metadata( 2319 'ApprovalWorkflowsHistory.List', req), 2320 timeout=t) 2321 except Exception as e: 2322 if self.parent.shouldRetry(tries, e, deadline): 2323 tries += 1 2324 time.sleep( 2325 self.parent.exponentialBackoff(tries, deadline)) 2326 continue 2327 raise plumbing.convert_error_to_porcelain(e) from e 2328 tries = 0 2329 for plumbing_item in plumbing_response.history: 2330 yield plumbing.convert_approval_workflow_history_to_porcelain( 2331 plumbing_item) 2332 if plumbing_response.meta.next_cursor == '': 2333 break 2334 req.meta.cursor = plumbing_response.meta.next_cursor 2335 2336 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)
2297 def list(self, filter, *args, timeout=None): 2298 ''' 2299 List gets a list of ApprovalWorkflowHistory records matching a given set of criteria. 2300 ''' 2301 deadline = None if timeout is None else time.time() + timeout 2302 req = ApprovalWorkflowHistoryListRequest() 2303 req.meta.CopyFrom(ListRequestMetadata()) 2304 if self.parent.page_limit > 0: 2305 req.meta.limit = self.parent.page_limit 2306 if self.parent.snapshot_datetime is not None: 2307 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2308 2309 req.filter = plumbing.quote_filter_args(filter, *args) 2310 2311 def generator(svc, req): 2312 tries = 0 2313 while True: 2314 t = None if deadline is None else deadline - time.time() 2315 try: 2316 plumbing_response = svc.stub.List( 2317 req, 2318 metadata=svc.parent.get_metadata( 2319 'ApprovalWorkflowsHistory.List', req), 2320 timeout=t) 2321 except Exception as e: 2322 if self.parent.shouldRetry(tries, e, deadline): 2323 tries += 1 2324 time.sleep( 2325 self.parent.exponentialBackoff(tries, deadline)) 2326 continue 2327 raise plumbing.convert_error_to_porcelain(e) from e 2328 tries = 0 2329 for plumbing_item in plumbing_response.history: 2330 yield plumbing.convert_approval_workflow_history_to_porcelain( 2331 plumbing_item) 2332 if plumbing_response.meta.next_cursor == '': 2333 break 2334 req.meta.cursor = plumbing_response.meta.next_cursor 2335 2336 return generator(self, req)
List gets a list of ApprovalWorkflowHistory records matching a given set of criteria.
class
ControlPanel:
2339class ControlPanel: 2340 ''' 2341 ControlPanel contains all administrative controls. 2342 ''' 2343 def __init__(self, channel, client): 2344 self.parent = client 2345 self.stub = ControlPanelStub(channel) 2346 2347 def get_sshca_public_key(self, timeout=None): 2348 ''' 2349 GetSSHCAPublicKey retrieves the SSH CA public key. 2350 ''' 2351 deadline = None if timeout is None else time.time() + timeout 2352 req = ControlPanelGetSSHCAPublicKeyRequest() 2353 2354 tries = 0 2355 plumbing_response = None 2356 while True: 2357 t = None if deadline is None else deadline - time.time() 2358 try: 2359 plumbing_response = self.stub.GetSSHCAPublicKey( 2360 req, 2361 metadata=self.parent.get_metadata( 2362 'ControlPanel.GetSSHCAPublicKey', req), 2363 timeout=t) 2364 except Exception as e: 2365 if self.parent.shouldRetry(tries, e, deadline): 2366 tries += 1 2367 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2368 continue 2369 raise plumbing.convert_error_to_porcelain(e) from e 2370 break 2371 2372 resp = models.ControlPanelGetSSHCAPublicKeyResponse() 2373 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2374 plumbing_response.meta) 2375 resp.public_key = (plumbing_response.public_key) 2376 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2377 plumbing_response.rate_limit) 2378 return resp 2379 2380 def get_rdpca_public_key(self, timeout=None): 2381 ''' 2382 GetRDPCAPublicKey retrieves the RDP CA public key. 2383 ''' 2384 deadline = None if timeout is None else time.time() + timeout 2385 req = ControlPanelGetRDPCAPublicKeyRequest() 2386 2387 tries = 0 2388 plumbing_response = None 2389 while True: 2390 t = None if deadline is None else deadline - time.time() 2391 try: 2392 plumbing_response = self.stub.GetRDPCAPublicKey( 2393 req, 2394 metadata=self.parent.get_metadata( 2395 'ControlPanel.GetRDPCAPublicKey', req), 2396 timeout=t) 2397 except Exception as e: 2398 if self.parent.shouldRetry(tries, e, deadline): 2399 tries += 1 2400 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2401 continue 2402 raise plumbing.convert_error_to_porcelain(e) from e 2403 break 2404 2405 resp = models.ControlPanelGetRDPCAPublicKeyResponse() 2406 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2407 plumbing_response.meta) 2408 resp.public_key = (plumbing_response.public_key) 2409 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2410 plumbing_response.rate_limit) 2411 return resp 2412 2413 def get_org_url_info(self, timeout=None): 2414 ''' 2415 GetOrgURLInfo retrieves URL configuration for the organization. 2416 This includes the base URL, website subdomain, OIDC issuer URL, and SAML metadata URL. 2417 ''' 2418 deadline = None if timeout is None else time.time() + timeout 2419 req = ControlPanelGetOrgURLInfoRequest() 2420 2421 tries = 0 2422 plumbing_response = None 2423 while True: 2424 t = None if deadline is None else deadline - time.time() 2425 try: 2426 plumbing_response = self.stub.GetOrgURLInfo( 2427 req, 2428 metadata=self.parent.get_metadata( 2429 'ControlPanel.GetOrgURLInfo', req), 2430 timeout=t) 2431 except Exception as e: 2432 if self.parent.shouldRetry(tries, e, deadline): 2433 tries += 1 2434 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2435 continue 2436 raise plumbing.convert_error_to_porcelain(e) from e 2437 break 2438 2439 resp = models.ControlPanelGetOrgURLInfoResponse() 2440 resp.base_url = (plumbing_response.base_url) 2441 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2442 plumbing_response.meta) 2443 resp.oidc_issuer_url = (plumbing_response.oidc_issuer_url) 2444 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2445 plumbing_response.rate_limit) 2446 resp.saml_metadata_url = (plumbing_response.saml_metadata_url) 2447 resp.websites_subdomain = (plumbing_response.websites_subdomain) 2448 return resp 2449 2450 def verify_jwt(self, token, timeout=None): 2451 ''' 2452 VerifyJWT reports whether the given JWT token (x-sdm-token) is valid. 2453 ''' 2454 deadline = None if timeout is None else time.time() + timeout 2455 req = ControlPanelVerifyJWTRequest() 2456 2457 req.token = (token) 2458 tries = 0 2459 plumbing_response = None 2460 while True: 2461 t = None if deadline is None else deadline - time.time() 2462 try: 2463 plumbing_response = self.stub.VerifyJWT( 2464 req, 2465 metadata=self.parent.get_metadata('ControlPanel.VerifyJWT', 2466 req), 2467 timeout=t) 2468 except Exception as e: 2469 if self.parent.shouldRetry(tries, e, deadline): 2470 tries += 1 2471 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2472 continue 2473 raise plumbing.convert_error_to_porcelain(e) from e 2474 break 2475 2476 resp = models.ControlPanelVerifyJWTResponse() 2477 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2478 plumbing_response.meta) 2479 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2480 plumbing_response.rate_limit) 2481 resp.valid = (plumbing_response.valid) 2482 return resp
ControlPanel contains all administrative controls.
def
get_sshca_public_key(self, timeout=None)
2347 def get_sshca_public_key(self, timeout=None): 2348 ''' 2349 GetSSHCAPublicKey retrieves the SSH CA public key. 2350 ''' 2351 deadline = None if timeout is None else time.time() + timeout 2352 req = ControlPanelGetSSHCAPublicKeyRequest() 2353 2354 tries = 0 2355 plumbing_response = None 2356 while True: 2357 t = None if deadline is None else deadline - time.time() 2358 try: 2359 plumbing_response = self.stub.GetSSHCAPublicKey( 2360 req, 2361 metadata=self.parent.get_metadata( 2362 'ControlPanel.GetSSHCAPublicKey', req), 2363 timeout=t) 2364 except Exception as e: 2365 if self.parent.shouldRetry(tries, e, deadline): 2366 tries += 1 2367 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2368 continue 2369 raise plumbing.convert_error_to_porcelain(e) from e 2370 break 2371 2372 resp = models.ControlPanelGetSSHCAPublicKeyResponse() 2373 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2374 plumbing_response.meta) 2375 resp.public_key = (plumbing_response.public_key) 2376 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2377 plumbing_response.rate_limit) 2378 return resp
GetSSHCAPublicKey retrieves the SSH CA public key.
def
get_rdpca_public_key(self, timeout=None)
2380 def get_rdpca_public_key(self, timeout=None): 2381 ''' 2382 GetRDPCAPublicKey retrieves the RDP CA public key. 2383 ''' 2384 deadline = None if timeout is None else time.time() + timeout 2385 req = ControlPanelGetRDPCAPublicKeyRequest() 2386 2387 tries = 0 2388 plumbing_response = None 2389 while True: 2390 t = None if deadline is None else deadline - time.time() 2391 try: 2392 plumbing_response = self.stub.GetRDPCAPublicKey( 2393 req, 2394 metadata=self.parent.get_metadata( 2395 'ControlPanel.GetRDPCAPublicKey', req), 2396 timeout=t) 2397 except Exception as e: 2398 if self.parent.shouldRetry(tries, e, deadline): 2399 tries += 1 2400 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2401 continue 2402 raise plumbing.convert_error_to_porcelain(e) from e 2403 break 2404 2405 resp = models.ControlPanelGetRDPCAPublicKeyResponse() 2406 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2407 plumbing_response.meta) 2408 resp.public_key = (plumbing_response.public_key) 2409 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2410 plumbing_response.rate_limit) 2411 return resp
GetRDPCAPublicKey retrieves the RDP CA public key.
def
get_org_url_info(self, timeout=None)
2413 def get_org_url_info(self, timeout=None): 2414 ''' 2415 GetOrgURLInfo retrieves URL configuration for the organization. 2416 This includes the base URL, website subdomain, OIDC issuer URL, and SAML metadata URL. 2417 ''' 2418 deadline = None if timeout is None else time.time() + timeout 2419 req = ControlPanelGetOrgURLInfoRequest() 2420 2421 tries = 0 2422 plumbing_response = None 2423 while True: 2424 t = None if deadline is None else deadline - time.time() 2425 try: 2426 plumbing_response = self.stub.GetOrgURLInfo( 2427 req, 2428 metadata=self.parent.get_metadata( 2429 'ControlPanel.GetOrgURLInfo', req), 2430 timeout=t) 2431 except Exception as e: 2432 if self.parent.shouldRetry(tries, e, deadline): 2433 tries += 1 2434 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2435 continue 2436 raise plumbing.convert_error_to_porcelain(e) from e 2437 break 2438 2439 resp = models.ControlPanelGetOrgURLInfoResponse() 2440 resp.base_url = (plumbing_response.base_url) 2441 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2442 plumbing_response.meta) 2443 resp.oidc_issuer_url = (plumbing_response.oidc_issuer_url) 2444 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2445 plumbing_response.rate_limit) 2446 resp.saml_metadata_url = (plumbing_response.saml_metadata_url) 2447 resp.websites_subdomain = (plumbing_response.websites_subdomain) 2448 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)
2450 def verify_jwt(self, token, timeout=None): 2451 ''' 2452 VerifyJWT reports whether the given JWT token (x-sdm-token) is valid. 2453 ''' 2454 deadline = None if timeout is None else time.time() + timeout 2455 req = ControlPanelVerifyJWTRequest() 2456 2457 req.token = (token) 2458 tries = 0 2459 plumbing_response = None 2460 while True: 2461 t = None if deadline is None else deadline - time.time() 2462 try: 2463 plumbing_response = self.stub.VerifyJWT( 2464 req, 2465 metadata=self.parent.get_metadata('ControlPanel.VerifyJWT', 2466 req), 2467 timeout=t) 2468 except Exception as e: 2469 if self.parent.shouldRetry(tries, e, deadline): 2470 tries += 1 2471 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2472 continue 2473 raise plumbing.convert_error_to_porcelain(e) from e 2474 break 2475 2476 resp = models.ControlPanelVerifyJWTResponse() 2477 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2478 plumbing_response.meta) 2479 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2480 plumbing_response.rate_limit) 2481 resp.valid = (plumbing_response.valid) 2482 return resp
VerifyJWT reports whether the given JWT token (x-sdm-token) is valid.
class
DiscoveryConnectors:
2485class DiscoveryConnectors: 2486 ''' 2487 A Discovery Connector is a configuration object for performing Resource 2488 Scans in remote systems such as AWS, GCP, Azure, and other systems. 2489 See: 2490 `strongdm.models.AWSConnector` 2491 `strongdm.models.AzureConnector` 2492 `strongdm.models.GCPConnector` 2493 ''' 2494 def __init__(self, channel, client): 2495 self.parent = client 2496 self.stub = DiscoveryConnectorsStub(channel) 2497 2498 def create(self, connector, timeout=None): 2499 ''' 2500 Create adds a new Connector. 2501 ''' 2502 deadline = None if timeout is None else time.time() + timeout 2503 req = ConnectorCreateRequest() 2504 2505 if connector is not None: 2506 req.connector.CopyFrom( 2507 plumbing.convert_connector_to_plumbing(connector)) 2508 tries = 0 2509 plumbing_response = None 2510 while True: 2511 t = None if deadline is None else deadline - time.time() 2512 try: 2513 plumbing_response = self.stub.Create( 2514 req, 2515 metadata=self.parent.get_metadata( 2516 'DiscoveryConnectors.Create', req), 2517 timeout=t) 2518 except Exception as e: 2519 if self.parent.shouldRetry(tries, e, deadline): 2520 tries += 1 2521 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2522 continue 2523 raise plumbing.convert_error_to_porcelain(e) from e 2524 break 2525 2526 resp = models.ConnectorCreateResponse() 2527 resp.connector = plumbing.convert_connector_to_porcelain( 2528 plumbing_response.connector) 2529 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2530 plumbing_response.rate_limit) 2531 return resp 2532 2533 def get(self, id, timeout=None): 2534 ''' 2535 Get reads one Connector by ID 2536 ''' 2537 deadline = None if timeout is None else time.time() + timeout 2538 req = ConnectorGetRequest() 2539 if self.parent.snapshot_datetime is not None: 2540 req.meta.CopyFrom(GetRequestMetadata()) 2541 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2542 2543 req.id = (id) 2544 tries = 0 2545 plumbing_response = None 2546 while True: 2547 t = None if deadline is None else deadline - time.time() 2548 try: 2549 plumbing_response = self.stub.Get( 2550 req, 2551 metadata=self.parent.get_metadata( 2552 'DiscoveryConnectors.Get', req), 2553 timeout=t) 2554 except Exception as e: 2555 if self.parent.shouldRetry(tries, e, deadline): 2556 tries += 1 2557 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2558 continue 2559 raise plumbing.convert_error_to_porcelain(e) from e 2560 break 2561 2562 resp = models.ConnectorGetResponse() 2563 resp.connector = plumbing.convert_connector_to_porcelain( 2564 plumbing_response.connector) 2565 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2566 plumbing_response.meta) 2567 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2568 plumbing_response.rate_limit) 2569 return resp 2570 2571 def update(self, connector, timeout=None): 2572 ''' 2573 Update replaces all the fields of a Connector by ID. 2574 ''' 2575 deadline = None if timeout is None else time.time() + timeout 2576 req = ConnectorUpdateRequest() 2577 2578 if connector is not None: 2579 req.connector.CopyFrom( 2580 plumbing.convert_connector_to_plumbing(connector)) 2581 tries = 0 2582 plumbing_response = None 2583 while True: 2584 t = None if deadline is None else deadline - time.time() 2585 try: 2586 plumbing_response = self.stub.Update( 2587 req, 2588 metadata=self.parent.get_metadata( 2589 'DiscoveryConnectors.Update', req), 2590 timeout=t) 2591 except Exception as e: 2592 if self.parent.shouldRetry(tries, e, deadline): 2593 tries += 1 2594 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2595 continue 2596 raise plumbing.convert_error_to_porcelain(e) from e 2597 break 2598 2599 resp = models.ConnectorUpdateResponse() 2600 resp.connector = plumbing.convert_connector_to_porcelain( 2601 plumbing_response.connector) 2602 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2603 plumbing_response.rate_limit) 2604 return resp 2605 2606 def delete(self, id, timeout=None): 2607 ''' 2608 Delete removes a Connector by ID. 2609 ''' 2610 deadline = None if timeout is None else time.time() + timeout 2611 req = ConnectorDeleteRequest() 2612 2613 req.id = (id) 2614 tries = 0 2615 plumbing_response = None 2616 while True: 2617 t = None if deadline is None else deadline - time.time() 2618 try: 2619 plumbing_response = self.stub.Delete( 2620 req, 2621 metadata=self.parent.get_metadata( 2622 'DiscoveryConnectors.Delete', req), 2623 timeout=t) 2624 except Exception as e: 2625 if self.parent.shouldRetry(tries, e, deadline): 2626 tries += 1 2627 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2628 continue 2629 raise plumbing.convert_error_to_porcelain(e) from e 2630 break 2631 2632 resp = models.ConnectorDeleteResponse() 2633 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 2634 plumbing_response.meta) 2635 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2636 plumbing_response.rate_limit) 2637 return resp 2638 2639 def list(self, filter, *args, timeout=None): 2640 ''' 2641 List gets a list of Connectors matching a given set of criteria. 2642 ''' 2643 deadline = None if timeout is None else time.time() + timeout 2644 req = ConnectorListRequest() 2645 req.meta.CopyFrom(ListRequestMetadata()) 2646 if self.parent.page_limit > 0: 2647 req.meta.limit = self.parent.page_limit 2648 if self.parent.snapshot_datetime is not None: 2649 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2650 2651 req.filter = plumbing.quote_filter_args(filter, *args) 2652 2653 def generator(svc, req): 2654 tries = 0 2655 while True: 2656 t = None if deadline is None else deadline - time.time() 2657 try: 2658 plumbing_response = svc.stub.List( 2659 req, 2660 metadata=svc.parent.get_metadata( 2661 'DiscoveryConnectors.List', req), 2662 timeout=t) 2663 except Exception as e: 2664 if self.parent.shouldRetry(tries, e, deadline): 2665 tries += 1 2666 time.sleep( 2667 self.parent.exponentialBackoff(tries, deadline)) 2668 continue 2669 raise plumbing.convert_error_to_porcelain(e) from e 2670 tries = 0 2671 for plumbing_item in plumbing_response.connectors: 2672 yield plumbing.convert_connector_to_porcelain( 2673 plumbing_item) 2674 if plumbing_response.meta.next_cursor == '': 2675 break 2676 req.meta.cursor = plumbing_response.meta.next_cursor 2677 2678 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)
2498 def create(self, connector, timeout=None): 2499 ''' 2500 Create adds a new Connector. 2501 ''' 2502 deadline = None if timeout is None else time.time() + timeout 2503 req = ConnectorCreateRequest() 2504 2505 if connector is not None: 2506 req.connector.CopyFrom( 2507 plumbing.convert_connector_to_plumbing(connector)) 2508 tries = 0 2509 plumbing_response = None 2510 while True: 2511 t = None if deadline is None else deadline - time.time() 2512 try: 2513 plumbing_response = self.stub.Create( 2514 req, 2515 metadata=self.parent.get_metadata( 2516 'DiscoveryConnectors.Create', req), 2517 timeout=t) 2518 except Exception as e: 2519 if self.parent.shouldRetry(tries, e, deadline): 2520 tries += 1 2521 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2522 continue 2523 raise plumbing.convert_error_to_porcelain(e) from e 2524 break 2525 2526 resp = models.ConnectorCreateResponse() 2527 resp.connector = plumbing.convert_connector_to_porcelain( 2528 plumbing_response.connector) 2529 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2530 plumbing_response.rate_limit) 2531 return resp
Create adds a new Connector.
def
get(self, id, timeout=None)
2533 def get(self, id, timeout=None): 2534 ''' 2535 Get reads one Connector by ID 2536 ''' 2537 deadline = None if timeout is None else time.time() + timeout 2538 req = ConnectorGetRequest() 2539 if self.parent.snapshot_datetime is not None: 2540 req.meta.CopyFrom(GetRequestMetadata()) 2541 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2542 2543 req.id = (id) 2544 tries = 0 2545 plumbing_response = None 2546 while True: 2547 t = None if deadline is None else deadline - time.time() 2548 try: 2549 plumbing_response = self.stub.Get( 2550 req, 2551 metadata=self.parent.get_metadata( 2552 'DiscoveryConnectors.Get', req), 2553 timeout=t) 2554 except Exception as e: 2555 if self.parent.shouldRetry(tries, e, deadline): 2556 tries += 1 2557 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2558 continue 2559 raise plumbing.convert_error_to_porcelain(e) from e 2560 break 2561 2562 resp = models.ConnectorGetResponse() 2563 resp.connector = plumbing.convert_connector_to_porcelain( 2564 plumbing_response.connector) 2565 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2566 plumbing_response.meta) 2567 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2568 plumbing_response.rate_limit) 2569 return resp
Get reads one Connector by ID
def
update(self, connector, timeout=None)
2571 def update(self, connector, timeout=None): 2572 ''' 2573 Update replaces all the fields of a Connector by ID. 2574 ''' 2575 deadline = None if timeout is None else time.time() + timeout 2576 req = ConnectorUpdateRequest() 2577 2578 if connector is not None: 2579 req.connector.CopyFrom( 2580 plumbing.convert_connector_to_plumbing(connector)) 2581 tries = 0 2582 plumbing_response = None 2583 while True: 2584 t = None if deadline is None else deadline - time.time() 2585 try: 2586 plumbing_response = self.stub.Update( 2587 req, 2588 metadata=self.parent.get_metadata( 2589 'DiscoveryConnectors.Update', req), 2590 timeout=t) 2591 except Exception as e: 2592 if self.parent.shouldRetry(tries, e, deadline): 2593 tries += 1 2594 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2595 continue 2596 raise plumbing.convert_error_to_porcelain(e) from e 2597 break 2598 2599 resp = models.ConnectorUpdateResponse() 2600 resp.connector = plumbing.convert_connector_to_porcelain( 2601 plumbing_response.connector) 2602 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2603 plumbing_response.rate_limit) 2604 return resp
Update replaces all the fields of a Connector by ID.
def
delete(self, id, timeout=None)
2606 def delete(self, id, timeout=None): 2607 ''' 2608 Delete removes a Connector by ID. 2609 ''' 2610 deadline = None if timeout is None else time.time() + timeout 2611 req = ConnectorDeleteRequest() 2612 2613 req.id = (id) 2614 tries = 0 2615 plumbing_response = None 2616 while True: 2617 t = None if deadline is None else deadline - time.time() 2618 try: 2619 plumbing_response = self.stub.Delete( 2620 req, 2621 metadata=self.parent.get_metadata( 2622 'DiscoveryConnectors.Delete', req), 2623 timeout=t) 2624 except Exception as e: 2625 if self.parent.shouldRetry(tries, e, deadline): 2626 tries += 1 2627 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2628 continue 2629 raise plumbing.convert_error_to_porcelain(e) from e 2630 break 2631 2632 resp = models.ConnectorDeleteResponse() 2633 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 2634 plumbing_response.meta) 2635 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2636 plumbing_response.rate_limit) 2637 return resp
Delete removes a Connector by ID.
def
list(self, filter, *args, timeout=None)
2639 def list(self, filter, *args, timeout=None): 2640 ''' 2641 List gets a list of Connectors matching a given set of criteria. 2642 ''' 2643 deadline = None if timeout is None else time.time() + timeout 2644 req = ConnectorListRequest() 2645 req.meta.CopyFrom(ListRequestMetadata()) 2646 if self.parent.page_limit > 0: 2647 req.meta.limit = self.parent.page_limit 2648 if self.parent.snapshot_datetime is not None: 2649 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2650 2651 req.filter = plumbing.quote_filter_args(filter, *args) 2652 2653 def generator(svc, req): 2654 tries = 0 2655 while True: 2656 t = None if deadline is None else deadline - time.time() 2657 try: 2658 plumbing_response = svc.stub.List( 2659 req, 2660 metadata=svc.parent.get_metadata( 2661 'DiscoveryConnectors.List', req), 2662 timeout=t) 2663 except Exception as e: 2664 if self.parent.shouldRetry(tries, e, deadline): 2665 tries += 1 2666 time.sleep( 2667 self.parent.exponentialBackoff(tries, deadline)) 2668 continue 2669 raise plumbing.convert_error_to_porcelain(e) from e 2670 tries = 0 2671 for plumbing_item in plumbing_response.connectors: 2672 yield plumbing.convert_connector_to_porcelain( 2673 plumbing_item) 2674 if plumbing_response.meta.next_cursor == '': 2675 break 2676 req.meta.cursor = plumbing_response.meta.next_cursor 2677 2678 return generator(self, req)
List gets a list of Connectors matching a given set of criteria.
class
SnapshotDiscoveryConnectors:
2681class SnapshotDiscoveryConnectors: 2682 ''' 2683 SnapshotDiscoveryConnectors exposes the read only methods of the DiscoveryConnectors 2684 service for historical queries. 2685 ''' 2686 def __init__(self, discovery_connectors): 2687 self.discovery_connectors = discovery_connectors 2688 2689 def get(self, id, timeout=None): 2690 ''' 2691 Get reads one Connector by ID 2692 ''' 2693 return self.discovery_connectors.get(id, timeout=timeout) 2694 2695 def list(self, filter, *args, timeout=None): 2696 ''' 2697 List gets a list of Connectors matching a given set of criteria. 2698 ''' 2699 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)
2689 def get(self, id, timeout=None): 2690 ''' 2691 Get reads one Connector by ID 2692 ''' 2693 return self.discovery_connectors.get(id, timeout=timeout)
Get reads one Connector by ID
def
list(self, filter, *args, timeout=None)
2695 def list(self, filter, *args, timeout=None): 2696 ''' 2697 List gets a list of Connectors matching a given set of criteria. 2698 ''' 2699 return self.discovery_connectors.list(filter, *args, timeout=timeout)
List gets a list of Connectors matching a given set of criteria.
class
GrantedAccountEntitlements:
2702class GrantedAccountEntitlements: 2703 ''' 2704 GrantedAccountEntitlements enumerates the resources to which an account has been granted access. 2705 The GrantedAccountEntitlements service is read-only. 2706 See `strongdm.models.GrantedAccountEntitlement`. 2707 ''' 2708 def __init__(self, channel, client): 2709 self.parent = client 2710 self.stub = GrantedAccountEntitlementsStub(channel) 2711 2712 def list(self, account_id, filter, *args, timeout=None): 2713 ''' 2714 List gets a list of GrantedAccountEntitlement records matching a given set of criteria. 2715 ''' 2716 deadline = None if timeout is None else time.time() + timeout 2717 req = GrantedAccountEntitlementListRequest() 2718 req.meta.CopyFrom(ListRequestMetadata()) 2719 if self.parent.page_limit > 0: 2720 req.meta.limit = self.parent.page_limit 2721 if self.parent.snapshot_datetime is not None: 2722 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2723 2724 req.account_id = (account_id) 2725 req.filter = plumbing.quote_filter_args(filter, *args) 2726 2727 def generator(svc, req): 2728 tries = 0 2729 while True: 2730 t = None if deadline is None else deadline - time.time() 2731 try: 2732 plumbing_response = svc.stub.List( 2733 req, 2734 metadata=svc.parent.get_metadata( 2735 'GrantedAccountEntitlements.List', req), 2736 timeout=t) 2737 except Exception as e: 2738 if self.parent.shouldRetry(tries, e, deadline): 2739 tries += 1 2740 time.sleep( 2741 self.parent.exponentialBackoff(tries, deadline)) 2742 continue 2743 raise plumbing.convert_error_to_porcelain(e) from e 2744 tries = 0 2745 for plumbing_item in plumbing_response.granted_account_entitlements: 2746 yield plumbing.convert_granted_account_entitlement_to_porcelain( 2747 plumbing_item) 2748 if plumbing_response.meta.next_cursor == '': 2749 break 2750 req.meta.cursor = plumbing_response.meta.next_cursor 2751 2752 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)
2712 def list(self, account_id, filter, *args, timeout=None): 2713 ''' 2714 List gets a list of GrantedAccountEntitlement records matching a given set of criteria. 2715 ''' 2716 deadline = None if timeout is None else time.time() + timeout 2717 req = GrantedAccountEntitlementListRequest() 2718 req.meta.CopyFrom(ListRequestMetadata()) 2719 if self.parent.page_limit > 0: 2720 req.meta.limit = self.parent.page_limit 2721 if self.parent.snapshot_datetime is not None: 2722 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2723 2724 req.account_id = (account_id) 2725 req.filter = plumbing.quote_filter_args(filter, *args) 2726 2727 def generator(svc, req): 2728 tries = 0 2729 while True: 2730 t = None if deadline is None else deadline - time.time() 2731 try: 2732 plumbing_response = svc.stub.List( 2733 req, 2734 metadata=svc.parent.get_metadata( 2735 'GrantedAccountEntitlements.List', req), 2736 timeout=t) 2737 except Exception as e: 2738 if self.parent.shouldRetry(tries, e, deadline): 2739 tries += 1 2740 time.sleep( 2741 self.parent.exponentialBackoff(tries, deadline)) 2742 continue 2743 raise plumbing.convert_error_to_porcelain(e) from e 2744 tries = 0 2745 for plumbing_item in plumbing_response.granted_account_entitlements: 2746 yield plumbing.convert_granted_account_entitlement_to_porcelain( 2747 plumbing_item) 2748 if plumbing_response.meta.next_cursor == '': 2749 break 2750 req.meta.cursor = plumbing_response.meta.next_cursor 2751 2752 return generator(self, req)
List gets a list of GrantedAccountEntitlement records matching a given set of criteria.
class
SnapshotGrantedAccountEntitlements:
2755class SnapshotGrantedAccountEntitlements: 2756 ''' 2757 SnapshotGrantedAccountEntitlements exposes the read only methods of the GrantedAccountEntitlements 2758 service for historical queries. 2759 ''' 2760 def __init__(self, granted_account_entitlements): 2761 self.granted_account_entitlements = granted_account_entitlements 2762 2763 def list(self, account_id, filter, *args, timeout=None): 2764 ''' 2765 List gets a list of GrantedAccountEntitlement records matching a given set of criteria. 2766 ''' 2767 return self.granted_account_entitlements.list(account_id, 2768 filter, 2769 *args, 2770 timeout=timeout)
SnapshotGrantedAccountEntitlements exposes the read only methods of the GrantedAccountEntitlements service for historical queries.
def
list(self, account_id, filter, *args, timeout=None)
2763 def list(self, account_id, filter, *args, timeout=None): 2764 ''' 2765 List gets a list of GrantedAccountEntitlement records matching a given set of criteria. 2766 ''' 2767 return self.granted_account_entitlements.list(account_id, 2768 filter, 2769 *args, 2770 timeout=timeout)
List gets a list of GrantedAccountEntitlement records matching a given set of criteria.
class
GrantedResourceEntitlements:
2773class GrantedResourceEntitlements: 2774 ''' 2775 GrantedResourceEntitlements enumerates the accounts that have been granted access to a given resource. 2776 The GrantedResourceEntitlements service is read-only. 2777 See `strongdm.models.GrantedResourceEntitlement`. 2778 ''' 2779 def __init__(self, channel, client): 2780 self.parent = client 2781 self.stub = GrantedResourceEntitlementsStub(channel) 2782 2783 def list(self, resource_id, filter, *args, timeout=None): 2784 ''' 2785 List gets a list of GrantedResourceEntitlement records matching a given set of criteria. 2786 ''' 2787 deadline = None if timeout is None else time.time() + timeout 2788 req = GrantedResourceEntitlementListRequest() 2789 req.meta.CopyFrom(ListRequestMetadata()) 2790 if self.parent.page_limit > 0: 2791 req.meta.limit = self.parent.page_limit 2792 if self.parent.snapshot_datetime is not None: 2793 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2794 2795 req.resource_id = (resource_id) 2796 req.filter = plumbing.quote_filter_args(filter, *args) 2797 2798 def generator(svc, req): 2799 tries = 0 2800 while True: 2801 t = None if deadline is None else deadline - time.time() 2802 try: 2803 plumbing_response = svc.stub.List( 2804 req, 2805 metadata=svc.parent.get_metadata( 2806 'GrantedResourceEntitlements.List', req), 2807 timeout=t) 2808 except Exception as e: 2809 if self.parent.shouldRetry(tries, e, deadline): 2810 tries += 1 2811 time.sleep( 2812 self.parent.exponentialBackoff(tries, deadline)) 2813 continue 2814 raise plumbing.convert_error_to_porcelain(e) from e 2815 tries = 0 2816 for plumbing_item in plumbing_response.granted_resource_entitlements: 2817 yield plumbing.convert_granted_resource_entitlement_to_porcelain( 2818 plumbing_item) 2819 if plumbing_response.meta.next_cursor == '': 2820 break 2821 req.meta.cursor = plumbing_response.meta.next_cursor 2822 2823 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)
2783 def list(self, resource_id, filter, *args, timeout=None): 2784 ''' 2785 List gets a list of GrantedResourceEntitlement records matching a given set of criteria. 2786 ''' 2787 deadline = None if timeout is None else time.time() + timeout 2788 req = GrantedResourceEntitlementListRequest() 2789 req.meta.CopyFrom(ListRequestMetadata()) 2790 if self.parent.page_limit > 0: 2791 req.meta.limit = self.parent.page_limit 2792 if self.parent.snapshot_datetime is not None: 2793 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2794 2795 req.resource_id = (resource_id) 2796 req.filter = plumbing.quote_filter_args(filter, *args) 2797 2798 def generator(svc, req): 2799 tries = 0 2800 while True: 2801 t = None if deadline is None else deadline - time.time() 2802 try: 2803 plumbing_response = svc.stub.List( 2804 req, 2805 metadata=svc.parent.get_metadata( 2806 'GrantedResourceEntitlements.List', req), 2807 timeout=t) 2808 except Exception as e: 2809 if self.parent.shouldRetry(tries, e, deadline): 2810 tries += 1 2811 time.sleep( 2812 self.parent.exponentialBackoff(tries, deadline)) 2813 continue 2814 raise plumbing.convert_error_to_porcelain(e) from e 2815 tries = 0 2816 for plumbing_item in plumbing_response.granted_resource_entitlements: 2817 yield plumbing.convert_granted_resource_entitlement_to_porcelain( 2818 plumbing_item) 2819 if plumbing_response.meta.next_cursor == '': 2820 break 2821 req.meta.cursor = plumbing_response.meta.next_cursor 2822 2823 return generator(self, req)
List gets a list of GrantedResourceEntitlement records matching a given set of criteria.
class
SnapshotGrantedResourceEntitlements:
2826class SnapshotGrantedResourceEntitlements: 2827 ''' 2828 SnapshotGrantedResourceEntitlements exposes the read only methods of the GrantedResourceEntitlements 2829 service for historical queries. 2830 ''' 2831 def __init__(self, granted_resource_entitlements): 2832 self.granted_resource_entitlements = granted_resource_entitlements 2833 2834 def list(self, resource_id, filter, *args, timeout=None): 2835 ''' 2836 List gets a list of GrantedResourceEntitlement records matching a given set of criteria. 2837 ''' 2838 return self.granted_resource_entitlements.list(resource_id, 2839 filter, 2840 *args, 2841 timeout=timeout)
SnapshotGrantedResourceEntitlements exposes the read only methods of the GrantedResourceEntitlements service for historical queries.
def
list(self, resource_id, filter, *args, timeout=None)
2834 def list(self, resource_id, filter, *args, timeout=None): 2835 ''' 2836 List gets a list of GrantedResourceEntitlement records matching a given set of criteria. 2837 ''' 2838 return self.granted_resource_entitlements.list(resource_id, 2839 filter, 2840 *args, 2841 timeout=timeout)
List gets a list of GrantedResourceEntitlement records matching a given set of criteria.
class
GrantedRoleEntitlements:
2844class GrantedRoleEntitlements: 2845 ''' 2846 GrantedRoleEntitlements enumerates the resources to which a role grants access. 2847 The GrantedRoleEntitlements service is read-only. 2848 See `strongdm.models.GrantedRoleEntitlement`. 2849 ''' 2850 def __init__(self, channel, client): 2851 self.parent = client 2852 self.stub = GrantedRoleEntitlementsStub(channel) 2853 2854 def list(self, role_id, filter, *args, timeout=None): 2855 ''' 2856 List gets a list of GrantedRoleEntitlement records matching a given set of criteria. 2857 ''' 2858 deadline = None if timeout is None else time.time() + timeout 2859 req = GrantedRoleEntitlementListRequest() 2860 req.meta.CopyFrom(ListRequestMetadata()) 2861 if self.parent.page_limit > 0: 2862 req.meta.limit = self.parent.page_limit 2863 if self.parent.snapshot_datetime is not None: 2864 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2865 2866 req.role_id = (role_id) 2867 req.filter = plumbing.quote_filter_args(filter, *args) 2868 2869 def generator(svc, req): 2870 tries = 0 2871 while True: 2872 t = None if deadline is None else deadline - time.time() 2873 try: 2874 plumbing_response = svc.stub.List( 2875 req, 2876 metadata=svc.parent.get_metadata( 2877 'GrantedRoleEntitlements.List', req), 2878 timeout=t) 2879 except Exception as e: 2880 if self.parent.shouldRetry(tries, e, deadline): 2881 tries += 1 2882 time.sleep( 2883 self.parent.exponentialBackoff(tries, deadline)) 2884 continue 2885 raise plumbing.convert_error_to_porcelain(e) from e 2886 tries = 0 2887 for plumbing_item in plumbing_response.granted_role_entitlements: 2888 yield plumbing.convert_granted_role_entitlement_to_porcelain( 2889 plumbing_item) 2890 if plumbing_response.meta.next_cursor == '': 2891 break 2892 req.meta.cursor = plumbing_response.meta.next_cursor 2893 2894 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)
2854 def list(self, role_id, filter, *args, timeout=None): 2855 ''' 2856 List gets a list of GrantedRoleEntitlement records matching a given set of criteria. 2857 ''' 2858 deadline = None if timeout is None else time.time() + timeout 2859 req = GrantedRoleEntitlementListRequest() 2860 req.meta.CopyFrom(ListRequestMetadata()) 2861 if self.parent.page_limit > 0: 2862 req.meta.limit = self.parent.page_limit 2863 if self.parent.snapshot_datetime is not None: 2864 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2865 2866 req.role_id = (role_id) 2867 req.filter = plumbing.quote_filter_args(filter, *args) 2868 2869 def generator(svc, req): 2870 tries = 0 2871 while True: 2872 t = None if deadline is None else deadline - time.time() 2873 try: 2874 plumbing_response = svc.stub.List( 2875 req, 2876 metadata=svc.parent.get_metadata( 2877 'GrantedRoleEntitlements.List', req), 2878 timeout=t) 2879 except Exception as e: 2880 if self.parent.shouldRetry(tries, e, deadline): 2881 tries += 1 2882 time.sleep( 2883 self.parent.exponentialBackoff(tries, deadline)) 2884 continue 2885 raise plumbing.convert_error_to_porcelain(e) from e 2886 tries = 0 2887 for plumbing_item in plumbing_response.granted_role_entitlements: 2888 yield plumbing.convert_granted_role_entitlement_to_porcelain( 2889 plumbing_item) 2890 if plumbing_response.meta.next_cursor == '': 2891 break 2892 req.meta.cursor = plumbing_response.meta.next_cursor 2893 2894 return generator(self, req)
List gets a list of GrantedRoleEntitlement records matching a given set of criteria.
class
SnapshotGrantedRoleEntitlements:
2897class SnapshotGrantedRoleEntitlements: 2898 ''' 2899 SnapshotGrantedRoleEntitlements exposes the read only methods of the GrantedRoleEntitlements 2900 service for historical queries. 2901 ''' 2902 def __init__(self, granted_role_entitlements): 2903 self.granted_role_entitlements = granted_role_entitlements 2904 2905 def list(self, role_id, filter, *args, timeout=None): 2906 ''' 2907 List gets a list of GrantedRoleEntitlement records matching a given set of criteria. 2908 ''' 2909 return self.granted_role_entitlements.list(role_id, 2910 filter, 2911 *args, 2912 timeout=timeout)
SnapshotGrantedRoleEntitlements exposes the read only methods of the GrantedRoleEntitlements service for historical queries.
def
list(self, role_id, filter, *args, timeout=None)
2905 def list(self, role_id, filter, *args, timeout=None): 2906 ''' 2907 List gets a list of GrantedRoleEntitlement records matching a given set of criteria. 2908 ''' 2909 return self.granted_role_entitlements.list(role_id, 2910 filter, 2911 *args, 2912 timeout=timeout)
List gets a list of GrantedRoleEntitlement records matching a given set of criteria.
class
Roles:
2915class Roles: 2916 ''' 2917 A Role has a list of access rules which determine which Resources the members 2918 of the Role have access to. An Account can be a member of multiple Roles via 2919 AccountAttachments. 2920 See `strongdm.models.Role`. 2921 ''' 2922 def __init__(self, channel, client): 2923 self.parent = client 2924 self.stub = RolesStub(channel) 2925 2926 def create(self, role, timeout=None): 2927 ''' 2928 Create registers a new Role. 2929 ''' 2930 deadline = None if timeout is None else time.time() + timeout 2931 req = RoleCreateRequest() 2932 2933 if role is not None: 2934 req.role.CopyFrom(plumbing.convert_role_to_plumbing(role)) 2935 tries = 0 2936 plumbing_response = None 2937 while True: 2938 t = None if deadline is None else deadline - time.time() 2939 try: 2940 plumbing_response = self.stub.Create( 2941 req, 2942 metadata=self.parent.get_metadata('Roles.Create', req), 2943 timeout=t) 2944 except Exception as e: 2945 if self.parent.shouldRetry(tries, e, deadline): 2946 tries += 1 2947 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2948 continue 2949 raise plumbing.convert_error_to_porcelain(e) from e 2950 break 2951 2952 resp = models.RoleCreateResponse() 2953 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 2954 plumbing_response.meta) 2955 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2956 plumbing_response.rate_limit) 2957 resp.role = plumbing.convert_role_to_porcelain(plumbing_response.role) 2958 return resp 2959 2960 def get(self, id, timeout=None): 2961 ''' 2962 Get reads one Role by ID. 2963 ''' 2964 deadline = None if timeout is None else time.time() + timeout 2965 req = RoleGetRequest() 2966 if self.parent.snapshot_datetime is not None: 2967 req.meta.CopyFrom(GetRequestMetadata()) 2968 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2969 2970 req.id = (id) 2971 tries = 0 2972 plumbing_response = None 2973 while True: 2974 t = None if deadline is None else deadline - time.time() 2975 try: 2976 plumbing_response = self.stub.Get( 2977 req, 2978 metadata=self.parent.get_metadata('Roles.Get', req), 2979 timeout=t) 2980 except Exception as e: 2981 if self.parent.shouldRetry(tries, e, deadline): 2982 tries += 1 2983 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2984 continue 2985 raise plumbing.convert_error_to_porcelain(e) from e 2986 break 2987 2988 resp = models.RoleGetResponse() 2989 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2990 plumbing_response.meta) 2991 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2992 plumbing_response.rate_limit) 2993 resp.role = plumbing.convert_role_to_porcelain(plumbing_response.role) 2994 return resp 2995 2996 def update(self, role, timeout=None): 2997 ''' 2998 Update replaces all the fields of a Role by ID. 2999 ''' 3000 deadline = None if timeout is None else time.time() + timeout 3001 req = RoleUpdateRequest() 3002 3003 if role is not None: 3004 req.role.CopyFrom(plumbing.convert_role_to_plumbing(role)) 3005 tries = 0 3006 plumbing_response = None 3007 while True: 3008 t = None if deadline is None else deadline - time.time() 3009 try: 3010 plumbing_response = self.stub.Update( 3011 req, 3012 metadata=self.parent.get_metadata('Roles.Update', req), 3013 timeout=t) 3014 except Exception as e: 3015 if self.parent.shouldRetry(tries, e, deadline): 3016 tries += 1 3017 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3018 continue 3019 raise plumbing.convert_error_to_porcelain(e) from e 3020 break 3021 3022 resp = models.RoleUpdateResponse() 3023 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 3024 plumbing_response.meta) 3025 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3026 plumbing_response.rate_limit) 3027 resp.role = plumbing.convert_role_to_porcelain(plumbing_response.role) 3028 return resp 3029 3030 def delete(self, id, timeout=None): 3031 ''' 3032 Delete removes a Role by ID. 3033 ''' 3034 deadline = None if timeout is None else time.time() + timeout 3035 req = RoleDeleteRequest() 3036 3037 req.id = (id) 3038 tries = 0 3039 plumbing_response = None 3040 while True: 3041 t = None if deadline is None else deadline - time.time() 3042 try: 3043 plumbing_response = self.stub.Delete( 3044 req, 3045 metadata=self.parent.get_metadata('Roles.Delete', req), 3046 timeout=t) 3047 except Exception as e: 3048 if self.parent.shouldRetry(tries, e, deadline): 3049 tries += 1 3050 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3051 continue 3052 raise plumbing.convert_error_to_porcelain(e) from e 3053 break 3054 3055 resp = models.RoleDeleteResponse() 3056 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3057 plumbing_response.meta) 3058 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3059 plumbing_response.rate_limit) 3060 return resp 3061 3062 def list(self, filter, *args, timeout=None): 3063 ''' 3064 List gets a list of Roles matching a given set of criteria. 3065 ''' 3066 deadline = None if timeout is None else time.time() + timeout 3067 req = RoleListRequest() 3068 req.meta.CopyFrom(ListRequestMetadata()) 3069 if self.parent.page_limit > 0: 3070 req.meta.limit = self.parent.page_limit 3071 if self.parent.snapshot_datetime is not None: 3072 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3073 3074 req.filter = plumbing.quote_filter_args(filter, *args) 3075 3076 def generator(svc, req): 3077 tries = 0 3078 while True: 3079 t = None if deadline is None else deadline - time.time() 3080 try: 3081 plumbing_response = svc.stub.List( 3082 req, 3083 metadata=svc.parent.get_metadata('Roles.List', req), 3084 timeout=t) 3085 except Exception as e: 3086 if self.parent.shouldRetry(tries, e, deadline): 3087 tries += 1 3088 time.sleep( 3089 self.parent.exponentialBackoff(tries, deadline)) 3090 continue 3091 raise plumbing.convert_error_to_porcelain(e) from e 3092 tries = 0 3093 for plumbing_item in plumbing_response.roles: 3094 yield plumbing.convert_role_to_porcelain(plumbing_item) 3095 if plumbing_response.meta.next_cursor == '': 3096 break 3097 req.meta.cursor = plumbing_response.meta.next_cursor 3098 3099 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)
2926 def create(self, role, timeout=None): 2927 ''' 2928 Create registers a new Role. 2929 ''' 2930 deadline = None if timeout is None else time.time() + timeout 2931 req = RoleCreateRequest() 2932 2933 if role is not None: 2934 req.role.CopyFrom(plumbing.convert_role_to_plumbing(role)) 2935 tries = 0 2936 plumbing_response = None 2937 while True: 2938 t = None if deadline is None else deadline - time.time() 2939 try: 2940 plumbing_response = self.stub.Create( 2941 req, 2942 metadata=self.parent.get_metadata('Roles.Create', req), 2943 timeout=t) 2944 except Exception as e: 2945 if self.parent.shouldRetry(tries, e, deadline): 2946 tries += 1 2947 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2948 continue 2949 raise plumbing.convert_error_to_porcelain(e) from e 2950 break 2951 2952 resp = models.RoleCreateResponse() 2953 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 2954 plumbing_response.meta) 2955 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2956 plumbing_response.rate_limit) 2957 resp.role = plumbing.convert_role_to_porcelain(plumbing_response.role) 2958 return resp
Create registers a new Role.
def
get(self, id, timeout=None)
2960 def get(self, id, timeout=None): 2961 ''' 2962 Get reads one Role by ID. 2963 ''' 2964 deadline = None if timeout is None else time.time() + timeout 2965 req = RoleGetRequest() 2966 if self.parent.snapshot_datetime is not None: 2967 req.meta.CopyFrom(GetRequestMetadata()) 2968 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2969 2970 req.id = (id) 2971 tries = 0 2972 plumbing_response = None 2973 while True: 2974 t = None if deadline is None else deadline - time.time() 2975 try: 2976 plumbing_response = self.stub.Get( 2977 req, 2978 metadata=self.parent.get_metadata('Roles.Get', req), 2979 timeout=t) 2980 except Exception as e: 2981 if self.parent.shouldRetry(tries, e, deadline): 2982 tries += 1 2983 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2984 continue 2985 raise plumbing.convert_error_to_porcelain(e) from e 2986 break 2987 2988 resp = models.RoleGetResponse() 2989 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2990 plumbing_response.meta) 2991 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2992 plumbing_response.rate_limit) 2993 resp.role = plumbing.convert_role_to_porcelain(plumbing_response.role) 2994 return resp
Get reads one Role by ID.
def
update(self, role, timeout=None)
2996 def update(self, role, timeout=None): 2997 ''' 2998 Update replaces all the fields of a Role by ID. 2999 ''' 3000 deadline = None if timeout is None else time.time() + timeout 3001 req = RoleUpdateRequest() 3002 3003 if role is not None: 3004 req.role.CopyFrom(plumbing.convert_role_to_plumbing(role)) 3005 tries = 0 3006 plumbing_response = None 3007 while True: 3008 t = None if deadline is None else deadline - time.time() 3009 try: 3010 plumbing_response = self.stub.Update( 3011 req, 3012 metadata=self.parent.get_metadata('Roles.Update', req), 3013 timeout=t) 3014 except Exception as e: 3015 if self.parent.shouldRetry(tries, e, deadline): 3016 tries += 1 3017 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3018 continue 3019 raise plumbing.convert_error_to_porcelain(e) from e 3020 break 3021 3022 resp = models.RoleUpdateResponse() 3023 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 3024 plumbing_response.meta) 3025 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3026 plumbing_response.rate_limit) 3027 resp.role = plumbing.convert_role_to_porcelain(plumbing_response.role) 3028 return resp
Update replaces all the fields of a Role by ID.
def
delete(self, id, timeout=None)
3030 def delete(self, id, timeout=None): 3031 ''' 3032 Delete removes a Role by ID. 3033 ''' 3034 deadline = None if timeout is None else time.time() + timeout 3035 req = RoleDeleteRequest() 3036 3037 req.id = (id) 3038 tries = 0 3039 plumbing_response = None 3040 while True: 3041 t = None if deadline is None else deadline - time.time() 3042 try: 3043 plumbing_response = self.stub.Delete( 3044 req, 3045 metadata=self.parent.get_metadata('Roles.Delete', req), 3046 timeout=t) 3047 except Exception as e: 3048 if self.parent.shouldRetry(tries, e, deadline): 3049 tries += 1 3050 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3051 continue 3052 raise plumbing.convert_error_to_porcelain(e) from e 3053 break 3054 3055 resp = models.RoleDeleteResponse() 3056 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3057 plumbing_response.meta) 3058 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3059 plumbing_response.rate_limit) 3060 return resp
Delete removes a Role by ID.
def
list(self, filter, *args, timeout=None)
3062 def list(self, filter, *args, timeout=None): 3063 ''' 3064 List gets a list of Roles matching a given set of criteria. 3065 ''' 3066 deadline = None if timeout is None else time.time() + timeout 3067 req = RoleListRequest() 3068 req.meta.CopyFrom(ListRequestMetadata()) 3069 if self.parent.page_limit > 0: 3070 req.meta.limit = self.parent.page_limit 3071 if self.parent.snapshot_datetime is not None: 3072 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3073 3074 req.filter = plumbing.quote_filter_args(filter, *args) 3075 3076 def generator(svc, req): 3077 tries = 0 3078 while True: 3079 t = None if deadline is None else deadline - time.time() 3080 try: 3081 plumbing_response = svc.stub.List( 3082 req, 3083 metadata=svc.parent.get_metadata('Roles.List', req), 3084 timeout=t) 3085 except Exception as e: 3086 if self.parent.shouldRetry(tries, e, deadline): 3087 tries += 1 3088 time.sleep( 3089 self.parent.exponentialBackoff(tries, deadline)) 3090 continue 3091 raise plumbing.convert_error_to_porcelain(e) from e 3092 tries = 0 3093 for plumbing_item in plumbing_response.roles: 3094 yield plumbing.convert_role_to_porcelain(plumbing_item) 3095 if plumbing_response.meta.next_cursor == '': 3096 break 3097 req.meta.cursor = plumbing_response.meta.next_cursor 3098 3099 return generator(self, req)
List gets a list of Roles matching a given set of criteria.
class
SnapshotRoles:
3102class SnapshotRoles: 3103 ''' 3104 SnapshotRoles exposes the read only methods of the Roles 3105 service for historical queries. 3106 ''' 3107 def __init__(self, roles): 3108 self.roles = roles 3109 3110 def get(self, id, timeout=None): 3111 ''' 3112 Get reads one Role by ID. 3113 ''' 3114 return self.roles.get(id, timeout=timeout) 3115 3116 def list(self, filter, *args, timeout=None): 3117 ''' 3118 List gets a list of Roles matching a given set of criteria. 3119 ''' 3120 return self.roles.list(filter, *args, timeout=timeout)
SnapshotRoles exposes the read only methods of the Roles service for historical queries.
class
Groups:
3123class Groups: 3124 ''' 3125 A Group is a set of principals. 3126 See `strongdm.models.Group`. 3127 ''' 3128 def __init__(self, channel, client): 3129 self.parent = client 3130 self.stub = GroupsStub(channel) 3131 3132 def create(self, group, timeout=None): 3133 ''' 3134 Create registers a new Group. 3135 ''' 3136 deadline = None if timeout is None else time.time() + timeout 3137 req = GroupCreateRequest() 3138 3139 if group is not None: 3140 req.group.CopyFrom(plumbing.convert_group_to_plumbing(group)) 3141 tries = 0 3142 plumbing_response = None 3143 while True: 3144 t = None if deadline is None else deadline - time.time() 3145 try: 3146 plumbing_response = self.stub.Create( 3147 req, 3148 metadata=self.parent.get_metadata('Groups.Create', req), 3149 timeout=t) 3150 except Exception as e: 3151 if self.parent.shouldRetry(tries, e, deadline): 3152 tries += 1 3153 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3154 continue 3155 raise plumbing.convert_error_to_porcelain(e) from e 3156 break 3157 3158 resp = models.GroupCreateResponse() 3159 resp.group = plumbing.convert_group_to_porcelain( 3160 plumbing_response.group) 3161 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3162 plumbing_response.rate_limit) 3163 return resp 3164 3165 def create_from_roles(self, role_ids, commit, timeout=None): 3166 deadline = None if timeout is None else time.time() + timeout 3167 req = GroupCreateFromRolesRequest() 3168 3169 req.role_ids.extend((role_ids)) 3170 req.commit = (commit) 3171 tries = 0 3172 plumbing_response = None 3173 while True: 3174 t = None if deadline is None else deadline - time.time() 3175 try: 3176 plumbing_response = self.stub.CreateFromRoles( 3177 req, 3178 metadata=self.parent.get_metadata('Groups.CreateFromRoles', 3179 req), 3180 timeout=t) 3181 except Exception as e: 3182 if self.parent.shouldRetry(tries, e, deadline): 3183 tries += 1 3184 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3185 continue 3186 raise plumbing.convert_error_to_porcelain(e) from e 3187 break 3188 3189 resp = models.GroupCreateFromRolesResponse() 3190 resp.group_from_role = plumbing.convert_repeated_group_from_role_to_porcelain( 3191 plumbing_response.group_from_role) 3192 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3193 plumbing_response.rate_limit) 3194 return resp 3195 3196 def get(self, id, timeout=None): 3197 ''' 3198 Get reads one Group by ID. 3199 ''' 3200 deadline = None if timeout is None else time.time() + timeout 3201 req = GroupGetRequest() 3202 if self.parent.snapshot_datetime is not None: 3203 req.meta.CopyFrom(GetRequestMetadata()) 3204 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3205 3206 req.id = (id) 3207 tries = 0 3208 plumbing_response = None 3209 while True: 3210 t = None if deadline is None else deadline - time.time() 3211 try: 3212 plumbing_response = self.stub.Get( 3213 req, 3214 metadata=self.parent.get_metadata('Groups.Get', req), 3215 timeout=t) 3216 except Exception as e: 3217 if self.parent.shouldRetry(tries, e, deadline): 3218 tries += 1 3219 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3220 continue 3221 raise plumbing.convert_error_to_porcelain(e) from e 3222 break 3223 3224 resp = models.GroupGetResponse() 3225 resp.group = plumbing.convert_group_to_porcelain( 3226 plumbing_response.group) 3227 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3228 plumbing_response.meta) 3229 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3230 plumbing_response.rate_limit) 3231 return resp 3232 3233 def update(self, group, timeout=None): 3234 ''' 3235 Update replaces all the fields of a Group by ID. 3236 ''' 3237 deadline = None if timeout is None else time.time() + timeout 3238 req = GroupUpdateRequest() 3239 3240 if group is not None: 3241 req.group.CopyFrom(plumbing.convert_group_to_plumbing(group)) 3242 tries = 0 3243 plumbing_response = None 3244 while True: 3245 t = None if deadline is None else deadline - time.time() 3246 try: 3247 plumbing_response = self.stub.Update( 3248 req, 3249 metadata=self.parent.get_metadata('Groups.Update', req), 3250 timeout=t) 3251 except Exception as e: 3252 if self.parent.shouldRetry(tries, e, deadline): 3253 tries += 1 3254 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3255 continue 3256 raise plumbing.convert_error_to_porcelain(e) from e 3257 break 3258 3259 resp = models.GroupUpdateResponse() 3260 resp.group = plumbing.convert_group_to_porcelain( 3261 plumbing_response.group) 3262 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3263 plumbing_response.rate_limit) 3264 return resp 3265 3266 def delete(self, id, timeout=None): 3267 ''' 3268 Delete removes a Group by ID. 3269 ''' 3270 deadline = None if timeout is None else time.time() + timeout 3271 req = GroupDeleteRequest() 3272 3273 req.id = (id) 3274 tries = 0 3275 plumbing_response = None 3276 while True: 3277 t = None if deadline is None else deadline - time.time() 3278 try: 3279 plumbing_response = self.stub.Delete( 3280 req, 3281 metadata=self.parent.get_metadata('Groups.Delete', req), 3282 timeout=t) 3283 except Exception as e: 3284 if self.parent.shouldRetry(tries, e, deadline): 3285 tries += 1 3286 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3287 continue 3288 raise plumbing.convert_error_to_porcelain(e) from e 3289 break 3290 3291 resp = models.GroupDeleteResponse() 3292 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3293 plumbing_response.meta) 3294 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3295 plumbing_response.rate_limit) 3296 return resp 3297 3298 def list(self, filter, *args, timeout=None): 3299 ''' 3300 List gets a list of Groups matching a given set of criteria. 3301 ''' 3302 deadline = None if timeout is None else time.time() + timeout 3303 req = GroupListRequest() 3304 req.meta.CopyFrom(ListRequestMetadata()) 3305 if self.parent.page_limit > 0: 3306 req.meta.limit = self.parent.page_limit 3307 if self.parent.snapshot_datetime is not None: 3308 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3309 3310 req.filter = plumbing.quote_filter_args(filter, *args) 3311 3312 def generator(svc, req): 3313 tries = 0 3314 while True: 3315 t = None if deadline is None else deadline - time.time() 3316 try: 3317 plumbing_response = svc.stub.List( 3318 req, 3319 metadata=svc.parent.get_metadata('Groups.List', req), 3320 timeout=t) 3321 except Exception as e: 3322 if self.parent.shouldRetry(tries, e, deadline): 3323 tries += 1 3324 time.sleep( 3325 self.parent.exponentialBackoff(tries, deadline)) 3326 continue 3327 raise plumbing.convert_error_to_porcelain(e) from e 3328 tries = 0 3329 for plumbing_item in plumbing_response.groups: 3330 yield plumbing.convert_group_to_porcelain(plumbing_item) 3331 if plumbing_response.meta.next_cursor == '': 3332 break 3333 req.meta.cursor = plumbing_response.meta.next_cursor 3334 3335 return generator(self, req)
A Group is a set of principals.
See strongdm.models.Group.
def
create(self, group, timeout=None)
3132 def create(self, group, timeout=None): 3133 ''' 3134 Create registers a new Group. 3135 ''' 3136 deadline = None if timeout is None else time.time() + timeout 3137 req = GroupCreateRequest() 3138 3139 if group is not None: 3140 req.group.CopyFrom(plumbing.convert_group_to_plumbing(group)) 3141 tries = 0 3142 plumbing_response = None 3143 while True: 3144 t = None if deadline is None else deadline - time.time() 3145 try: 3146 plumbing_response = self.stub.Create( 3147 req, 3148 metadata=self.parent.get_metadata('Groups.Create', req), 3149 timeout=t) 3150 except Exception as e: 3151 if self.parent.shouldRetry(tries, e, deadline): 3152 tries += 1 3153 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3154 continue 3155 raise plumbing.convert_error_to_porcelain(e) from e 3156 break 3157 3158 resp = models.GroupCreateResponse() 3159 resp.group = plumbing.convert_group_to_porcelain( 3160 plumbing_response.group) 3161 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3162 plumbing_response.rate_limit) 3163 return resp
Create registers a new Group.
def
create_from_roles(self, role_ids, commit, timeout=None)
3165 def create_from_roles(self, role_ids, commit, timeout=None): 3166 deadline = None if timeout is None else time.time() + timeout 3167 req = GroupCreateFromRolesRequest() 3168 3169 req.role_ids.extend((role_ids)) 3170 req.commit = (commit) 3171 tries = 0 3172 plumbing_response = None 3173 while True: 3174 t = None if deadline is None else deadline - time.time() 3175 try: 3176 plumbing_response = self.stub.CreateFromRoles( 3177 req, 3178 metadata=self.parent.get_metadata('Groups.CreateFromRoles', 3179 req), 3180 timeout=t) 3181 except Exception as e: 3182 if self.parent.shouldRetry(tries, e, deadline): 3183 tries += 1 3184 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3185 continue 3186 raise plumbing.convert_error_to_porcelain(e) from e 3187 break 3188 3189 resp = models.GroupCreateFromRolesResponse() 3190 resp.group_from_role = plumbing.convert_repeated_group_from_role_to_porcelain( 3191 plumbing_response.group_from_role) 3192 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3193 plumbing_response.rate_limit) 3194 return resp
def
get(self, id, timeout=None)
3196 def get(self, id, timeout=None): 3197 ''' 3198 Get reads one Group by ID. 3199 ''' 3200 deadline = None if timeout is None else time.time() + timeout 3201 req = GroupGetRequest() 3202 if self.parent.snapshot_datetime is not None: 3203 req.meta.CopyFrom(GetRequestMetadata()) 3204 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3205 3206 req.id = (id) 3207 tries = 0 3208 plumbing_response = None 3209 while True: 3210 t = None if deadline is None else deadline - time.time() 3211 try: 3212 plumbing_response = self.stub.Get( 3213 req, 3214 metadata=self.parent.get_metadata('Groups.Get', req), 3215 timeout=t) 3216 except Exception as e: 3217 if self.parent.shouldRetry(tries, e, deadline): 3218 tries += 1 3219 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3220 continue 3221 raise plumbing.convert_error_to_porcelain(e) from e 3222 break 3223 3224 resp = models.GroupGetResponse() 3225 resp.group = plumbing.convert_group_to_porcelain( 3226 plumbing_response.group) 3227 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3228 plumbing_response.meta) 3229 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3230 plumbing_response.rate_limit) 3231 return resp
Get reads one Group by ID.
def
update(self, group, timeout=None)
3233 def update(self, group, timeout=None): 3234 ''' 3235 Update replaces all the fields of a Group by ID. 3236 ''' 3237 deadline = None if timeout is None else time.time() + timeout 3238 req = GroupUpdateRequest() 3239 3240 if group is not None: 3241 req.group.CopyFrom(plumbing.convert_group_to_plumbing(group)) 3242 tries = 0 3243 plumbing_response = None 3244 while True: 3245 t = None if deadline is None else deadline - time.time() 3246 try: 3247 plumbing_response = self.stub.Update( 3248 req, 3249 metadata=self.parent.get_metadata('Groups.Update', req), 3250 timeout=t) 3251 except Exception as e: 3252 if self.parent.shouldRetry(tries, e, deadline): 3253 tries += 1 3254 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3255 continue 3256 raise plumbing.convert_error_to_porcelain(e) from e 3257 break 3258 3259 resp = models.GroupUpdateResponse() 3260 resp.group = plumbing.convert_group_to_porcelain( 3261 plumbing_response.group) 3262 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3263 plumbing_response.rate_limit) 3264 return resp
Update replaces all the fields of a Group by ID.
def
delete(self, id, timeout=None)
3266 def delete(self, id, timeout=None): 3267 ''' 3268 Delete removes a Group by ID. 3269 ''' 3270 deadline = None if timeout is None else time.time() + timeout 3271 req = GroupDeleteRequest() 3272 3273 req.id = (id) 3274 tries = 0 3275 plumbing_response = None 3276 while True: 3277 t = None if deadline is None else deadline - time.time() 3278 try: 3279 plumbing_response = self.stub.Delete( 3280 req, 3281 metadata=self.parent.get_metadata('Groups.Delete', req), 3282 timeout=t) 3283 except Exception as e: 3284 if self.parent.shouldRetry(tries, e, deadline): 3285 tries += 1 3286 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3287 continue 3288 raise plumbing.convert_error_to_porcelain(e) from e 3289 break 3290 3291 resp = models.GroupDeleteResponse() 3292 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3293 plumbing_response.meta) 3294 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3295 plumbing_response.rate_limit) 3296 return resp
Delete removes a Group by ID.
def
list(self, filter, *args, timeout=None)
3298 def list(self, filter, *args, timeout=None): 3299 ''' 3300 List gets a list of Groups matching a given set of criteria. 3301 ''' 3302 deadline = None if timeout is None else time.time() + timeout 3303 req = GroupListRequest() 3304 req.meta.CopyFrom(ListRequestMetadata()) 3305 if self.parent.page_limit > 0: 3306 req.meta.limit = self.parent.page_limit 3307 if self.parent.snapshot_datetime is not None: 3308 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3309 3310 req.filter = plumbing.quote_filter_args(filter, *args) 3311 3312 def generator(svc, req): 3313 tries = 0 3314 while True: 3315 t = None if deadline is None else deadline - time.time() 3316 try: 3317 plumbing_response = svc.stub.List( 3318 req, 3319 metadata=svc.parent.get_metadata('Groups.List', req), 3320 timeout=t) 3321 except Exception as e: 3322 if self.parent.shouldRetry(tries, e, deadline): 3323 tries += 1 3324 time.sleep( 3325 self.parent.exponentialBackoff(tries, deadline)) 3326 continue 3327 raise plumbing.convert_error_to_porcelain(e) from e 3328 tries = 0 3329 for plumbing_item in plumbing_response.groups: 3330 yield plumbing.convert_group_to_porcelain(plumbing_item) 3331 if plumbing_response.meta.next_cursor == '': 3332 break 3333 req.meta.cursor = plumbing_response.meta.next_cursor 3334 3335 return generator(self, req)
List gets a list of Groups matching a given set of criteria.
class
SnapshotGroups:
3338class SnapshotGroups: 3339 ''' 3340 SnapshotGroups exposes the read only methods of the Groups 3341 service for historical queries. 3342 ''' 3343 def __init__(self, groups): 3344 self.groups = groups 3345 3346 def get(self, id, timeout=None): 3347 ''' 3348 Get reads one Group by ID. 3349 ''' 3350 return self.groups.get(id, timeout=timeout) 3351 3352 def list(self, filter, *args, timeout=None): 3353 ''' 3354 List gets a list of Groups matching a given set of criteria. 3355 ''' 3356 return self.groups.list(filter, *args, timeout=timeout)
SnapshotGroups exposes the read only methods of the Groups service for historical queries.
class
GroupsHistory:
3359class GroupsHistory: 3360 ''' 3361 GroupsHistory records all changes to the state of a Group. 3362 See `strongdm.models.GroupHistory`. 3363 ''' 3364 def __init__(self, channel, client): 3365 self.parent = client 3366 self.stub = GroupsHistoryStub(channel) 3367 3368 def list(self, filter, *args, timeout=None): 3369 ''' 3370 List gets a list of GroupHistory records matching a given set of criteria. 3371 ''' 3372 deadline = None if timeout is None else time.time() + timeout 3373 req = GroupHistoryListRequest() 3374 req.meta.CopyFrom(ListRequestMetadata()) 3375 if self.parent.page_limit > 0: 3376 req.meta.limit = self.parent.page_limit 3377 if self.parent.snapshot_datetime is not None: 3378 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3379 3380 req.filter = plumbing.quote_filter_args(filter, *args) 3381 3382 def generator(svc, req): 3383 tries = 0 3384 while True: 3385 t = None if deadline is None else deadline - time.time() 3386 try: 3387 plumbing_response = svc.stub.List( 3388 req, 3389 metadata=svc.parent.get_metadata( 3390 'GroupsHistory.List', req), 3391 timeout=t) 3392 except Exception as e: 3393 if self.parent.shouldRetry(tries, e, deadline): 3394 tries += 1 3395 time.sleep( 3396 self.parent.exponentialBackoff(tries, deadline)) 3397 continue 3398 raise plumbing.convert_error_to_porcelain(e) from e 3399 tries = 0 3400 for plumbing_item in plumbing_response.history: 3401 yield plumbing.convert_group_history_to_porcelain( 3402 plumbing_item) 3403 if plumbing_response.meta.next_cursor == '': 3404 break 3405 req.meta.cursor = plumbing_response.meta.next_cursor 3406 3407 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)
3368 def list(self, filter, *args, timeout=None): 3369 ''' 3370 List gets a list of GroupHistory records matching a given set of criteria. 3371 ''' 3372 deadline = None if timeout is None else time.time() + timeout 3373 req = GroupHistoryListRequest() 3374 req.meta.CopyFrom(ListRequestMetadata()) 3375 if self.parent.page_limit > 0: 3376 req.meta.limit = self.parent.page_limit 3377 if self.parent.snapshot_datetime is not None: 3378 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3379 3380 req.filter = plumbing.quote_filter_args(filter, *args) 3381 3382 def generator(svc, req): 3383 tries = 0 3384 while True: 3385 t = None if deadline is None else deadline - time.time() 3386 try: 3387 plumbing_response = svc.stub.List( 3388 req, 3389 metadata=svc.parent.get_metadata( 3390 'GroupsHistory.List', req), 3391 timeout=t) 3392 except Exception as e: 3393 if self.parent.shouldRetry(tries, e, deadline): 3394 tries += 1 3395 time.sleep( 3396 self.parent.exponentialBackoff(tries, deadline)) 3397 continue 3398 raise plumbing.convert_error_to_porcelain(e) from e 3399 tries = 0 3400 for plumbing_item in plumbing_response.history: 3401 yield plumbing.convert_group_history_to_porcelain( 3402 plumbing_item) 3403 if plumbing_response.meta.next_cursor == '': 3404 break 3405 req.meta.cursor = plumbing_response.meta.next_cursor 3406 3407 return generator(self, req)
List gets a list of GroupHistory records matching a given set of criteria.
class
GroupsRoles:
3410class GroupsRoles: 3411 ''' 3412 A GroupRole is an assignment of a Group to a Role. 3413 See `strongdm.models.GroupRole`. 3414 ''' 3415 def __init__(self, channel, client): 3416 self.parent = client 3417 self.stub = GroupsRolesStub(channel) 3418 3419 def create(self, group_role, timeout=None): 3420 ''' 3421 Create registers a new GroupRole. 3422 ''' 3423 deadline = None if timeout is None else time.time() + timeout 3424 req = GroupRoleCreateRequest() 3425 3426 if group_role is not None: 3427 req.group_role.CopyFrom( 3428 plumbing.convert_group_role_to_plumbing(group_role)) 3429 tries = 0 3430 plumbing_response = None 3431 while True: 3432 t = None if deadline is None else deadline - time.time() 3433 try: 3434 plumbing_response = self.stub.Create( 3435 req, 3436 metadata=self.parent.get_metadata('GroupsRoles.Create', 3437 req), 3438 timeout=t) 3439 except Exception as e: 3440 if self.parent.shouldRetry(tries, e, deadline): 3441 tries += 1 3442 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3443 continue 3444 raise plumbing.convert_error_to_porcelain(e) from e 3445 break 3446 3447 resp = models.GroupRoleCreateResponse() 3448 resp.group_role = plumbing.convert_group_role_to_porcelain( 3449 plumbing_response.group_role) 3450 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3451 plumbing_response.rate_limit) 3452 return resp 3453 3454 def get(self, id, timeout=None): 3455 ''' 3456 Get reads one GroupRole by ID. 3457 ''' 3458 deadline = None if timeout is None else time.time() + timeout 3459 req = GroupRoleGetRequest() 3460 if self.parent.snapshot_datetime is not None: 3461 req.meta.CopyFrom(GetRequestMetadata()) 3462 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3463 3464 req.id = (id) 3465 tries = 0 3466 plumbing_response = None 3467 while True: 3468 t = None if deadline is None else deadline - time.time() 3469 try: 3470 plumbing_response = self.stub.Get( 3471 req, 3472 metadata=self.parent.get_metadata('GroupsRoles.Get', req), 3473 timeout=t) 3474 except Exception as e: 3475 if self.parent.shouldRetry(tries, e, deadline): 3476 tries += 1 3477 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3478 continue 3479 raise plumbing.convert_error_to_porcelain(e) from e 3480 break 3481 3482 resp = models.GroupRoleGetResponse() 3483 resp.group_role = plumbing.convert_group_role_to_porcelain( 3484 plumbing_response.group_role) 3485 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3486 plumbing_response.meta) 3487 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3488 plumbing_response.rate_limit) 3489 return resp 3490 3491 def delete(self, id, timeout=None): 3492 ''' 3493 Delete removes a GroupRole by ID. 3494 ''' 3495 deadline = None if timeout is None else time.time() + timeout 3496 req = GroupRoleDeleteRequest() 3497 3498 req.id = (id) 3499 tries = 0 3500 plumbing_response = None 3501 while True: 3502 t = None if deadline is None else deadline - time.time() 3503 try: 3504 plumbing_response = self.stub.Delete( 3505 req, 3506 metadata=self.parent.get_metadata('GroupsRoles.Delete', 3507 req), 3508 timeout=t) 3509 except Exception as e: 3510 if self.parent.shouldRetry(tries, e, deadline): 3511 tries += 1 3512 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3513 continue 3514 raise plumbing.convert_error_to_porcelain(e) from e 3515 break 3516 3517 resp = models.GroupRoleDeleteResponse() 3518 resp.group_role = plumbing.convert_group_role_to_porcelain( 3519 plumbing_response.group_role) 3520 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3521 plumbing_response.meta) 3522 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3523 plumbing_response.rate_limit) 3524 return resp 3525 3526 def list(self, filter, *args, timeout=None): 3527 ''' 3528 List gets a list of GroupRoles matching a given set of criteria. 3529 ''' 3530 deadline = None if timeout is None else time.time() + timeout 3531 req = GroupRoleListRequest() 3532 req.meta.CopyFrom(ListRequestMetadata()) 3533 if self.parent.page_limit > 0: 3534 req.meta.limit = self.parent.page_limit 3535 if self.parent.snapshot_datetime is not None: 3536 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3537 3538 req.filter = plumbing.quote_filter_args(filter, *args) 3539 3540 def generator(svc, req): 3541 tries = 0 3542 while True: 3543 t = None if deadline is None else deadline - time.time() 3544 try: 3545 plumbing_response = svc.stub.List( 3546 req, 3547 metadata=svc.parent.get_metadata( 3548 'GroupsRoles.List', req), 3549 timeout=t) 3550 except Exception as e: 3551 if self.parent.shouldRetry(tries, e, deadline): 3552 tries += 1 3553 time.sleep( 3554 self.parent.exponentialBackoff(tries, deadline)) 3555 continue 3556 raise plumbing.convert_error_to_porcelain(e) from e 3557 tries = 0 3558 for plumbing_item in plumbing_response.groups_roles: 3559 yield plumbing.convert_group_role_to_porcelain( 3560 plumbing_item) 3561 if plumbing_response.meta.next_cursor == '': 3562 break 3563 req.meta.cursor = plumbing_response.meta.next_cursor 3564 3565 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)
3419 def create(self, group_role, timeout=None): 3420 ''' 3421 Create registers a new GroupRole. 3422 ''' 3423 deadline = None if timeout is None else time.time() + timeout 3424 req = GroupRoleCreateRequest() 3425 3426 if group_role is not None: 3427 req.group_role.CopyFrom( 3428 plumbing.convert_group_role_to_plumbing(group_role)) 3429 tries = 0 3430 plumbing_response = None 3431 while True: 3432 t = None if deadline is None else deadline - time.time() 3433 try: 3434 plumbing_response = self.stub.Create( 3435 req, 3436 metadata=self.parent.get_metadata('GroupsRoles.Create', 3437 req), 3438 timeout=t) 3439 except Exception as e: 3440 if self.parent.shouldRetry(tries, e, deadline): 3441 tries += 1 3442 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3443 continue 3444 raise plumbing.convert_error_to_porcelain(e) from e 3445 break 3446 3447 resp = models.GroupRoleCreateResponse() 3448 resp.group_role = plumbing.convert_group_role_to_porcelain( 3449 plumbing_response.group_role) 3450 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3451 plumbing_response.rate_limit) 3452 return resp
Create registers a new GroupRole.
def
get(self, id, timeout=None)
3454 def get(self, id, timeout=None): 3455 ''' 3456 Get reads one GroupRole by ID. 3457 ''' 3458 deadline = None if timeout is None else time.time() + timeout 3459 req = GroupRoleGetRequest() 3460 if self.parent.snapshot_datetime is not None: 3461 req.meta.CopyFrom(GetRequestMetadata()) 3462 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3463 3464 req.id = (id) 3465 tries = 0 3466 plumbing_response = None 3467 while True: 3468 t = None if deadline is None else deadline - time.time() 3469 try: 3470 plumbing_response = self.stub.Get( 3471 req, 3472 metadata=self.parent.get_metadata('GroupsRoles.Get', req), 3473 timeout=t) 3474 except Exception as e: 3475 if self.parent.shouldRetry(tries, e, deadline): 3476 tries += 1 3477 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3478 continue 3479 raise plumbing.convert_error_to_porcelain(e) from e 3480 break 3481 3482 resp = models.GroupRoleGetResponse() 3483 resp.group_role = plumbing.convert_group_role_to_porcelain( 3484 plumbing_response.group_role) 3485 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3486 plumbing_response.meta) 3487 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3488 plumbing_response.rate_limit) 3489 return resp
Get reads one GroupRole by ID.
def
delete(self, id, timeout=None)
3491 def delete(self, id, timeout=None): 3492 ''' 3493 Delete removes a GroupRole by ID. 3494 ''' 3495 deadline = None if timeout is None else time.time() + timeout 3496 req = GroupRoleDeleteRequest() 3497 3498 req.id = (id) 3499 tries = 0 3500 plumbing_response = None 3501 while True: 3502 t = None if deadline is None else deadline - time.time() 3503 try: 3504 plumbing_response = self.stub.Delete( 3505 req, 3506 metadata=self.parent.get_metadata('GroupsRoles.Delete', 3507 req), 3508 timeout=t) 3509 except Exception as e: 3510 if self.parent.shouldRetry(tries, e, deadline): 3511 tries += 1 3512 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3513 continue 3514 raise plumbing.convert_error_to_porcelain(e) from e 3515 break 3516 3517 resp = models.GroupRoleDeleteResponse() 3518 resp.group_role = plumbing.convert_group_role_to_porcelain( 3519 plumbing_response.group_role) 3520 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3521 plumbing_response.meta) 3522 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3523 plumbing_response.rate_limit) 3524 return resp
Delete removes a GroupRole by ID.
def
list(self, filter, *args, timeout=None)
3526 def list(self, filter, *args, timeout=None): 3527 ''' 3528 List gets a list of GroupRoles matching a given set of criteria. 3529 ''' 3530 deadline = None if timeout is None else time.time() + timeout 3531 req = GroupRoleListRequest() 3532 req.meta.CopyFrom(ListRequestMetadata()) 3533 if self.parent.page_limit > 0: 3534 req.meta.limit = self.parent.page_limit 3535 if self.parent.snapshot_datetime is not None: 3536 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3537 3538 req.filter = plumbing.quote_filter_args(filter, *args) 3539 3540 def generator(svc, req): 3541 tries = 0 3542 while True: 3543 t = None if deadline is None else deadline - time.time() 3544 try: 3545 plumbing_response = svc.stub.List( 3546 req, 3547 metadata=svc.parent.get_metadata( 3548 'GroupsRoles.List', req), 3549 timeout=t) 3550 except Exception as e: 3551 if self.parent.shouldRetry(tries, e, deadline): 3552 tries += 1 3553 time.sleep( 3554 self.parent.exponentialBackoff(tries, deadline)) 3555 continue 3556 raise plumbing.convert_error_to_porcelain(e) from e 3557 tries = 0 3558 for plumbing_item in plumbing_response.groups_roles: 3559 yield plumbing.convert_group_role_to_porcelain( 3560 plumbing_item) 3561 if plumbing_response.meta.next_cursor == '': 3562 break 3563 req.meta.cursor = plumbing_response.meta.next_cursor 3564 3565 return generator(self, req)
List gets a list of GroupRoles matching a given set of criteria.
class
SnapshotGroupsRoles:
3568class SnapshotGroupsRoles: 3569 ''' 3570 SnapshotGroupsRoles exposes the read only methods of the GroupsRoles 3571 service for historical queries. 3572 ''' 3573 def __init__(self, groups_roles): 3574 self.groups_roles = groups_roles 3575 3576 def get(self, id, timeout=None): 3577 ''' 3578 Get reads one GroupRole by ID. 3579 ''' 3580 return self.groups_roles.get(id, timeout=timeout) 3581 3582 def list(self, filter, *args, timeout=None): 3583 ''' 3584 List gets a list of GroupRoles matching a given set of criteria. 3585 ''' 3586 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)
3576 def get(self, id, timeout=None): 3577 ''' 3578 Get reads one GroupRole by ID. 3579 ''' 3580 return self.groups_roles.get(id, timeout=timeout)
Get reads one GroupRole by ID.
def
list(self, filter, *args, timeout=None)
3582 def list(self, filter, *args, timeout=None): 3583 ''' 3584 List gets a list of GroupRoles matching a given set of criteria. 3585 ''' 3586 return self.groups_roles.list(filter, *args, timeout=timeout)
List gets a list of GroupRoles matching a given set of criteria.
class
GroupsRolesHistory:
3589class GroupsRolesHistory: 3590 ''' 3591 GroupsRolesHistory records all changes to the state of a GroupRole. 3592 See `strongdm.models.GroupRoleHistory`. 3593 ''' 3594 def __init__(self, channel, client): 3595 self.parent = client 3596 self.stub = GroupsRolesHistoryStub(channel) 3597 3598 def list(self, filter, *args, timeout=None): 3599 ''' 3600 List gets a list of GroupRoleHistory records matching a given set of criteria. 3601 ''' 3602 deadline = None if timeout is None else time.time() + timeout 3603 req = GroupRoleHistoryListRequest() 3604 req.meta.CopyFrom(ListRequestMetadata()) 3605 if self.parent.page_limit > 0: 3606 req.meta.limit = self.parent.page_limit 3607 if self.parent.snapshot_datetime is not None: 3608 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3609 3610 req.filter = plumbing.quote_filter_args(filter, *args) 3611 3612 def generator(svc, req): 3613 tries = 0 3614 while True: 3615 t = None if deadline is None else deadline - time.time() 3616 try: 3617 plumbing_response = svc.stub.List( 3618 req, 3619 metadata=svc.parent.get_metadata( 3620 'GroupsRolesHistory.List', req), 3621 timeout=t) 3622 except Exception as e: 3623 if self.parent.shouldRetry(tries, e, deadline): 3624 tries += 1 3625 time.sleep( 3626 self.parent.exponentialBackoff(tries, deadline)) 3627 continue 3628 raise plumbing.convert_error_to_porcelain(e) from e 3629 tries = 0 3630 for plumbing_item in plumbing_response.history: 3631 yield plumbing.convert_group_role_history_to_porcelain( 3632 plumbing_item) 3633 if plumbing_response.meta.next_cursor == '': 3634 break 3635 req.meta.cursor = plumbing_response.meta.next_cursor 3636 3637 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)
3598 def list(self, filter, *args, timeout=None): 3599 ''' 3600 List gets a list of GroupRoleHistory records matching a given set of criteria. 3601 ''' 3602 deadline = None if timeout is None else time.time() + timeout 3603 req = GroupRoleHistoryListRequest() 3604 req.meta.CopyFrom(ListRequestMetadata()) 3605 if self.parent.page_limit > 0: 3606 req.meta.limit = self.parent.page_limit 3607 if self.parent.snapshot_datetime is not None: 3608 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3609 3610 req.filter = plumbing.quote_filter_args(filter, *args) 3611 3612 def generator(svc, req): 3613 tries = 0 3614 while True: 3615 t = None if deadline is None else deadline - time.time() 3616 try: 3617 plumbing_response = svc.stub.List( 3618 req, 3619 metadata=svc.parent.get_metadata( 3620 'GroupsRolesHistory.List', req), 3621 timeout=t) 3622 except Exception as e: 3623 if self.parent.shouldRetry(tries, e, deadline): 3624 tries += 1 3625 time.sleep( 3626 self.parent.exponentialBackoff(tries, deadline)) 3627 continue 3628 raise plumbing.convert_error_to_porcelain(e) from e 3629 tries = 0 3630 for plumbing_item in plumbing_response.history: 3631 yield plumbing.convert_group_role_history_to_porcelain( 3632 plumbing_item) 3633 if plumbing_response.meta.next_cursor == '': 3634 break 3635 req.meta.cursor = plumbing_response.meta.next_cursor 3636 3637 return generator(self, req)
List gets a list of GroupRoleHistory records matching a given set of criteria.
class
HealthChecks:
3640class HealthChecks: 3641 ''' 3642 HealthChecks lists the last healthcheck between each node and resource. 3643 Note the unconventional capitalization here is to prevent having a collision with GRPC 3644 See `strongdm.models.Healthcheck`. 3645 ''' 3646 def __init__(self, channel, client): 3647 self.parent = client 3648 self.stub = HealthChecksStub(channel) 3649 3650 def list(self, filter, *args, timeout=None): 3651 ''' 3652 List gets a list of Healthchecks matching a given set of criteria. 3653 ''' 3654 deadline = None if timeout is None else time.time() + timeout 3655 req = HealthcheckListRequest() 3656 req.meta.CopyFrom(ListRequestMetadata()) 3657 if self.parent.page_limit > 0: 3658 req.meta.limit = self.parent.page_limit 3659 if self.parent.snapshot_datetime is not None: 3660 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3661 3662 req.filter = plumbing.quote_filter_args(filter, *args) 3663 3664 def generator(svc, req): 3665 tries = 0 3666 while True: 3667 t = None if deadline is None else deadline - time.time() 3668 try: 3669 plumbing_response = svc.stub.List( 3670 req, 3671 metadata=svc.parent.get_metadata( 3672 'HealthChecks.List', req), 3673 timeout=t) 3674 except Exception as e: 3675 if self.parent.shouldRetry(tries, e, deadline): 3676 tries += 1 3677 time.sleep( 3678 self.parent.exponentialBackoff(tries, deadline)) 3679 continue 3680 raise plumbing.convert_error_to_porcelain(e) from e 3681 tries = 0 3682 for plumbing_item in plumbing_response.healthchecks: 3683 yield plumbing.convert_healthcheck_to_porcelain( 3684 plumbing_item) 3685 if plumbing_response.meta.next_cursor == '': 3686 break 3687 req.meta.cursor = plumbing_response.meta.next_cursor 3688 3689 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)
3650 def list(self, filter, *args, timeout=None): 3651 ''' 3652 List gets a list of Healthchecks matching a given set of criteria. 3653 ''' 3654 deadline = None if timeout is None else time.time() + timeout 3655 req = HealthcheckListRequest() 3656 req.meta.CopyFrom(ListRequestMetadata()) 3657 if self.parent.page_limit > 0: 3658 req.meta.limit = self.parent.page_limit 3659 if self.parent.snapshot_datetime is not None: 3660 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3661 3662 req.filter = plumbing.quote_filter_args(filter, *args) 3663 3664 def generator(svc, req): 3665 tries = 0 3666 while True: 3667 t = None if deadline is None else deadline - time.time() 3668 try: 3669 plumbing_response = svc.stub.List( 3670 req, 3671 metadata=svc.parent.get_metadata( 3672 'HealthChecks.List', req), 3673 timeout=t) 3674 except Exception as e: 3675 if self.parent.shouldRetry(tries, e, deadline): 3676 tries += 1 3677 time.sleep( 3678 self.parent.exponentialBackoff(tries, deadline)) 3679 continue 3680 raise plumbing.convert_error_to_porcelain(e) from e 3681 tries = 0 3682 for plumbing_item in plumbing_response.healthchecks: 3683 yield plumbing.convert_healthcheck_to_porcelain( 3684 plumbing_item) 3685 if plumbing_response.meta.next_cursor == '': 3686 break 3687 req.meta.cursor = plumbing_response.meta.next_cursor 3688 3689 return generator(self, req)
List gets a list of Healthchecks matching a given set of criteria.
class
IdentityAliases:
3692class IdentityAliases: 3693 ''' 3694 IdentityAliases assign an alias to an account within an IdentitySet. 3695 The alias is used as the username when connecting to a identity supported resource. 3696 See `strongdm.models.IdentityAlias`. 3697 ''' 3698 def __init__(self, channel, client): 3699 self.parent = client 3700 self.stub = IdentityAliasesStub(channel) 3701 3702 def create(self, identity_alias, timeout=None): 3703 ''' 3704 Create registers a new IdentityAlias. 3705 ''' 3706 deadline = None if timeout is None else time.time() + timeout 3707 req = IdentityAliasCreateRequest() 3708 3709 if identity_alias is not None: 3710 req.identity_alias.CopyFrom( 3711 plumbing.convert_identity_alias_to_plumbing(identity_alias)) 3712 tries = 0 3713 plumbing_response = None 3714 while True: 3715 t = None if deadline is None else deadline - time.time() 3716 try: 3717 plumbing_response = self.stub.Create( 3718 req, 3719 metadata=self.parent.get_metadata('IdentityAliases.Create', 3720 req), 3721 timeout=t) 3722 except Exception as e: 3723 if self.parent.shouldRetry(tries, e, deadline): 3724 tries += 1 3725 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3726 continue 3727 raise plumbing.convert_error_to_porcelain(e) from e 3728 break 3729 3730 resp = models.IdentityAliasCreateResponse() 3731 resp.identity_alias = plumbing.convert_identity_alias_to_porcelain( 3732 plumbing_response.identity_alias) 3733 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 3734 plumbing_response.meta) 3735 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3736 plumbing_response.rate_limit) 3737 return resp 3738 3739 def get(self, id, timeout=None): 3740 ''' 3741 Get reads one IdentityAlias by ID. 3742 ''' 3743 deadline = None if timeout is None else time.time() + timeout 3744 req = IdentityAliasGetRequest() 3745 if self.parent.snapshot_datetime is not None: 3746 req.meta.CopyFrom(GetRequestMetadata()) 3747 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3748 3749 req.id = (id) 3750 tries = 0 3751 plumbing_response = None 3752 while True: 3753 t = None if deadline is None else deadline - time.time() 3754 try: 3755 plumbing_response = self.stub.Get( 3756 req, 3757 metadata=self.parent.get_metadata('IdentityAliases.Get', 3758 req), 3759 timeout=t) 3760 except Exception as e: 3761 if self.parent.shouldRetry(tries, e, deadline): 3762 tries += 1 3763 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3764 continue 3765 raise plumbing.convert_error_to_porcelain(e) from e 3766 break 3767 3768 resp = models.IdentityAliasGetResponse() 3769 resp.identity_alias = plumbing.convert_identity_alias_to_porcelain( 3770 plumbing_response.identity_alias) 3771 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3772 plumbing_response.meta) 3773 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3774 plumbing_response.rate_limit) 3775 return resp 3776 3777 def update(self, identity_alias, timeout=None): 3778 ''' 3779 Update replaces all the fields of a IdentityAlias by ID. 3780 ''' 3781 deadline = None if timeout is None else time.time() + timeout 3782 req = IdentityAliasUpdateRequest() 3783 3784 if identity_alias is not None: 3785 req.identity_alias.CopyFrom( 3786 plumbing.convert_identity_alias_to_plumbing(identity_alias)) 3787 tries = 0 3788 plumbing_response = None 3789 while True: 3790 t = None if deadline is None else deadline - time.time() 3791 try: 3792 plumbing_response = self.stub.Update( 3793 req, 3794 metadata=self.parent.get_metadata('IdentityAliases.Update', 3795 req), 3796 timeout=t) 3797 except Exception as e: 3798 if self.parent.shouldRetry(tries, e, deadline): 3799 tries += 1 3800 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3801 continue 3802 raise plumbing.convert_error_to_porcelain(e) from e 3803 break 3804 3805 resp = models.IdentityAliasUpdateResponse() 3806 resp.identity_alias = plumbing.convert_identity_alias_to_porcelain( 3807 plumbing_response.identity_alias) 3808 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 3809 plumbing_response.meta) 3810 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3811 plumbing_response.rate_limit) 3812 return resp 3813 3814 def delete(self, id, timeout=None): 3815 ''' 3816 Delete removes a IdentityAlias by ID. 3817 ''' 3818 deadline = None if timeout is None else time.time() + timeout 3819 req = IdentityAliasDeleteRequest() 3820 3821 req.id = (id) 3822 tries = 0 3823 plumbing_response = None 3824 while True: 3825 t = None if deadline is None else deadline - time.time() 3826 try: 3827 plumbing_response = self.stub.Delete( 3828 req, 3829 metadata=self.parent.get_metadata('IdentityAliases.Delete', 3830 req), 3831 timeout=t) 3832 except Exception as e: 3833 if self.parent.shouldRetry(tries, e, deadline): 3834 tries += 1 3835 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3836 continue 3837 raise plumbing.convert_error_to_porcelain(e) from e 3838 break 3839 3840 resp = models.IdentityAliasDeleteResponse() 3841 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3842 plumbing_response.meta) 3843 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3844 plumbing_response.rate_limit) 3845 return resp 3846 3847 def list(self, filter, *args, timeout=None): 3848 ''' 3849 List gets a list of IdentityAliases matching a given set of criteria. 3850 ''' 3851 deadline = None if timeout is None else time.time() + timeout 3852 req = IdentityAliasListRequest() 3853 req.meta.CopyFrom(ListRequestMetadata()) 3854 if self.parent.page_limit > 0: 3855 req.meta.limit = self.parent.page_limit 3856 if self.parent.snapshot_datetime is not None: 3857 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3858 3859 req.filter = plumbing.quote_filter_args(filter, *args) 3860 3861 def generator(svc, req): 3862 tries = 0 3863 while True: 3864 t = None if deadline is None else deadline - time.time() 3865 try: 3866 plumbing_response = svc.stub.List( 3867 req, 3868 metadata=svc.parent.get_metadata( 3869 'IdentityAliases.List', req), 3870 timeout=t) 3871 except Exception as e: 3872 if self.parent.shouldRetry(tries, e, deadline): 3873 tries += 1 3874 time.sleep( 3875 self.parent.exponentialBackoff(tries, deadline)) 3876 continue 3877 raise plumbing.convert_error_to_porcelain(e) from e 3878 tries = 0 3879 for plumbing_item in plumbing_response.identity_aliases: 3880 yield plumbing.convert_identity_alias_to_porcelain( 3881 plumbing_item) 3882 if plumbing_response.meta.next_cursor == '': 3883 break 3884 req.meta.cursor = plumbing_response.meta.next_cursor 3885 3886 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)
3702 def create(self, identity_alias, timeout=None): 3703 ''' 3704 Create registers a new IdentityAlias. 3705 ''' 3706 deadline = None if timeout is None else time.time() + timeout 3707 req = IdentityAliasCreateRequest() 3708 3709 if identity_alias is not None: 3710 req.identity_alias.CopyFrom( 3711 plumbing.convert_identity_alias_to_plumbing(identity_alias)) 3712 tries = 0 3713 plumbing_response = None 3714 while True: 3715 t = None if deadline is None else deadline - time.time() 3716 try: 3717 plumbing_response = self.stub.Create( 3718 req, 3719 metadata=self.parent.get_metadata('IdentityAliases.Create', 3720 req), 3721 timeout=t) 3722 except Exception as e: 3723 if self.parent.shouldRetry(tries, e, deadline): 3724 tries += 1 3725 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3726 continue 3727 raise plumbing.convert_error_to_porcelain(e) from e 3728 break 3729 3730 resp = models.IdentityAliasCreateResponse() 3731 resp.identity_alias = plumbing.convert_identity_alias_to_porcelain( 3732 plumbing_response.identity_alias) 3733 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 3734 plumbing_response.meta) 3735 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3736 plumbing_response.rate_limit) 3737 return resp
Create registers a new IdentityAlias.
def
get(self, id, timeout=None)
3739 def get(self, id, timeout=None): 3740 ''' 3741 Get reads one IdentityAlias by ID. 3742 ''' 3743 deadline = None if timeout is None else time.time() + timeout 3744 req = IdentityAliasGetRequest() 3745 if self.parent.snapshot_datetime is not None: 3746 req.meta.CopyFrom(GetRequestMetadata()) 3747 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3748 3749 req.id = (id) 3750 tries = 0 3751 plumbing_response = None 3752 while True: 3753 t = None if deadline is None else deadline - time.time() 3754 try: 3755 plumbing_response = self.stub.Get( 3756 req, 3757 metadata=self.parent.get_metadata('IdentityAliases.Get', 3758 req), 3759 timeout=t) 3760 except Exception as e: 3761 if self.parent.shouldRetry(tries, e, deadline): 3762 tries += 1 3763 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3764 continue 3765 raise plumbing.convert_error_to_porcelain(e) from e 3766 break 3767 3768 resp = models.IdentityAliasGetResponse() 3769 resp.identity_alias = plumbing.convert_identity_alias_to_porcelain( 3770 plumbing_response.identity_alias) 3771 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3772 plumbing_response.meta) 3773 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3774 plumbing_response.rate_limit) 3775 return resp
Get reads one IdentityAlias by ID.
def
update(self, identity_alias, timeout=None)
3777 def update(self, identity_alias, timeout=None): 3778 ''' 3779 Update replaces all the fields of a IdentityAlias by ID. 3780 ''' 3781 deadline = None if timeout is None else time.time() + timeout 3782 req = IdentityAliasUpdateRequest() 3783 3784 if identity_alias is not None: 3785 req.identity_alias.CopyFrom( 3786 plumbing.convert_identity_alias_to_plumbing(identity_alias)) 3787 tries = 0 3788 plumbing_response = None 3789 while True: 3790 t = None if deadline is None else deadline - time.time() 3791 try: 3792 plumbing_response = self.stub.Update( 3793 req, 3794 metadata=self.parent.get_metadata('IdentityAliases.Update', 3795 req), 3796 timeout=t) 3797 except Exception as e: 3798 if self.parent.shouldRetry(tries, e, deadline): 3799 tries += 1 3800 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3801 continue 3802 raise plumbing.convert_error_to_porcelain(e) from e 3803 break 3804 3805 resp = models.IdentityAliasUpdateResponse() 3806 resp.identity_alias = plumbing.convert_identity_alias_to_porcelain( 3807 plumbing_response.identity_alias) 3808 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 3809 plumbing_response.meta) 3810 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3811 plumbing_response.rate_limit) 3812 return resp
Update replaces all the fields of a IdentityAlias by ID.
def
delete(self, id, timeout=None)
3814 def delete(self, id, timeout=None): 3815 ''' 3816 Delete removes a IdentityAlias by ID. 3817 ''' 3818 deadline = None if timeout is None else time.time() + timeout 3819 req = IdentityAliasDeleteRequest() 3820 3821 req.id = (id) 3822 tries = 0 3823 plumbing_response = None 3824 while True: 3825 t = None if deadline is None else deadline - time.time() 3826 try: 3827 plumbing_response = self.stub.Delete( 3828 req, 3829 metadata=self.parent.get_metadata('IdentityAliases.Delete', 3830 req), 3831 timeout=t) 3832 except Exception as e: 3833 if self.parent.shouldRetry(tries, e, deadline): 3834 tries += 1 3835 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3836 continue 3837 raise plumbing.convert_error_to_porcelain(e) from e 3838 break 3839 3840 resp = models.IdentityAliasDeleteResponse() 3841 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3842 plumbing_response.meta) 3843 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3844 plumbing_response.rate_limit) 3845 return resp
Delete removes a IdentityAlias by ID.
def
list(self, filter, *args, timeout=None)
3847 def list(self, filter, *args, timeout=None): 3848 ''' 3849 List gets a list of IdentityAliases matching a given set of criteria. 3850 ''' 3851 deadline = None if timeout is None else time.time() + timeout 3852 req = IdentityAliasListRequest() 3853 req.meta.CopyFrom(ListRequestMetadata()) 3854 if self.parent.page_limit > 0: 3855 req.meta.limit = self.parent.page_limit 3856 if self.parent.snapshot_datetime is not None: 3857 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3858 3859 req.filter = plumbing.quote_filter_args(filter, *args) 3860 3861 def generator(svc, req): 3862 tries = 0 3863 while True: 3864 t = None if deadline is None else deadline - time.time() 3865 try: 3866 plumbing_response = svc.stub.List( 3867 req, 3868 metadata=svc.parent.get_metadata( 3869 'IdentityAliases.List', req), 3870 timeout=t) 3871 except Exception as e: 3872 if self.parent.shouldRetry(tries, e, deadline): 3873 tries += 1 3874 time.sleep( 3875 self.parent.exponentialBackoff(tries, deadline)) 3876 continue 3877 raise plumbing.convert_error_to_porcelain(e) from e 3878 tries = 0 3879 for plumbing_item in plumbing_response.identity_aliases: 3880 yield plumbing.convert_identity_alias_to_porcelain( 3881 plumbing_item) 3882 if plumbing_response.meta.next_cursor == '': 3883 break 3884 req.meta.cursor = plumbing_response.meta.next_cursor 3885 3886 return generator(self, req)
List gets a list of IdentityAliases matching a given set of criteria.
class
SnapshotIdentityAliases:
3889class SnapshotIdentityAliases: 3890 ''' 3891 SnapshotIdentityAliases exposes the read only methods of the IdentityAliases 3892 service for historical queries. 3893 ''' 3894 def __init__(self, identity_aliases): 3895 self.identity_aliases = identity_aliases 3896 3897 def get(self, id, timeout=None): 3898 ''' 3899 Get reads one IdentityAlias by ID. 3900 ''' 3901 return self.identity_aliases.get(id, timeout=timeout) 3902 3903 def list(self, filter, *args, timeout=None): 3904 ''' 3905 List gets a list of IdentityAliases matching a given set of criteria. 3906 ''' 3907 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)
3897 def get(self, id, timeout=None): 3898 ''' 3899 Get reads one IdentityAlias by ID. 3900 ''' 3901 return self.identity_aliases.get(id, timeout=timeout)
Get reads one IdentityAlias by ID.
def
list(self, filter, *args, timeout=None)
3903 def list(self, filter, *args, timeout=None): 3904 ''' 3905 List gets a list of IdentityAliases matching a given set of criteria. 3906 ''' 3907 return self.identity_aliases.list(filter, *args, timeout=timeout)
List gets a list of IdentityAliases matching a given set of criteria.
class
IdentityAliasesHistory:
3910class IdentityAliasesHistory: 3911 ''' 3912 IdentityAliasesHistory records all changes to the state of a IdentityAlias. 3913 See `strongdm.models.IdentityAliasHistory`. 3914 ''' 3915 def __init__(self, channel, client): 3916 self.parent = client 3917 self.stub = IdentityAliasesHistoryStub(channel) 3918 3919 def list(self, filter, *args, timeout=None): 3920 ''' 3921 List gets a list of IdentityAliasHistory records matching a given set of criteria. 3922 ''' 3923 deadline = None if timeout is None else time.time() + timeout 3924 req = IdentityAliasHistoryListRequest() 3925 req.meta.CopyFrom(ListRequestMetadata()) 3926 if self.parent.page_limit > 0: 3927 req.meta.limit = self.parent.page_limit 3928 if self.parent.snapshot_datetime is not None: 3929 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3930 3931 req.filter = plumbing.quote_filter_args(filter, *args) 3932 3933 def generator(svc, req): 3934 tries = 0 3935 while True: 3936 t = None if deadline is None else deadline - time.time() 3937 try: 3938 plumbing_response = svc.stub.List( 3939 req, 3940 metadata=svc.parent.get_metadata( 3941 'IdentityAliasesHistory.List', req), 3942 timeout=t) 3943 except Exception as e: 3944 if self.parent.shouldRetry(tries, e, deadline): 3945 tries += 1 3946 time.sleep( 3947 self.parent.exponentialBackoff(tries, deadline)) 3948 continue 3949 raise plumbing.convert_error_to_porcelain(e) from e 3950 tries = 0 3951 for plumbing_item in plumbing_response.history: 3952 yield plumbing.convert_identity_alias_history_to_porcelain( 3953 plumbing_item) 3954 if plumbing_response.meta.next_cursor == '': 3955 break 3956 req.meta.cursor = plumbing_response.meta.next_cursor 3957 3958 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)
3919 def list(self, filter, *args, timeout=None): 3920 ''' 3921 List gets a list of IdentityAliasHistory records matching a given set of criteria. 3922 ''' 3923 deadline = None if timeout is None else time.time() + timeout 3924 req = IdentityAliasHistoryListRequest() 3925 req.meta.CopyFrom(ListRequestMetadata()) 3926 if self.parent.page_limit > 0: 3927 req.meta.limit = self.parent.page_limit 3928 if self.parent.snapshot_datetime is not None: 3929 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3930 3931 req.filter = plumbing.quote_filter_args(filter, *args) 3932 3933 def generator(svc, req): 3934 tries = 0 3935 while True: 3936 t = None if deadline is None else deadline - time.time() 3937 try: 3938 plumbing_response = svc.stub.List( 3939 req, 3940 metadata=svc.parent.get_metadata( 3941 'IdentityAliasesHistory.List', req), 3942 timeout=t) 3943 except Exception as e: 3944 if self.parent.shouldRetry(tries, e, deadline): 3945 tries += 1 3946 time.sleep( 3947 self.parent.exponentialBackoff(tries, deadline)) 3948 continue 3949 raise plumbing.convert_error_to_porcelain(e) from e 3950 tries = 0 3951 for plumbing_item in plumbing_response.history: 3952 yield plumbing.convert_identity_alias_history_to_porcelain( 3953 plumbing_item) 3954 if plumbing_response.meta.next_cursor == '': 3955 break 3956 req.meta.cursor = plumbing_response.meta.next_cursor 3957 3958 return generator(self, req)
List gets a list of IdentityAliasHistory records matching a given set of criteria.
class
IdentitySets:
3961class IdentitySets: 3962 ''' 3963 A IdentitySet is a named grouping of Identity Aliases for Accounts. 3964 An Account's relationship to a IdentitySet is defined via IdentityAlias objects. 3965 See `strongdm.models.IdentitySet`. 3966 ''' 3967 def __init__(self, channel, client): 3968 self.parent = client 3969 self.stub = IdentitySetsStub(channel) 3970 3971 def create(self, identity_set, timeout=None): 3972 ''' 3973 Create registers a new IdentitySet. 3974 ''' 3975 deadline = None if timeout is None else time.time() + timeout 3976 req = IdentitySetCreateRequest() 3977 3978 if identity_set is not None: 3979 req.identity_set.CopyFrom( 3980 plumbing.convert_identity_set_to_plumbing(identity_set)) 3981 tries = 0 3982 plumbing_response = None 3983 while True: 3984 t = None if deadline is None else deadline - time.time() 3985 try: 3986 plumbing_response = self.stub.Create( 3987 req, 3988 metadata=self.parent.get_metadata('IdentitySets.Create', 3989 req), 3990 timeout=t) 3991 except Exception as e: 3992 if self.parent.shouldRetry(tries, e, deadline): 3993 tries += 1 3994 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3995 continue 3996 raise plumbing.convert_error_to_porcelain(e) from e 3997 break 3998 3999 resp = models.IdentitySetCreateResponse() 4000 resp.identity_set = plumbing.convert_identity_set_to_porcelain( 4001 plumbing_response.identity_set) 4002 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4003 plumbing_response.meta) 4004 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4005 plumbing_response.rate_limit) 4006 return resp 4007 4008 def get(self, id, timeout=None): 4009 ''' 4010 Get reads one IdentitySet by ID. 4011 ''' 4012 deadline = None if timeout is None else time.time() + timeout 4013 req = IdentitySetGetRequest() 4014 if self.parent.snapshot_datetime is not None: 4015 req.meta.CopyFrom(GetRequestMetadata()) 4016 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4017 4018 req.id = (id) 4019 tries = 0 4020 plumbing_response = None 4021 while True: 4022 t = None if deadline is None else deadline - time.time() 4023 try: 4024 plumbing_response = self.stub.Get( 4025 req, 4026 metadata=self.parent.get_metadata('IdentitySets.Get', req), 4027 timeout=t) 4028 except Exception as e: 4029 if self.parent.shouldRetry(tries, e, deadline): 4030 tries += 1 4031 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4032 continue 4033 raise plumbing.convert_error_to_porcelain(e) from e 4034 break 4035 4036 resp = models.IdentitySetGetResponse() 4037 resp.identity_set = plumbing.convert_identity_set_to_porcelain( 4038 plumbing_response.identity_set) 4039 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4040 plumbing_response.meta) 4041 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4042 plumbing_response.rate_limit) 4043 return resp 4044 4045 def update(self, identity_set, timeout=None): 4046 ''' 4047 Update replaces all the fields of a IdentitySet by ID. 4048 ''' 4049 deadline = None if timeout is None else time.time() + timeout 4050 req = IdentitySetUpdateRequest() 4051 4052 if identity_set is not None: 4053 req.identity_set.CopyFrom( 4054 plumbing.convert_identity_set_to_plumbing(identity_set)) 4055 tries = 0 4056 plumbing_response = None 4057 while True: 4058 t = None if deadline is None else deadline - time.time() 4059 try: 4060 plumbing_response = self.stub.Update( 4061 req, 4062 metadata=self.parent.get_metadata('IdentitySets.Update', 4063 req), 4064 timeout=t) 4065 except Exception as e: 4066 if self.parent.shouldRetry(tries, e, deadline): 4067 tries += 1 4068 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4069 continue 4070 raise plumbing.convert_error_to_porcelain(e) from e 4071 break 4072 4073 resp = models.IdentitySetUpdateResponse() 4074 resp.identity_set = plumbing.convert_identity_set_to_porcelain( 4075 plumbing_response.identity_set) 4076 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 4077 plumbing_response.meta) 4078 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4079 plumbing_response.rate_limit) 4080 return resp 4081 4082 def delete(self, id, timeout=None): 4083 ''' 4084 Delete removes a IdentitySet by ID. 4085 ''' 4086 deadline = None if timeout is None else time.time() + timeout 4087 req = IdentitySetDeleteRequest() 4088 4089 req.id = (id) 4090 tries = 0 4091 plumbing_response = None 4092 while True: 4093 t = None if deadline is None else deadline - time.time() 4094 try: 4095 plumbing_response = self.stub.Delete( 4096 req, 4097 metadata=self.parent.get_metadata('IdentitySets.Delete', 4098 req), 4099 timeout=t) 4100 except Exception as e: 4101 if self.parent.shouldRetry(tries, e, deadline): 4102 tries += 1 4103 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4104 continue 4105 raise plumbing.convert_error_to_porcelain(e) from e 4106 break 4107 4108 resp = models.IdentitySetDeleteResponse() 4109 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 4110 plumbing_response.meta) 4111 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4112 plumbing_response.rate_limit) 4113 return resp 4114 4115 def list(self, filter, *args, timeout=None): 4116 ''' 4117 List gets a list of IdentitySets matching a given set of criteria. 4118 ''' 4119 deadline = None if timeout is None else time.time() + timeout 4120 req = IdentitySetListRequest() 4121 req.meta.CopyFrom(ListRequestMetadata()) 4122 if self.parent.page_limit > 0: 4123 req.meta.limit = self.parent.page_limit 4124 if self.parent.snapshot_datetime is not None: 4125 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4126 4127 req.filter = plumbing.quote_filter_args(filter, *args) 4128 4129 def generator(svc, req): 4130 tries = 0 4131 while True: 4132 t = None if deadline is None else deadline - time.time() 4133 try: 4134 plumbing_response = svc.stub.List( 4135 req, 4136 metadata=svc.parent.get_metadata( 4137 'IdentitySets.List', req), 4138 timeout=t) 4139 except Exception as e: 4140 if self.parent.shouldRetry(tries, e, deadline): 4141 tries += 1 4142 time.sleep( 4143 self.parent.exponentialBackoff(tries, deadline)) 4144 continue 4145 raise plumbing.convert_error_to_porcelain(e) from e 4146 tries = 0 4147 for plumbing_item in plumbing_response.identity_sets: 4148 yield plumbing.convert_identity_set_to_porcelain( 4149 plumbing_item) 4150 if plumbing_response.meta.next_cursor == '': 4151 break 4152 req.meta.cursor = plumbing_response.meta.next_cursor 4153 4154 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)
3971 def create(self, identity_set, timeout=None): 3972 ''' 3973 Create registers a new IdentitySet. 3974 ''' 3975 deadline = None if timeout is None else time.time() + timeout 3976 req = IdentitySetCreateRequest() 3977 3978 if identity_set is not None: 3979 req.identity_set.CopyFrom( 3980 plumbing.convert_identity_set_to_plumbing(identity_set)) 3981 tries = 0 3982 plumbing_response = None 3983 while True: 3984 t = None if deadline is None else deadline - time.time() 3985 try: 3986 plumbing_response = self.stub.Create( 3987 req, 3988 metadata=self.parent.get_metadata('IdentitySets.Create', 3989 req), 3990 timeout=t) 3991 except Exception as e: 3992 if self.parent.shouldRetry(tries, e, deadline): 3993 tries += 1 3994 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3995 continue 3996 raise plumbing.convert_error_to_porcelain(e) from e 3997 break 3998 3999 resp = models.IdentitySetCreateResponse() 4000 resp.identity_set = plumbing.convert_identity_set_to_porcelain( 4001 plumbing_response.identity_set) 4002 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4003 plumbing_response.meta) 4004 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4005 plumbing_response.rate_limit) 4006 return resp
Create registers a new IdentitySet.
def
get(self, id, timeout=None)
4008 def get(self, id, timeout=None): 4009 ''' 4010 Get reads one IdentitySet by ID. 4011 ''' 4012 deadline = None if timeout is None else time.time() + timeout 4013 req = IdentitySetGetRequest() 4014 if self.parent.snapshot_datetime is not None: 4015 req.meta.CopyFrom(GetRequestMetadata()) 4016 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4017 4018 req.id = (id) 4019 tries = 0 4020 plumbing_response = None 4021 while True: 4022 t = None if deadline is None else deadline - time.time() 4023 try: 4024 plumbing_response = self.stub.Get( 4025 req, 4026 metadata=self.parent.get_metadata('IdentitySets.Get', req), 4027 timeout=t) 4028 except Exception as e: 4029 if self.parent.shouldRetry(tries, e, deadline): 4030 tries += 1 4031 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4032 continue 4033 raise plumbing.convert_error_to_porcelain(e) from e 4034 break 4035 4036 resp = models.IdentitySetGetResponse() 4037 resp.identity_set = plumbing.convert_identity_set_to_porcelain( 4038 plumbing_response.identity_set) 4039 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4040 plumbing_response.meta) 4041 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4042 plumbing_response.rate_limit) 4043 return resp
Get reads one IdentitySet by ID.
def
update(self, identity_set, timeout=None)
4045 def update(self, identity_set, timeout=None): 4046 ''' 4047 Update replaces all the fields of a IdentitySet by ID. 4048 ''' 4049 deadline = None if timeout is None else time.time() + timeout 4050 req = IdentitySetUpdateRequest() 4051 4052 if identity_set is not None: 4053 req.identity_set.CopyFrom( 4054 plumbing.convert_identity_set_to_plumbing(identity_set)) 4055 tries = 0 4056 plumbing_response = None 4057 while True: 4058 t = None if deadline is None else deadline - time.time() 4059 try: 4060 plumbing_response = self.stub.Update( 4061 req, 4062 metadata=self.parent.get_metadata('IdentitySets.Update', 4063 req), 4064 timeout=t) 4065 except Exception as e: 4066 if self.parent.shouldRetry(tries, e, deadline): 4067 tries += 1 4068 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4069 continue 4070 raise plumbing.convert_error_to_porcelain(e) from e 4071 break 4072 4073 resp = models.IdentitySetUpdateResponse() 4074 resp.identity_set = plumbing.convert_identity_set_to_porcelain( 4075 plumbing_response.identity_set) 4076 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 4077 plumbing_response.meta) 4078 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4079 plumbing_response.rate_limit) 4080 return resp
Update replaces all the fields of a IdentitySet by ID.
def
delete(self, id, timeout=None)
4082 def delete(self, id, timeout=None): 4083 ''' 4084 Delete removes a IdentitySet by ID. 4085 ''' 4086 deadline = None if timeout is None else time.time() + timeout 4087 req = IdentitySetDeleteRequest() 4088 4089 req.id = (id) 4090 tries = 0 4091 plumbing_response = None 4092 while True: 4093 t = None if deadline is None else deadline - time.time() 4094 try: 4095 plumbing_response = self.stub.Delete( 4096 req, 4097 metadata=self.parent.get_metadata('IdentitySets.Delete', 4098 req), 4099 timeout=t) 4100 except Exception as e: 4101 if self.parent.shouldRetry(tries, e, deadline): 4102 tries += 1 4103 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4104 continue 4105 raise plumbing.convert_error_to_porcelain(e) from e 4106 break 4107 4108 resp = models.IdentitySetDeleteResponse() 4109 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 4110 plumbing_response.meta) 4111 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4112 plumbing_response.rate_limit) 4113 return resp
Delete removes a IdentitySet by ID.
def
list(self, filter, *args, timeout=None)
4115 def list(self, filter, *args, timeout=None): 4116 ''' 4117 List gets a list of IdentitySets matching a given set of criteria. 4118 ''' 4119 deadline = None if timeout is None else time.time() + timeout 4120 req = IdentitySetListRequest() 4121 req.meta.CopyFrom(ListRequestMetadata()) 4122 if self.parent.page_limit > 0: 4123 req.meta.limit = self.parent.page_limit 4124 if self.parent.snapshot_datetime is not None: 4125 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4126 4127 req.filter = plumbing.quote_filter_args(filter, *args) 4128 4129 def generator(svc, req): 4130 tries = 0 4131 while True: 4132 t = None if deadline is None else deadline - time.time() 4133 try: 4134 plumbing_response = svc.stub.List( 4135 req, 4136 metadata=svc.parent.get_metadata( 4137 'IdentitySets.List', req), 4138 timeout=t) 4139 except Exception as e: 4140 if self.parent.shouldRetry(tries, e, deadline): 4141 tries += 1 4142 time.sleep( 4143 self.parent.exponentialBackoff(tries, deadline)) 4144 continue 4145 raise plumbing.convert_error_to_porcelain(e) from e 4146 tries = 0 4147 for plumbing_item in plumbing_response.identity_sets: 4148 yield plumbing.convert_identity_set_to_porcelain( 4149 plumbing_item) 4150 if plumbing_response.meta.next_cursor == '': 4151 break 4152 req.meta.cursor = plumbing_response.meta.next_cursor 4153 4154 return generator(self, req)
List gets a list of IdentitySets matching a given set of criteria.
class
SnapshotIdentitySets:
4157class SnapshotIdentitySets: 4158 ''' 4159 SnapshotIdentitySets exposes the read only methods of the IdentitySets 4160 service for historical queries. 4161 ''' 4162 def __init__(self, identity_sets): 4163 self.identity_sets = identity_sets 4164 4165 def get(self, id, timeout=None): 4166 ''' 4167 Get reads one IdentitySet by ID. 4168 ''' 4169 return self.identity_sets.get(id, timeout=timeout) 4170 4171 def list(self, filter, *args, timeout=None): 4172 ''' 4173 List gets a list of IdentitySets matching a given set of criteria. 4174 ''' 4175 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)
4165 def get(self, id, timeout=None): 4166 ''' 4167 Get reads one IdentitySet by ID. 4168 ''' 4169 return self.identity_sets.get(id, timeout=timeout)
Get reads one IdentitySet by ID.
def
list(self, filter, *args, timeout=None)
4171 def list(self, filter, *args, timeout=None): 4172 ''' 4173 List gets a list of IdentitySets matching a given set of criteria. 4174 ''' 4175 return self.identity_sets.list(filter, *args, timeout=timeout)
List gets a list of IdentitySets matching a given set of criteria.
class
IdentitySetsHistory:
4178class IdentitySetsHistory: 4179 ''' 4180 IdentitySetsHistory records all changes to the state of a IdentitySet. 4181 See `strongdm.models.IdentitySetHistory`. 4182 ''' 4183 def __init__(self, channel, client): 4184 self.parent = client 4185 self.stub = IdentitySetsHistoryStub(channel) 4186 4187 def list(self, filter, *args, timeout=None): 4188 ''' 4189 List gets a list of IdentitySetHistory records matching a given set of criteria. 4190 ''' 4191 deadline = None if timeout is None else time.time() + timeout 4192 req = IdentitySetHistoryListRequest() 4193 req.meta.CopyFrom(ListRequestMetadata()) 4194 if self.parent.page_limit > 0: 4195 req.meta.limit = self.parent.page_limit 4196 if self.parent.snapshot_datetime is not None: 4197 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4198 4199 req.filter = plumbing.quote_filter_args(filter, *args) 4200 4201 def generator(svc, req): 4202 tries = 0 4203 while True: 4204 t = None if deadline is None else deadline - time.time() 4205 try: 4206 plumbing_response = svc.stub.List( 4207 req, 4208 metadata=svc.parent.get_metadata( 4209 'IdentitySetsHistory.List', req), 4210 timeout=t) 4211 except Exception as e: 4212 if self.parent.shouldRetry(tries, e, deadline): 4213 tries += 1 4214 time.sleep( 4215 self.parent.exponentialBackoff(tries, deadline)) 4216 continue 4217 raise plumbing.convert_error_to_porcelain(e) from e 4218 tries = 0 4219 for plumbing_item in plumbing_response.history: 4220 yield plumbing.convert_identity_set_history_to_porcelain( 4221 plumbing_item) 4222 if plumbing_response.meta.next_cursor == '': 4223 break 4224 req.meta.cursor = plumbing_response.meta.next_cursor 4225 4226 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)
4187 def list(self, filter, *args, timeout=None): 4188 ''' 4189 List gets a list of IdentitySetHistory records matching a given set of criteria. 4190 ''' 4191 deadline = None if timeout is None else time.time() + timeout 4192 req = IdentitySetHistoryListRequest() 4193 req.meta.CopyFrom(ListRequestMetadata()) 4194 if self.parent.page_limit > 0: 4195 req.meta.limit = self.parent.page_limit 4196 if self.parent.snapshot_datetime is not None: 4197 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4198 4199 req.filter = plumbing.quote_filter_args(filter, *args) 4200 4201 def generator(svc, req): 4202 tries = 0 4203 while True: 4204 t = None if deadline is None else deadline - time.time() 4205 try: 4206 plumbing_response = svc.stub.List( 4207 req, 4208 metadata=svc.parent.get_metadata( 4209 'IdentitySetsHistory.List', req), 4210 timeout=t) 4211 except Exception as e: 4212 if self.parent.shouldRetry(tries, e, deadline): 4213 tries += 1 4214 time.sleep( 4215 self.parent.exponentialBackoff(tries, deadline)) 4216 continue 4217 raise plumbing.convert_error_to_porcelain(e) from e 4218 tries = 0 4219 for plumbing_item in plumbing_response.history: 4220 yield plumbing.convert_identity_set_history_to_porcelain( 4221 plumbing_item) 4222 if plumbing_response.meta.next_cursor == '': 4223 break 4224 req.meta.cursor = plumbing_response.meta.next_cursor 4225 4226 return generator(self, req)
List gets a list of IdentitySetHistory records matching a given set of criteria.
class
ManagedSecrets:
4229class ManagedSecrets: 4230 ''' 4231 ManagedSecret is a private vertical for creating, reading, updating, 4232 deleting, listing and rotating the managed secrets in the secrets engines as 4233 an authenticated user. 4234 See `strongdm.models.ManagedSecret`. 4235 ''' 4236 def __init__(self, channel, client): 4237 self.parent = client 4238 self.stub = ManagedSecretsStub(channel) 4239 4240 def list(self, filter, *args, timeout=None): 4241 ''' 4242 List returns Managed Secrets from a Secret Engine. 4243 ''' 4244 deadline = None if timeout is None else time.time() + timeout 4245 req = ManagedSecretListRequest() 4246 req.meta.CopyFrom(ListRequestMetadata()) 4247 if self.parent.page_limit > 0: 4248 req.meta.limit = self.parent.page_limit 4249 if self.parent.snapshot_datetime is not None: 4250 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4251 4252 req.filter = plumbing.quote_filter_args(filter, *args) 4253 4254 def generator(svc, req): 4255 tries = 0 4256 while True: 4257 t = None if deadline is None else deadline - time.time() 4258 try: 4259 plumbing_response = svc.stub.List( 4260 req, 4261 metadata=svc.parent.get_metadata( 4262 'ManagedSecrets.List', req), 4263 timeout=t) 4264 except Exception as e: 4265 if self.parent.shouldRetry(tries, e, deadline): 4266 tries += 1 4267 time.sleep( 4268 self.parent.exponentialBackoff(tries, deadline)) 4269 continue 4270 raise plumbing.convert_error_to_porcelain(e) from e 4271 tries = 0 4272 for plumbing_item in plumbing_response.managed_secrets: 4273 yield plumbing.convert_managed_secret_to_porcelain( 4274 plumbing_item) 4275 if plumbing_response.meta.next_cursor == '': 4276 break 4277 req.meta.cursor = plumbing_response.meta.next_cursor 4278 4279 return generator(self, req) 4280 4281 def list_by_actor(self, filter, *args, timeout=None): 4282 ''' 4283 List returns Managed Secrets for an Actor from a Secret Engine. 4284 ''' 4285 deadline = None if timeout is None else time.time() + timeout 4286 req = ManagedSecretListRequest() 4287 req.meta.CopyFrom(ListRequestMetadata()) 4288 if self.parent.page_limit > 0: 4289 req.meta.limit = self.parent.page_limit 4290 if self.parent.snapshot_datetime is not None: 4291 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4292 4293 req.filter = plumbing.quote_filter_args(filter, *args) 4294 4295 def generator(svc, req): 4296 tries = 0 4297 while True: 4298 t = None if deadline is None else deadline - time.time() 4299 try: 4300 plumbing_response = svc.stub.ListByActor( 4301 req, 4302 metadata=svc.parent.get_metadata( 4303 'ManagedSecrets.ListByActor', req), 4304 timeout=t) 4305 except Exception as e: 4306 if self.parent.shouldRetry(tries, e, deadline): 4307 tries += 1 4308 time.sleep( 4309 self.parent.exponentialBackoff(tries, deadline)) 4310 continue 4311 raise plumbing.convert_error_to_porcelain(e) from e 4312 tries = 0 4313 for plumbing_item in plumbing_response.managed_secrets: 4314 yield plumbing.convert_managed_secret_to_porcelain( 4315 plumbing_item) 4316 if plumbing_response.meta.next_cursor == '': 4317 break 4318 req.meta.cursor = plumbing_response.meta.next_cursor 4319 4320 return generator(self, req) 4321 4322 def create(self, managed_secret, timeout=None): 4323 ''' 4324 Create creates a Managed Secret 4325 ''' 4326 deadline = None if timeout is None else time.time() + timeout 4327 req = ManagedSecretCreateRequest() 4328 4329 if managed_secret is not None: 4330 req.managed_secret.CopyFrom( 4331 plumbing.convert_managed_secret_to_plumbing(managed_secret)) 4332 tries = 0 4333 plumbing_response = None 4334 while True: 4335 t = None if deadline is None else deadline - time.time() 4336 try: 4337 plumbing_response = self.stub.Create( 4338 req, 4339 metadata=self.parent.get_metadata('ManagedSecrets.Create', 4340 req), 4341 timeout=t) 4342 except Exception as e: 4343 if self.parent.shouldRetry(tries, e, deadline): 4344 tries += 1 4345 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4346 continue 4347 raise plumbing.convert_error_to_porcelain(e) from e 4348 break 4349 4350 resp = models.ManagedSecretCreateResponse() 4351 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 4352 plumbing_response.managed_secret) 4353 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4354 plumbing_response.meta) 4355 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4356 plumbing_response.rate_limit) 4357 return resp 4358 4359 def update(self, managed_secret, timeout=None): 4360 ''' 4361 Update updates a Managed Secret 4362 ''' 4363 deadline = None if timeout is None else time.time() + timeout 4364 req = ManagedSecretUpdateRequest() 4365 4366 if managed_secret is not None: 4367 req.managed_secret.CopyFrom( 4368 plumbing.convert_managed_secret_to_plumbing(managed_secret)) 4369 tries = 0 4370 plumbing_response = None 4371 while True: 4372 t = None if deadline is None else deadline - time.time() 4373 try: 4374 plumbing_response = self.stub.Update( 4375 req, 4376 metadata=self.parent.get_metadata('ManagedSecrets.Update', 4377 req), 4378 timeout=t) 4379 except Exception as e: 4380 if self.parent.shouldRetry(tries, e, deadline): 4381 tries += 1 4382 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4383 continue 4384 raise plumbing.convert_error_to_porcelain(e) from e 4385 break 4386 4387 resp = models.ManagedSecretUpdateResponse() 4388 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 4389 plumbing_response.managed_secret) 4390 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 4391 plumbing_response.meta) 4392 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4393 plumbing_response.rate_limit) 4394 return resp 4395 4396 def rotate(self, id, timeout=None): 4397 ''' 4398 Rotate forces rotation of Managed Secret 4399 ''' 4400 deadline = None if timeout is None else time.time() + timeout 4401 req = ManagedSecretRotateRequest() 4402 4403 req.id = (id) 4404 tries = 0 4405 plumbing_response = None 4406 while True: 4407 t = None if deadline is None else deadline - time.time() 4408 try: 4409 plumbing_response = self.stub.Rotate( 4410 req, 4411 metadata=self.parent.get_metadata('ManagedSecrets.Rotate', 4412 req), 4413 timeout=t) 4414 except Exception as e: 4415 if self.parent.shouldRetry(tries, e, deadline): 4416 tries += 1 4417 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4418 continue 4419 raise plumbing.convert_error_to_porcelain(e) from e 4420 break 4421 4422 resp = models.ManagedSecretRotateResponse() 4423 resp.meta = plumbing.convert_generic_response_metadata_to_porcelain( 4424 plumbing_response.meta) 4425 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4426 plumbing_response.rate_limit) 4427 return resp 4428 4429 def delete(self, id, timeout=None): 4430 ''' 4431 Delete deletes a Managed Secret 4432 ''' 4433 deadline = None if timeout is None else time.time() + timeout 4434 req = ManagedSecretDeleteRequest() 4435 4436 req.id = (id) 4437 tries = 0 4438 plumbing_response = None 4439 while True: 4440 t = None if deadline is None else deadline - time.time() 4441 try: 4442 plumbing_response = self.stub.Delete( 4443 req, 4444 metadata=self.parent.get_metadata('ManagedSecrets.Delete', 4445 req), 4446 timeout=t) 4447 except Exception as e: 4448 if self.parent.shouldRetry(tries, e, deadline): 4449 tries += 1 4450 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4451 continue 4452 raise plumbing.convert_error_to_porcelain(e) from e 4453 break 4454 4455 resp = models.ManagedSecretDeleteResponse() 4456 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4457 plumbing_response.rate_limit) 4458 return resp 4459 4460 def force_delete(self, id, timeout=None): 4461 ''' 4462 ForceDelete deletes a Managed Secret regardless of errors on external system 4463 ''' 4464 deadline = None if timeout is None else time.time() + timeout 4465 req = ManagedSecretDeleteRequest() 4466 4467 req.id = (id) 4468 tries = 0 4469 plumbing_response = None 4470 while True: 4471 t = None if deadline is None else deadline - time.time() 4472 try: 4473 plumbing_response = self.stub.ForceDelete( 4474 req, 4475 metadata=self.parent.get_metadata( 4476 'ManagedSecrets.ForceDelete', req), 4477 timeout=t) 4478 except Exception as e: 4479 if self.parent.shouldRetry(tries, e, deadline): 4480 tries += 1 4481 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4482 continue 4483 raise plumbing.convert_error_to_porcelain(e) from e 4484 break 4485 4486 resp = models.ManagedSecretDeleteResponse() 4487 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4488 plumbing_response.rate_limit) 4489 return resp 4490 4491 def get(self, id, timeout=None): 4492 ''' 4493 Get gets details of a Managed Secret without sensitive data 4494 ''' 4495 deadline = None if timeout is None else time.time() + timeout 4496 req = ManagedSecretGetRequest() 4497 if self.parent.snapshot_datetime is not None: 4498 req.meta.CopyFrom(GetRequestMetadata()) 4499 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4500 4501 req.id = (id) 4502 tries = 0 4503 plumbing_response = None 4504 while True: 4505 t = None if deadline is None else deadline - time.time() 4506 try: 4507 plumbing_response = self.stub.Get( 4508 req, 4509 metadata=self.parent.get_metadata('ManagedSecrets.Get', 4510 req), 4511 timeout=t) 4512 except Exception as e: 4513 if self.parent.shouldRetry(tries, e, deadline): 4514 tries += 1 4515 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4516 continue 4517 raise plumbing.convert_error_to_porcelain(e) from e 4518 break 4519 4520 resp = models.ManagedSecretGetResponse() 4521 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 4522 plumbing_response.managed_secret) 4523 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4524 plumbing_response.meta) 4525 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4526 plumbing_response.rate_limit) 4527 return resp 4528 4529 def retrieve(self, id, timeout=None): 4530 ''' 4531 Retrieve returns Managed Secret with sensitive data 4532 ''' 4533 deadline = None if timeout is None else time.time() + timeout 4534 req = ManagedSecretRetrieveRequest() 4535 4536 req.id = (id) 4537 tries = 0 4538 plumbing_response = None 4539 while True: 4540 t = None if deadline is None else deadline - time.time() 4541 try: 4542 plumbing_response = self.stub.Retrieve( 4543 req, 4544 metadata=self.parent.get_metadata( 4545 'ManagedSecrets.Retrieve', req), 4546 timeout=t) 4547 except Exception as e: 4548 if self.parent.shouldRetry(tries, e, deadline): 4549 tries += 1 4550 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4551 continue 4552 raise plumbing.convert_error_to_porcelain(e) from e 4553 break 4554 4555 resp = models.ManagedSecretRetrieveResponse() 4556 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 4557 plumbing_response.managed_secret) 4558 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4559 plumbing_response.meta) 4560 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4561 plumbing_response.rate_limit) 4562 return resp 4563 4564 def validate(self, id, timeout=None): 4565 ''' 4566 Validate returns the result of testing the stored credential against the 4567 secret engine. 4568 ''' 4569 deadline = None if timeout is None else time.time() + timeout 4570 req = ManagedSecretValidateRequest() 4571 4572 req.id = (id) 4573 tries = 0 4574 plumbing_response = None 4575 while True: 4576 t = None if deadline is None else deadline - time.time() 4577 try: 4578 plumbing_response = self.stub.Validate( 4579 req, 4580 metadata=self.parent.get_metadata( 4581 'ManagedSecrets.Validate', req), 4582 timeout=t) 4583 except Exception as e: 4584 if self.parent.shouldRetry(tries, e, deadline): 4585 tries += 1 4586 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4587 continue 4588 raise plumbing.convert_error_to_porcelain(e) from e 4589 break 4590 4591 resp = models.ManagedSecretValidateResponse() 4592 resp.invalid_info = (plumbing_response.invalid_info) 4593 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4594 plumbing_response.meta) 4595 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4596 plumbing_response.rate_limit) 4597 resp.valid = (plumbing_response.valid) 4598 return resp 4599 4600 def logs(self, filter, *args, timeout=None): 4601 ''' 4602 Logs returns the audit records for the managed secret. This may be replaced 4603 in the future. 4604 ''' 4605 deadline = None if timeout is None else time.time() + timeout 4606 req = ManagedSecretLogsRequest() 4607 req.meta.CopyFrom(ListRequestMetadata()) 4608 if self.parent.page_limit > 0: 4609 req.meta.limit = self.parent.page_limit 4610 if self.parent.snapshot_datetime is not None: 4611 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4612 4613 req.filter = plumbing.quote_filter_args(filter, *args) 4614 4615 def generator(svc, req): 4616 tries = 0 4617 while True: 4618 t = None if deadline is None else deadline - time.time() 4619 try: 4620 plumbing_response = svc.stub.Logs( 4621 req, 4622 metadata=svc.parent.get_metadata( 4623 'ManagedSecrets.Logs', req), 4624 timeout=t) 4625 except Exception as e: 4626 if self.parent.shouldRetry(tries, e, deadline): 4627 tries += 1 4628 time.sleep( 4629 self.parent.exponentialBackoff(tries, deadline)) 4630 continue 4631 raise plumbing.convert_error_to_porcelain(e) from e 4632 tries = 0 4633 for plumbing_item in plumbing_response.managed_secret_logs: 4634 yield plumbing.convert_managed_secret_log_to_porcelain( 4635 plumbing_item) 4636 if plumbing_response.meta.next_cursor == '': 4637 break 4638 req.meta.cursor = plumbing_response.meta.next_cursor 4639 4640 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)
4240 def list(self, filter, *args, timeout=None): 4241 ''' 4242 List returns Managed Secrets from a Secret Engine. 4243 ''' 4244 deadline = None if timeout is None else time.time() + timeout 4245 req = ManagedSecretListRequest() 4246 req.meta.CopyFrom(ListRequestMetadata()) 4247 if self.parent.page_limit > 0: 4248 req.meta.limit = self.parent.page_limit 4249 if self.parent.snapshot_datetime is not None: 4250 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4251 4252 req.filter = plumbing.quote_filter_args(filter, *args) 4253 4254 def generator(svc, req): 4255 tries = 0 4256 while True: 4257 t = None if deadline is None else deadline - time.time() 4258 try: 4259 plumbing_response = svc.stub.List( 4260 req, 4261 metadata=svc.parent.get_metadata( 4262 'ManagedSecrets.List', req), 4263 timeout=t) 4264 except Exception as e: 4265 if self.parent.shouldRetry(tries, e, deadline): 4266 tries += 1 4267 time.sleep( 4268 self.parent.exponentialBackoff(tries, deadline)) 4269 continue 4270 raise plumbing.convert_error_to_porcelain(e) from e 4271 tries = 0 4272 for plumbing_item in plumbing_response.managed_secrets: 4273 yield plumbing.convert_managed_secret_to_porcelain( 4274 plumbing_item) 4275 if plumbing_response.meta.next_cursor == '': 4276 break 4277 req.meta.cursor = plumbing_response.meta.next_cursor 4278 4279 return generator(self, req)
List returns Managed Secrets from a Secret Engine.
def
list_by_actor(self, filter, *args, timeout=None)
4281 def list_by_actor(self, filter, *args, timeout=None): 4282 ''' 4283 List returns Managed Secrets for an Actor from a Secret Engine. 4284 ''' 4285 deadline = None if timeout is None else time.time() + timeout 4286 req = ManagedSecretListRequest() 4287 req.meta.CopyFrom(ListRequestMetadata()) 4288 if self.parent.page_limit > 0: 4289 req.meta.limit = self.parent.page_limit 4290 if self.parent.snapshot_datetime is not None: 4291 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4292 4293 req.filter = plumbing.quote_filter_args(filter, *args) 4294 4295 def generator(svc, req): 4296 tries = 0 4297 while True: 4298 t = None if deadline is None else deadline - time.time() 4299 try: 4300 plumbing_response = svc.stub.ListByActor( 4301 req, 4302 metadata=svc.parent.get_metadata( 4303 'ManagedSecrets.ListByActor', req), 4304 timeout=t) 4305 except Exception as e: 4306 if self.parent.shouldRetry(tries, e, deadline): 4307 tries += 1 4308 time.sleep( 4309 self.parent.exponentialBackoff(tries, deadline)) 4310 continue 4311 raise plumbing.convert_error_to_porcelain(e) from e 4312 tries = 0 4313 for plumbing_item in plumbing_response.managed_secrets: 4314 yield plumbing.convert_managed_secret_to_porcelain( 4315 plumbing_item) 4316 if plumbing_response.meta.next_cursor == '': 4317 break 4318 req.meta.cursor = plumbing_response.meta.next_cursor 4319 4320 return generator(self, req)
List returns Managed Secrets for an Actor from a Secret Engine.
def
create(self, managed_secret, timeout=None)
4322 def create(self, managed_secret, timeout=None): 4323 ''' 4324 Create creates a Managed Secret 4325 ''' 4326 deadline = None if timeout is None else time.time() + timeout 4327 req = ManagedSecretCreateRequest() 4328 4329 if managed_secret is not None: 4330 req.managed_secret.CopyFrom( 4331 plumbing.convert_managed_secret_to_plumbing(managed_secret)) 4332 tries = 0 4333 plumbing_response = None 4334 while True: 4335 t = None if deadline is None else deadline - time.time() 4336 try: 4337 plumbing_response = self.stub.Create( 4338 req, 4339 metadata=self.parent.get_metadata('ManagedSecrets.Create', 4340 req), 4341 timeout=t) 4342 except Exception as e: 4343 if self.parent.shouldRetry(tries, e, deadline): 4344 tries += 1 4345 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4346 continue 4347 raise plumbing.convert_error_to_porcelain(e) from e 4348 break 4349 4350 resp = models.ManagedSecretCreateResponse() 4351 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 4352 plumbing_response.managed_secret) 4353 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4354 plumbing_response.meta) 4355 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4356 plumbing_response.rate_limit) 4357 return resp
Create creates a Managed Secret
def
update(self, managed_secret, timeout=None)
4359 def update(self, managed_secret, timeout=None): 4360 ''' 4361 Update updates a Managed Secret 4362 ''' 4363 deadline = None if timeout is None else time.time() + timeout 4364 req = ManagedSecretUpdateRequest() 4365 4366 if managed_secret is not None: 4367 req.managed_secret.CopyFrom( 4368 plumbing.convert_managed_secret_to_plumbing(managed_secret)) 4369 tries = 0 4370 plumbing_response = None 4371 while True: 4372 t = None if deadline is None else deadline - time.time() 4373 try: 4374 plumbing_response = self.stub.Update( 4375 req, 4376 metadata=self.parent.get_metadata('ManagedSecrets.Update', 4377 req), 4378 timeout=t) 4379 except Exception as e: 4380 if self.parent.shouldRetry(tries, e, deadline): 4381 tries += 1 4382 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4383 continue 4384 raise plumbing.convert_error_to_porcelain(e) from e 4385 break 4386 4387 resp = models.ManagedSecretUpdateResponse() 4388 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 4389 plumbing_response.managed_secret) 4390 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 4391 plumbing_response.meta) 4392 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4393 plumbing_response.rate_limit) 4394 return resp
Update updates a Managed Secret
def
rotate(self, id, timeout=None)
4396 def rotate(self, id, timeout=None): 4397 ''' 4398 Rotate forces rotation of Managed Secret 4399 ''' 4400 deadline = None if timeout is None else time.time() + timeout 4401 req = ManagedSecretRotateRequest() 4402 4403 req.id = (id) 4404 tries = 0 4405 plumbing_response = None 4406 while True: 4407 t = None if deadline is None else deadline - time.time() 4408 try: 4409 plumbing_response = self.stub.Rotate( 4410 req, 4411 metadata=self.parent.get_metadata('ManagedSecrets.Rotate', 4412 req), 4413 timeout=t) 4414 except Exception as e: 4415 if self.parent.shouldRetry(tries, e, deadline): 4416 tries += 1 4417 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4418 continue 4419 raise plumbing.convert_error_to_porcelain(e) from e 4420 break 4421 4422 resp = models.ManagedSecretRotateResponse() 4423 resp.meta = plumbing.convert_generic_response_metadata_to_porcelain( 4424 plumbing_response.meta) 4425 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4426 plumbing_response.rate_limit) 4427 return resp
Rotate forces rotation of Managed Secret
def
delete(self, id, timeout=None)
4429 def delete(self, id, timeout=None): 4430 ''' 4431 Delete deletes a Managed Secret 4432 ''' 4433 deadline = None if timeout is None else time.time() + timeout 4434 req = ManagedSecretDeleteRequest() 4435 4436 req.id = (id) 4437 tries = 0 4438 plumbing_response = None 4439 while True: 4440 t = None if deadline is None else deadline - time.time() 4441 try: 4442 plumbing_response = self.stub.Delete( 4443 req, 4444 metadata=self.parent.get_metadata('ManagedSecrets.Delete', 4445 req), 4446 timeout=t) 4447 except Exception as e: 4448 if self.parent.shouldRetry(tries, e, deadline): 4449 tries += 1 4450 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4451 continue 4452 raise plumbing.convert_error_to_porcelain(e) from e 4453 break 4454 4455 resp = models.ManagedSecretDeleteResponse() 4456 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4457 plumbing_response.rate_limit) 4458 return resp
Delete deletes a Managed Secret
def
force_delete(self, id, timeout=None)
4460 def force_delete(self, id, timeout=None): 4461 ''' 4462 ForceDelete deletes a Managed Secret regardless of errors on external system 4463 ''' 4464 deadline = None if timeout is None else time.time() + timeout 4465 req = ManagedSecretDeleteRequest() 4466 4467 req.id = (id) 4468 tries = 0 4469 plumbing_response = None 4470 while True: 4471 t = None if deadline is None else deadline - time.time() 4472 try: 4473 plumbing_response = self.stub.ForceDelete( 4474 req, 4475 metadata=self.parent.get_metadata( 4476 'ManagedSecrets.ForceDelete', req), 4477 timeout=t) 4478 except Exception as e: 4479 if self.parent.shouldRetry(tries, e, deadline): 4480 tries += 1 4481 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4482 continue 4483 raise plumbing.convert_error_to_porcelain(e) from e 4484 break 4485 4486 resp = models.ManagedSecretDeleteResponse() 4487 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4488 plumbing_response.rate_limit) 4489 return resp
ForceDelete deletes a Managed Secret regardless of errors on external system
def
get(self, id, timeout=None)
4491 def get(self, id, timeout=None): 4492 ''' 4493 Get gets details of a Managed Secret without sensitive data 4494 ''' 4495 deadline = None if timeout is None else time.time() + timeout 4496 req = ManagedSecretGetRequest() 4497 if self.parent.snapshot_datetime is not None: 4498 req.meta.CopyFrom(GetRequestMetadata()) 4499 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4500 4501 req.id = (id) 4502 tries = 0 4503 plumbing_response = None 4504 while True: 4505 t = None if deadline is None else deadline - time.time() 4506 try: 4507 plumbing_response = self.stub.Get( 4508 req, 4509 metadata=self.parent.get_metadata('ManagedSecrets.Get', 4510 req), 4511 timeout=t) 4512 except Exception as e: 4513 if self.parent.shouldRetry(tries, e, deadline): 4514 tries += 1 4515 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4516 continue 4517 raise plumbing.convert_error_to_porcelain(e) from e 4518 break 4519 4520 resp = models.ManagedSecretGetResponse() 4521 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 4522 plumbing_response.managed_secret) 4523 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4524 plumbing_response.meta) 4525 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4526 plumbing_response.rate_limit) 4527 return resp
Get gets details of a Managed Secret without sensitive data
def
retrieve(self, id, timeout=None)
4529 def retrieve(self, id, timeout=None): 4530 ''' 4531 Retrieve returns Managed Secret with sensitive data 4532 ''' 4533 deadline = None if timeout is None else time.time() + timeout 4534 req = ManagedSecretRetrieveRequest() 4535 4536 req.id = (id) 4537 tries = 0 4538 plumbing_response = None 4539 while True: 4540 t = None if deadline is None else deadline - time.time() 4541 try: 4542 plumbing_response = self.stub.Retrieve( 4543 req, 4544 metadata=self.parent.get_metadata( 4545 'ManagedSecrets.Retrieve', req), 4546 timeout=t) 4547 except Exception as e: 4548 if self.parent.shouldRetry(tries, e, deadline): 4549 tries += 1 4550 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4551 continue 4552 raise plumbing.convert_error_to_porcelain(e) from e 4553 break 4554 4555 resp = models.ManagedSecretRetrieveResponse() 4556 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 4557 plumbing_response.managed_secret) 4558 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4559 plumbing_response.meta) 4560 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4561 plumbing_response.rate_limit) 4562 return resp
Retrieve returns Managed Secret with sensitive data
def
validate(self, id, timeout=None)
4564 def validate(self, id, timeout=None): 4565 ''' 4566 Validate returns the result of testing the stored credential against the 4567 secret engine. 4568 ''' 4569 deadline = None if timeout is None else time.time() + timeout 4570 req = ManagedSecretValidateRequest() 4571 4572 req.id = (id) 4573 tries = 0 4574 plumbing_response = None 4575 while True: 4576 t = None if deadline is None else deadline - time.time() 4577 try: 4578 plumbing_response = self.stub.Validate( 4579 req, 4580 metadata=self.parent.get_metadata( 4581 'ManagedSecrets.Validate', req), 4582 timeout=t) 4583 except Exception as e: 4584 if self.parent.shouldRetry(tries, e, deadline): 4585 tries += 1 4586 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4587 continue 4588 raise plumbing.convert_error_to_porcelain(e) from e 4589 break 4590 4591 resp = models.ManagedSecretValidateResponse() 4592 resp.invalid_info = (plumbing_response.invalid_info) 4593 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4594 plumbing_response.meta) 4595 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4596 plumbing_response.rate_limit) 4597 resp.valid = (plumbing_response.valid) 4598 return resp
Validate returns the result of testing the stored credential against the secret engine.
def
logs(self, filter, *args, timeout=None)
4600 def logs(self, filter, *args, timeout=None): 4601 ''' 4602 Logs returns the audit records for the managed secret. This may be replaced 4603 in the future. 4604 ''' 4605 deadline = None if timeout is None else time.time() + timeout 4606 req = ManagedSecretLogsRequest() 4607 req.meta.CopyFrom(ListRequestMetadata()) 4608 if self.parent.page_limit > 0: 4609 req.meta.limit = self.parent.page_limit 4610 if self.parent.snapshot_datetime is not None: 4611 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4612 4613 req.filter = plumbing.quote_filter_args(filter, *args) 4614 4615 def generator(svc, req): 4616 tries = 0 4617 while True: 4618 t = None if deadline is None else deadline - time.time() 4619 try: 4620 plumbing_response = svc.stub.Logs( 4621 req, 4622 metadata=svc.parent.get_metadata( 4623 'ManagedSecrets.Logs', req), 4624 timeout=t) 4625 except Exception as e: 4626 if self.parent.shouldRetry(tries, e, deadline): 4627 tries += 1 4628 time.sleep( 4629 self.parent.exponentialBackoff(tries, deadline)) 4630 continue 4631 raise plumbing.convert_error_to_porcelain(e) from e 4632 tries = 0 4633 for plumbing_item in plumbing_response.managed_secret_logs: 4634 yield plumbing.convert_managed_secret_log_to_porcelain( 4635 plumbing_item) 4636 if plumbing_response.meta.next_cursor == '': 4637 break 4638 req.meta.cursor = plumbing_response.meta.next_cursor 4639 4640 return generator(self, req)
Logs returns the audit records for the managed secret. This may be replaced in the future.
class
Nodes:
4643class Nodes: 4644 ''' 4645 Nodes make up the StrongDM network, and allow your users to connect securely to your resources. 4646 There are three types of nodes: 4647 1. **Relay:** creates connectivity to your datasources, while maintaining the egress-only nature of your firewall 4648 2. **Gateway:** a relay that also listens for connections from StrongDM clients 4649 3. **Proxy Cluster:** a cluster of workers that together mediate access from clients to resources 4650 See: 4651 `strongdm.models.Gateway` 4652 `strongdm.models.ProxyCluster` 4653 `strongdm.models.Relay` 4654 ''' 4655 def __init__(self, channel, client): 4656 self.parent = client 4657 self.stub = NodesStub(channel) 4658 4659 def create(self, node, timeout=None): 4660 ''' 4661 Create registers a new Node. 4662 ''' 4663 deadline = None if timeout is None else time.time() + timeout 4664 req = NodeCreateRequest() 4665 4666 if node is not None: 4667 req.node.CopyFrom(plumbing.convert_node_to_plumbing(node)) 4668 tries = 0 4669 plumbing_response = None 4670 while True: 4671 t = None if deadline is None else deadline - time.time() 4672 try: 4673 plumbing_response = self.stub.Create( 4674 req, 4675 metadata=self.parent.get_metadata('Nodes.Create', req), 4676 timeout=t) 4677 except Exception as e: 4678 if self.parent.shouldRetry(tries, e, deadline): 4679 tries += 1 4680 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4681 continue 4682 raise plumbing.convert_error_to_porcelain(e) from e 4683 break 4684 4685 resp = models.NodeCreateResponse() 4686 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4687 plumbing_response.meta) 4688 resp.node = plumbing.convert_node_to_porcelain(plumbing_response.node) 4689 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4690 plumbing_response.rate_limit) 4691 resp.token = (plumbing_response.token) 4692 return resp 4693 4694 def get(self, id, timeout=None): 4695 ''' 4696 Get reads one Node by ID. 4697 ''' 4698 deadline = None if timeout is None else time.time() + timeout 4699 req = NodeGetRequest() 4700 if self.parent.snapshot_datetime is not None: 4701 req.meta.CopyFrom(GetRequestMetadata()) 4702 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4703 4704 req.id = (id) 4705 tries = 0 4706 plumbing_response = None 4707 while True: 4708 t = None if deadline is None else deadline - time.time() 4709 try: 4710 plumbing_response = self.stub.Get( 4711 req, 4712 metadata=self.parent.get_metadata('Nodes.Get', req), 4713 timeout=t) 4714 except Exception as e: 4715 if self.parent.shouldRetry(tries, e, deadline): 4716 tries += 1 4717 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4718 continue 4719 raise plumbing.convert_error_to_porcelain(e) from e 4720 break 4721 4722 resp = models.NodeGetResponse() 4723 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4724 plumbing_response.meta) 4725 resp.node = plumbing.convert_node_to_porcelain(plumbing_response.node) 4726 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4727 plumbing_response.rate_limit) 4728 return resp 4729 4730 def update(self, node, timeout=None): 4731 ''' 4732 Update replaces all the fields of a Node by ID. 4733 ''' 4734 deadline = None if timeout is None else time.time() + timeout 4735 req = NodeUpdateRequest() 4736 4737 if node is not None: 4738 req.node.CopyFrom(plumbing.convert_node_to_plumbing(node)) 4739 tries = 0 4740 plumbing_response = None 4741 while True: 4742 t = None if deadline is None else deadline - time.time() 4743 try: 4744 plumbing_response = self.stub.Update( 4745 req, 4746 metadata=self.parent.get_metadata('Nodes.Update', req), 4747 timeout=t) 4748 except Exception as e: 4749 if self.parent.shouldRetry(tries, e, deadline): 4750 tries += 1 4751 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4752 continue 4753 raise plumbing.convert_error_to_porcelain(e) from e 4754 break 4755 4756 resp = models.NodeUpdateResponse() 4757 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 4758 plumbing_response.meta) 4759 resp.node = plumbing.convert_node_to_porcelain(plumbing_response.node) 4760 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4761 plumbing_response.rate_limit) 4762 return resp 4763 4764 def delete(self, id, timeout=None): 4765 ''' 4766 Delete removes a Node by ID. 4767 ''' 4768 deadline = None if timeout is None else time.time() + timeout 4769 req = NodeDeleteRequest() 4770 4771 req.id = (id) 4772 tries = 0 4773 plumbing_response = None 4774 while True: 4775 t = None if deadline is None else deadline - time.time() 4776 try: 4777 plumbing_response = self.stub.Delete( 4778 req, 4779 metadata=self.parent.get_metadata('Nodes.Delete', req), 4780 timeout=t) 4781 except Exception as e: 4782 if self.parent.shouldRetry(tries, e, deadline): 4783 tries += 1 4784 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4785 continue 4786 raise plumbing.convert_error_to_porcelain(e) from e 4787 break 4788 4789 resp = models.NodeDeleteResponse() 4790 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 4791 plumbing_response.meta) 4792 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4793 plumbing_response.rate_limit) 4794 return resp 4795 4796 def list(self, filter, *args, timeout=None): 4797 ''' 4798 List gets a list of Nodes matching a given set of criteria. 4799 ''' 4800 deadline = None if timeout is None else time.time() + timeout 4801 req = NodeListRequest() 4802 req.meta.CopyFrom(ListRequestMetadata()) 4803 if self.parent.page_limit > 0: 4804 req.meta.limit = self.parent.page_limit 4805 if self.parent.snapshot_datetime is not None: 4806 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4807 4808 req.filter = plumbing.quote_filter_args(filter, *args) 4809 4810 def generator(svc, req): 4811 tries = 0 4812 while True: 4813 t = None if deadline is None else deadline - time.time() 4814 try: 4815 plumbing_response = svc.stub.List( 4816 req, 4817 metadata=svc.parent.get_metadata('Nodes.List', req), 4818 timeout=t) 4819 except Exception as e: 4820 if self.parent.shouldRetry(tries, e, deadline): 4821 tries += 1 4822 time.sleep( 4823 self.parent.exponentialBackoff(tries, deadline)) 4824 continue 4825 raise plumbing.convert_error_to_porcelain(e) from e 4826 tries = 0 4827 for plumbing_item in plumbing_response.nodes: 4828 yield plumbing.convert_node_to_porcelain(plumbing_item) 4829 if plumbing_response.meta.next_cursor == '': 4830 break 4831 req.meta.cursor = plumbing_response.meta.next_cursor 4832 4833 return generator(self, req) 4834 4835 def tcp_probe(self, node_id, host, port, timeout=None): 4836 ''' 4837 TCPProbe instructs a Node to connect to an address via TCP and report the 4838 result. 4839 ''' 4840 deadline = None if timeout is None else time.time() + timeout 4841 req = NodeTCPProbeRequest() 4842 4843 req.node_id = (node_id) 4844 req.host = (host) 4845 req.port = (port) 4846 tries = 0 4847 plumbing_response = None 4848 while True: 4849 t = None if deadline is None else deadline - time.time() 4850 try: 4851 plumbing_response = self.stub.TCPProbe( 4852 req, 4853 metadata=self.parent.get_metadata('Nodes.TCPProbe', req), 4854 timeout=t) 4855 except Exception as e: 4856 if self.parent.shouldRetry(tries, e, deadline): 4857 tries += 1 4858 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4859 continue 4860 raise plumbing.convert_error_to_porcelain(e) from e 4861 break 4862 4863 resp = models.NodeTCPProbeResponse() 4864 resp.error = (plumbing_response.error) 4865 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4866 plumbing_response.meta) 4867 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4868 plumbing_response.rate_limit) 4869 resp.succeeded = (plumbing_response.succeeded) 4870 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)
4659 def create(self, node, timeout=None): 4660 ''' 4661 Create registers a new Node. 4662 ''' 4663 deadline = None if timeout is None else time.time() + timeout 4664 req = NodeCreateRequest() 4665 4666 if node is not None: 4667 req.node.CopyFrom(plumbing.convert_node_to_plumbing(node)) 4668 tries = 0 4669 plumbing_response = None 4670 while True: 4671 t = None if deadline is None else deadline - time.time() 4672 try: 4673 plumbing_response = self.stub.Create( 4674 req, 4675 metadata=self.parent.get_metadata('Nodes.Create', req), 4676 timeout=t) 4677 except Exception as e: 4678 if self.parent.shouldRetry(tries, e, deadline): 4679 tries += 1 4680 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4681 continue 4682 raise plumbing.convert_error_to_porcelain(e) from e 4683 break 4684 4685 resp = models.NodeCreateResponse() 4686 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4687 plumbing_response.meta) 4688 resp.node = plumbing.convert_node_to_porcelain(plumbing_response.node) 4689 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4690 plumbing_response.rate_limit) 4691 resp.token = (plumbing_response.token) 4692 return resp
Create registers a new Node.
def
get(self, id, timeout=None)
4694 def get(self, id, timeout=None): 4695 ''' 4696 Get reads one Node by ID. 4697 ''' 4698 deadline = None if timeout is None else time.time() + timeout 4699 req = NodeGetRequest() 4700 if self.parent.snapshot_datetime is not None: 4701 req.meta.CopyFrom(GetRequestMetadata()) 4702 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4703 4704 req.id = (id) 4705 tries = 0 4706 plumbing_response = None 4707 while True: 4708 t = None if deadline is None else deadline - time.time() 4709 try: 4710 plumbing_response = self.stub.Get( 4711 req, 4712 metadata=self.parent.get_metadata('Nodes.Get', req), 4713 timeout=t) 4714 except Exception as e: 4715 if self.parent.shouldRetry(tries, e, deadline): 4716 tries += 1 4717 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4718 continue 4719 raise plumbing.convert_error_to_porcelain(e) from e 4720 break 4721 4722 resp = models.NodeGetResponse() 4723 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4724 plumbing_response.meta) 4725 resp.node = plumbing.convert_node_to_porcelain(plumbing_response.node) 4726 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4727 plumbing_response.rate_limit) 4728 return resp
Get reads one Node by ID.
def
update(self, node, timeout=None)
4730 def update(self, node, timeout=None): 4731 ''' 4732 Update replaces all the fields of a Node by ID. 4733 ''' 4734 deadline = None if timeout is None else time.time() + timeout 4735 req = NodeUpdateRequest() 4736 4737 if node is not None: 4738 req.node.CopyFrom(plumbing.convert_node_to_plumbing(node)) 4739 tries = 0 4740 plumbing_response = None 4741 while True: 4742 t = None if deadline is None else deadline - time.time() 4743 try: 4744 plumbing_response = self.stub.Update( 4745 req, 4746 metadata=self.parent.get_metadata('Nodes.Update', req), 4747 timeout=t) 4748 except Exception as e: 4749 if self.parent.shouldRetry(tries, e, deadline): 4750 tries += 1 4751 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4752 continue 4753 raise plumbing.convert_error_to_porcelain(e) from e 4754 break 4755 4756 resp = models.NodeUpdateResponse() 4757 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 4758 plumbing_response.meta) 4759 resp.node = plumbing.convert_node_to_porcelain(plumbing_response.node) 4760 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4761 plumbing_response.rate_limit) 4762 return resp
Update replaces all the fields of a Node by ID.
def
delete(self, id, timeout=None)
4764 def delete(self, id, timeout=None): 4765 ''' 4766 Delete removes a Node by ID. 4767 ''' 4768 deadline = None if timeout is None else time.time() + timeout 4769 req = NodeDeleteRequest() 4770 4771 req.id = (id) 4772 tries = 0 4773 plumbing_response = None 4774 while True: 4775 t = None if deadline is None else deadline - time.time() 4776 try: 4777 plumbing_response = self.stub.Delete( 4778 req, 4779 metadata=self.parent.get_metadata('Nodes.Delete', req), 4780 timeout=t) 4781 except Exception as e: 4782 if self.parent.shouldRetry(tries, e, deadline): 4783 tries += 1 4784 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4785 continue 4786 raise plumbing.convert_error_to_porcelain(e) from e 4787 break 4788 4789 resp = models.NodeDeleteResponse() 4790 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 4791 plumbing_response.meta) 4792 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4793 plumbing_response.rate_limit) 4794 return resp
Delete removes a Node by ID.
def
list(self, filter, *args, timeout=None)
4796 def list(self, filter, *args, timeout=None): 4797 ''' 4798 List gets a list of Nodes matching a given set of criteria. 4799 ''' 4800 deadline = None if timeout is None else time.time() + timeout 4801 req = NodeListRequest() 4802 req.meta.CopyFrom(ListRequestMetadata()) 4803 if self.parent.page_limit > 0: 4804 req.meta.limit = self.parent.page_limit 4805 if self.parent.snapshot_datetime is not None: 4806 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4807 4808 req.filter = plumbing.quote_filter_args(filter, *args) 4809 4810 def generator(svc, req): 4811 tries = 0 4812 while True: 4813 t = None if deadline is None else deadline - time.time() 4814 try: 4815 plumbing_response = svc.stub.List( 4816 req, 4817 metadata=svc.parent.get_metadata('Nodes.List', req), 4818 timeout=t) 4819 except Exception as e: 4820 if self.parent.shouldRetry(tries, e, deadline): 4821 tries += 1 4822 time.sleep( 4823 self.parent.exponentialBackoff(tries, deadline)) 4824 continue 4825 raise plumbing.convert_error_to_porcelain(e) from e 4826 tries = 0 4827 for plumbing_item in plumbing_response.nodes: 4828 yield plumbing.convert_node_to_porcelain(plumbing_item) 4829 if plumbing_response.meta.next_cursor == '': 4830 break 4831 req.meta.cursor = plumbing_response.meta.next_cursor 4832 4833 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)
4835 def tcp_probe(self, node_id, host, port, timeout=None): 4836 ''' 4837 TCPProbe instructs a Node to connect to an address via TCP and report the 4838 result. 4839 ''' 4840 deadline = None if timeout is None else time.time() + timeout 4841 req = NodeTCPProbeRequest() 4842 4843 req.node_id = (node_id) 4844 req.host = (host) 4845 req.port = (port) 4846 tries = 0 4847 plumbing_response = None 4848 while True: 4849 t = None if deadline is None else deadline - time.time() 4850 try: 4851 plumbing_response = self.stub.TCPProbe( 4852 req, 4853 metadata=self.parent.get_metadata('Nodes.TCPProbe', req), 4854 timeout=t) 4855 except Exception as e: 4856 if self.parent.shouldRetry(tries, e, deadline): 4857 tries += 1 4858 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4859 continue 4860 raise plumbing.convert_error_to_porcelain(e) from e 4861 break 4862 4863 resp = models.NodeTCPProbeResponse() 4864 resp.error = (plumbing_response.error) 4865 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4866 plumbing_response.meta) 4867 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4868 plumbing_response.rate_limit) 4869 resp.succeeded = (plumbing_response.succeeded) 4870 return resp
TCPProbe instructs a Node to connect to an address via TCP and report the result.
class
SnapshotNodes:
4873class SnapshotNodes: 4874 ''' 4875 SnapshotNodes exposes the read only methods of the Nodes 4876 service for historical queries. 4877 ''' 4878 def __init__(self, nodes): 4879 self.nodes = nodes 4880 4881 def get(self, id, timeout=None): 4882 ''' 4883 Get reads one Node by ID. 4884 ''' 4885 return self.nodes.get(id, timeout=timeout) 4886 4887 def list(self, filter, *args, timeout=None): 4888 ''' 4889 List gets a list of Nodes matching a given set of criteria. 4890 ''' 4891 return self.nodes.list(filter, *args, timeout=timeout)
SnapshotNodes exposes the read only methods of the Nodes service for historical queries.
class
NodesHistory:
4894class NodesHistory: 4895 ''' 4896 NodesHistory records all changes to the state of a Node. 4897 See `strongdm.models.NodeHistory`. 4898 ''' 4899 def __init__(self, channel, client): 4900 self.parent = client 4901 self.stub = NodesHistoryStub(channel) 4902 4903 def list(self, filter, *args, timeout=None): 4904 ''' 4905 List gets a list of NodeHistory records matching a given set of criteria. 4906 ''' 4907 deadline = None if timeout is None else time.time() + timeout 4908 req = NodeHistoryListRequest() 4909 req.meta.CopyFrom(ListRequestMetadata()) 4910 if self.parent.page_limit > 0: 4911 req.meta.limit = self.parent.page_limit 4912 if self.parent.snapshot_datetime is not None: 4913 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4914 4915 req.filter = plumbing.quote_filter_args(filter, *args) 4916 4917 def generator(svc, req): 4918 tries = 0 4919 while True: 4920 t = None if deadline is None else deadline - time.time() 4921 try: 4922 plumbing_response = svc.stub.List( 4923 req, 4924 metadata=svc.parent.get_metadata( 4925 'NodesHistory.List', req), 4926 timeout=t) 4927 except Exception as e: 4928 if self.parent.shouldRetry(tries, e, deadline): 4929 tries += 1 4930 time.sleep( 4931 self.parent.exponentialBackoff(tries, deadline)) 4932 continue 4933 raise plumbing.convert_error_to_porcelain(e) from e 4934 tries = 0 4935 for plumbing_item in plumbing_response.history: 4936 yield plumbing.convert_node_history_to_porcelain( 4937 plumbing_item) 4938 if plumbing_response.meta.next_cursor == '': 4939 break 4940 req.meta.cursor = plumbing_response.meta.next_cursor 4941 4942 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)
4903 def list(self, filter, *args, timeout=None): 4904 ''' 4905 List gets a list of NodeHistory records matching a given set of criteria. 4906 ''' 4907 deadline = None if timeout is None else time.time() + timeout 4908 req = NodeHistoryListRequest() 4909 req.meta.CopyFrom(ListRequestMetadata()) 4910 if self.parent.page_limit > 0: 4911 req.meta.limit = self.parent.page_limit 4912 if self.parent.snapshot_datetime is not None: 4913 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4914 4915 req.filter = plumbing.quote_filter_args(filter, *args) 4916 4917 def generator(svc, req): 4918 tries = 0 4919 while True: 4920 t = None if deadline is None else deadline - time.time() 4921 try: 4922 plumbing_response = svc.stub.List( 4923 req, 4924 metadata=svc.parent.get_metadata( 4925 'NodesHistory.List', req), 4926 timeout=t) 4927 except Exception as e: 4928 if self.parent.shouldRetry(tries, e, deadline): 4929 tries += 1 4930 time.sleep( 4931 self.parent.exponentialBackoff(tries, deadline)) 4932 continue 4933 raise plumbing.convert_error_to_porcelain(e) from e 4934 tries = 0 4935 for plumbing_item in plumbing_response.history: 4936 yield plumbing.convert_node_history_to_porcelain( 4937 plumbing_item) 4938 if plumbing_response.meta.next_cursor == '': 4939 break 4940 req.meta.cursor = plumbing_response.meta.next_cursor 4941 4942 return generator(self, req)
List gets a list of NodeHistory records matching a given set of criteria.
class
OrganizationHistory:
4945class OrganizationHistory: 4946 ''' 4947 OrganizationHistory records all changes to the state of an Organization. 4948 See `strongdm.models.OrganizationHistoryRecord`. 4949 ''' 4950 def __init__(self, channel, client): 4951 self.parent = client 4952 self.stub = OrganizationHistoryStub(channel) 4953 4954 def list(self, filter, *args, timeout=None): 4955 ''' 4956 List gets a list of OrganizationHistory records matching a given set of criteria. 4957 ''' 4958 deadline = None if timeout is None else time.time() + timeout 4959 req = OrganizationHistoryListRequest() 4960 req.meta.CopyFrom(ListRequestMetadata()) 4961 if self.parent.page_limit > 0: 4962 req.meta.limit = self.parent.page_limit 4963 if self.parent.snapshot_datetime is not None: 4964 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4965 4966 req.filter = plumbing.quote_filter_args(filter, *args) 4967 4968 def generator(svc, req): 4969 tries = 0 4970 while True: 4971 t = None if deadline is None else deadline - time.time() 4972 try: 4973 plumbing_response = svc.stub.List( 4974 req, 4975 metadata=svc.parent.get_metadata( 4976 'OrganizationHistory.List', req), 4977 timeout=t) 4978 except Exception as e: 4979 if self.parent.shouldRetry(tries, e, deadline): 4980 tries += 1 4981 time.sleep( 4982 self.parent.exponentialBackoff(tries, deadline)) 4983 continue 4984 raise plumbing.convert_error_to_porcelain(e) from e 4985 tries = 0 4986 for plumbing_item in plumbing_response.history: 4987 yield plumbing.convert_organization_history_record_to_porcelain( 4988 plumbing_item) 4989 if plumbing_response.meta.next_cursor == '': 4990 break 4991 req.meta.cursor = plumbing_response.meta.next_cursor 4992 4993 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)
4954 def list(self, filter, *args, timeout=None): 4955 ''' 4956 List gets a list of OrganizationHistory records matching a given set of criteria. 4957 ''' 4958 deadline = None if timeout is None else time.time() + timeout 4959 req = OrganizationHistoryListRequest() 4960 req.meta.CopyFrom(ListRequestMetadata()) 4961 if self.parent.page_limit > 0: 4962 req.meta.limit = self.parent.page_limit 4963 if self.parent.snapshot_datetime is not None: 4964 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4965 4966 req.filter = plumbing.quote_filter_args(filter, *args) 4967 4968 def generator(svc, req): 4969 tries = 0 4970 while True: 4971 t = None if deadline is None else deadline - time.time() 4972 try: 4973 plumbing_response = svc.stub.List( 4974 req, 4975 metadata=svc.parent.get_metadata( 4976 'OrganizationHistory.List', req), 4977 timeout=t) 4978 except Exception as e: 4979 if self.parent.shouldRetry(tries, e, deadline): 4980 tries += 1 4981 time.sleep( 4982 self.parent.exponentialBackoff(tries, deadline)) 4983 continue 4984 raise plumbing.convert_error_to_porcelain(e) from e 4985 tries = 0 4986 for plumbing_item in plumbing_response.history: 4987 yield plumbing.convert_organization_history_record_to_porcelain( 4988 plumbing_item) 4989 if plumbing_response.meta.next_cursor == '': 4990 break 4991 req.meta.cursor = plumbing_response.meta.next_cursor 4992 4993 return generator(self, req)
List gets a list of OrganizationHistory records matching a given set of criteria.
class
PeeringGroupNodes:
4996class PeeringGroupNodes: 4997 ''' 4998 PeeringGroupNodes provides the building blocks necessary to obtain attach a node to a peering group. 4999 See `strongdm.models.PeeringGroupNode`. 5000 ''' 5001 def __init__(self, channel, client): 5002 self.parent = client 5003 self.stub = PeeringGroupNodesStub(channel) 5004 5005 def create(self, peering_group_node, timeout=None): 5006 ''' 5007 Create attaches a Node to a PeeringGroup 5008 ''' 5009 deadline = None if timeout is None else time.time() + timeout 5010 req = PeeringGroupNodeCreateRequest() 5011 5012 if peering_group_node is not None: 5013 req.peering_group_node.CopyFrom( 5014 plumbing.convert_peering_group_node_to_plumbing( 5015 peering_group_node)) 5016 tries = 0 5017 plumbing_response = None 5018 while True: 5019 t = None if deadline is None else deadline - time.time() 5020 try: 5021 plumbing_response = self.stub.Create( 5022 req, 5023 metadata=self.parent.get_metadata( 5024 'PeeringGroupNodes.Create', req), 5025 timeout=t) 5026 except Exception as e: 5027 if self.parent.shouldRetry(tries, e, deadline): 5028 tries += 1 5029 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5030 continue 5031 raise plumbing.convert_error_to_porcelain(e) from e 5032 break 5033 5034 resp = models.PeeringGroupNodeCreateResponse() 5035 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5036 plumbing_response.meta) 5037 resp.peering_group_node = plumbing.convert_peering_group_node_to_porcelain( 5038 plumbing_response.peering_group_node) 5039 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5040 plumbing_response.rate_limit) 5041 return resp 5042 5043 def delete(self, id, timeout=None): 5044 ''' 5045 Delete detaches a Node to a PeeringGroup. 5046 ''' 5047 deadline = None if timeout is None else time.time() + timeout 5048 req = PeeringGroupNodeDeleteRequest() 5049 5050 req.id = (id) 5051 tries = 0 5052 plumbing_response = None 5053 while True: 5054 t = None if deadline is None else deadline - time.time() 5055 try: 5056 plumbing_response = self.stub.Delete( 5057 req, 5058 metadata=self.parent.get_metadata( 5059 'PeeringGroupNodes.Delete', req), 5060 timeout=t) 5061 except Exception as e: 5062 if self.parent.shouldRetry(tries, e, deadline): 5063 tries += 1 5064 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5065 continue 5066 raise plumbing.convert_error_to_porcelain(e) from e 5067 break 5068 5069 resp = models.PeeringGroupNodeDeleteResponse() 5070 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 5071 plumbing_response.meta) 5072 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5073 plumbing_response.rate_limit) 5074 return resp 5075 5076 def get(self, id, timeout=None): 5077 ''' 5078 Get reads the information of one peering group to node attachment. 5079 ''' 5080 deadline = None if timeout is None else time.time() + timeout 5081 req = PeeringGroupNodeGetRequest() 5082 if self.parent.snapshot_datetime is not None: 5083 req.meta.CopyFrom(GetRequestMetadata()) 5084 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5085 5086 req.id = (id) 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.Get( 5093 req, 5094 metadata=self.parent.get_metadata('PeeringGroupNodes.Get', 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.PeeringGroupNodeGetResponse() 5106 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5107 plumbing_response.meta) 5108 resp.peering_group_node = plumbing.convert_peering_group_node_to_porcelain( 5109 plumbing_response.peering_group_node) 5110 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5111 plumbing_response.rate_limit) 5112 return resp 5113 5114 def list(self, filter, *args, timeout=None): 5115 ''' 5116 List gets a list of peering group node attachments. 5117 ''' 5118 deadline = None if timeout is None else time.time() + timeout 5119 req = PeeringGroupNodeListRequest() 5120 req.meta.CopyFrom(ListRequestMetadata()) 5121 if self.parent.page_limit > 0: 5122 req.meta.limit = self.parent.page_limit 5123 if self.parent.snapshot_datetime is not None: 5124 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5125 5126 req.filter = plumbing.quote_filter_args(filter, *args) 5127 5128 def generator(svc, req): 5129 tries = 0 5130 while True: 5131 t = None if deadline is None else deadline - time.time() 5132 try: 5133 plumbing_response = svc.stub.List( 5134 req, 5135 metadata=svc.parent.get_metadata( 5136 'PeeringGroupNodes.List', req), 5137 timeout=t) 5138 except Exception as e: 5139 if self.parent.shouldRetry(tries, e, deadline): 5140 tries += 1 5141 time.sleep( 5142 self.parent.exponentialBackoff(tries, deadline)) 5143 continue 5144 raise plumbing.convert_error_to_porcelain(e) from e 5145 tries = 0 5146 for plumbing_item in plumbing_response.peering_group_nodes: 5147 yield plumbing.convert_peering_group_node_to_porcelain( 5148 plumbing_item) 5149 if plumbing_response.meta.next_cursor == '': 5150 break 5151 req.meta.cursor = plumbing_response.meta.next_cursor 5152 5153 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)
5005 def create(self, peering_group_node, timeout=None): 5006 ''' 5007 Create attaches a Node to a PeeringGroup 5008 ''' 5009 deadline = None if timeout is None else time.time() + timeout 5010 req = PeeringGroupNodeCreateRequest() 5011 5012 if peering_group_node is not None: 5013 req.peering_group_node.CopyFrom( 5014 plumbing.convert_peering_group_node_to_plumbing( 5015 peering_group_node)) 5016 tries = 0 5017 plumbing_response = None 5018 while True: 5019 t = None if deadline is None else deadline - time.time() 5020 try: 5021 plumbing_response = self.stub.Create( 5022 req, 5023 metadata=self.parent.get_metadata( 5024 'PeeringGroupNodes.Create', req), 5025 timeout=t) 5026 except Exception as e: 5027 if self.parent.shouldRetry(tries, e, deadline): 5028 tries += 1 5029 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5030 continue 5031 raise plumbing.convert_error_to_porcelain(e) from e 5032 break 5033 5034 resp = models.PeeringGroupNodeCreateResponse() 5035 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5036 plumbing_response.meta) 5037 resp.peering_group_node = plumbing.convert_peering_group_node_to_porcelain( 5038 plumbing_response.peering_group_node) 5039 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5040 plumbing_response.rate_limit) 5041 return resp
Create attaches a Node to a PeeringGroup
def
delete(self, id, timeout=None)
5043 def delete(self, id, timeout=None): 5044 ''' 5045 Delete detaches a Node to a PeeringGroup. 5046 ''' 5047 deadline = None if timeout is None else time.time() + timeout 5048 req = PeeringGroupNodeDeleteRequest() 5049 5050 req.id = (id) 5051 tries = 0 5052 plumbing_response = None 5053 while True: 5054 t = None if deadline is None else deadline - time.time() 5055 try: 5056 plumbing_response = self.stub.Delete( 5057 req, 5058 metadata=self.parent.get_metadata( 5059 'PeeringGroupNodes.Delete', req), 5060 timeout=t) 5061 except Exception as e: 5062 if self.parent.shouldRetry(tries, e, deadline): 5063 tries += 1 5064 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5065 continue 5066 raise plumbing.convert_error_to_porcelain(e) from e 5067 break 5068 5069 resp = models.PeeringGroupNodeDeleteResponse() 5070 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 5071 plumbing_response.meta) 5072 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5073 plumbing_response.rate_limit) 5074 return resp
Delete detaches a Node to a PeeringGroup.
def
get(self, id, timeout=None)
5076 def get(self, id, timeout=None): 5077 ''' 5078 Get reads the information of one peering group to node attachment. 5079 ''' 5080 deadline = None if timeout is None else time.time() + timeout 5081 req = PeeringGroupNodeGetRequest() 5082 if self.parent.snapshot_datetime is not None: 5083 req.meta.CopyFrom(GetRequestMetadata()) 5084 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5085 5086 req.id = (id) 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.Get( 5093 req, 5094 metadata=self.parent.get_metadata('PeeringGroupNodes.Get', 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.PeeringGroupNodeGetResponse() 5106 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5107 plumbing_response.meta) 5108 resp.peering_group_node = plumbing.convert_peering_group_node_to_porcelain( 5109 plumbing_response.peering_group_node) 5110 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5111 plumbing_response.rate_limit) 5112 return resp
Get reads the information of one peering group to node attachment.
def
list(self, filter, *args, timeout=None)
5114 def list(self, filter, *args, timeout=None): 5115 ''' 5116 List gets a list of peering group node attachments. 5117 ''' 5118 deadline = None if timeout is None else time.time() + timeout 5119 req = PeeringGroupNodeListRequest() 5120 req.meta.CopyFrom(ListRequestMetadata()) 5121 if self.parent.page_limit > 0: 5122 req.meta.limit = self.parent.page_limit 5123 if self.parent.snapshot_datetime is not None: 5124 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5125 5126 req.filter = plumbing.quote_filter_args(filter, *args) 5127 5128 def generator(svc, req): 5129 tries = 0 5130 while True: 5131 t = None if deadline is None else deadline - time.time() 5132 try: 5133 plumbing_response = svc.stub.List( 5134 req, 5135 metadata=svc.parent.get_metadata( 5136 'PeeringGroupNodes.List', req), 5137 timeout=t) 5138 except Exception as e: 5139 if self.parent.shouldRetry(tries, e, deadline): 5140 tries += 1 5141 time.sleep( 5142 self.parent.exponentialBackoff(tries, deadline)) 5143 continue 5144 raise plumbing.convert_error_to_porcelain(e) from e 5145 tries = 0 5146 for plumbing_item in plumbing_response.peering_group_nodes: 5147 yield plumbing.convert_peering_group_node_to_porcelain( 5148 plumbing_item) 5149 if plumbing_response.meta.next_cursor == '': 5150 break 5151 req.meta.cursor = plumbing_response.meta.next_cursor 5152 5153 return generator(self, req)
List gets a list of peering group node attachments.
class
PeeringGroupPeers:
5156class PeeringGroupPeers: 5157 ''' 5158 PeeringGroupPeers provides the building blocks necessary to link two peering groups. 5159 See `strongdm.models.PeeringGroupPeer`. 5160 ''' 5161 def __init__(self, channel, client): 5162 self.parent = client 5163 self.stub = PeeringGroupPeersStub(channel) 5164 5165 def create(self, peering_group_peer, timeout=None): 5166 ''' 5167 Create links two peering groups. 5168 ''' 5169 deadline = None if timeout is None else time.time() + timeout 5170 req = PeeringGroupPeerCreateRequest() 5171 5172 if peering_group_peer is not None: 5173 req.peering_group_peer.CopyFrom( 5174 plumbing.convert_peering_group_peer_to_plumbing( 5175 peering_group_peer)) 5176 tries = 0 5177 plumbing_response = None 5178 while True: 5179 t = None if deadline is None else deadline - time.time() 5180 try: 5181 plumbing_response = self.stub.Create( 5182 req, 5183 metadata=self.parent.get_metadata( 5184 'PeeringGroupPeers.Create', req), 5185 timeout=t) 5186 except Exception as e: 5187 if self.parent.shouldRetry(tries, e, deadline): 5188 tries += 1 5189 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5190 continue 5191 raise plumbing.convert_error_to_porcelain(e) from e 5192 break 5193 5194 resp = models.PeeringGroupPeerCreateResponse() 5195 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5196 plumbing_response.meta) 5197 resp.peering_group_peer = plumbing.convert_peering_group_peer_to_porcelain( 5198 plumbing_response.peering_group_peer) 5199 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5200 plumbing_response.rate_limit) 5201 return resp 5202 5203 def delete(self, id, timeout=None): 5204 ''' 5205 Delete unlinks two peering groups. 5206 ''' 5207 deadline = None if timeout is None else time.time() + timeout 5208 req = PeeringGroupPeerDeleteRequest() 5209 5210 req.id = (id) 5211 tries = 0 5212 plumbing_response = None 5213 while True: 5214 t = None if deadline is None else deadline - time.time() 5215 try: 5216 plumbing_response = self.stub.Delete( 5217 req, 5218 metadata=self.parent.get_metadata( 5219 'PeeringGroupPeers.Delete', req), 5220 timeout=t) 5221 except Exception as e: 5222 if self.parent.shouldRetry(tries, e, deadline): 5223 tries += 1 5224 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5225 continue 5226 raise plumbing.convert_error_to_porcelain(e) from e 5227 break 5228 5229 resp = models.PeeringGroupPeerDeleteResponse() 5230 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 5231 plumbing_response.meta) 5232 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5233 plumbing_response.rate_limit) 5234 return resp 5235 5236 def get(self, id, timeout=None): 5237 ''' 5238 Get reads the information of one peering group link. 5239 ''' 5240 deadline = None if timeout is None else time.time() + timeout 5241 req = PeeringGroupPeerGetRequest() 5242 if self.parent.snapshot_datetime is not None: 5243 req.meta.CopyFrom(GetRequestMetadata()) 5244 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5245 5246 req.id = (id) 5247 tries = 0 5248 plumbing_response = None 5249 while True: 5250 t = None if deadline is None else deadline - time.time() 5251 try: 5252 plumbing_response = self.stub.Get( 5253 req, 5254 metadata=self.parent.get_metadata('PeeringGroupPeers.Get', 5255 req), 5256 timeout=t) 5257 except Exception as e: 5258 if self.parent.shouldRetry(tries, e, deadline): 5259 tries += 1 5260 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5261 continue 5262 raise plumbing.convert_error_to_porcelain(e) from e 5263 break 5264 5265 resp = models.PeeringGroupPeerGetResponse() 5266 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5267 plumbing_response.meta) 5268 resp.peering_group_peer = plumbing.convert_peering_group_peer_to_porcelain( 5269 plumbing_response.peering_group_peer) 5270 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5271 plumbing_response.rate_limit) 5272 return resp 5273 5274 def list(self, filter, *args, timeout=None): 5275 ''' 5276 List gets a list of peering group links. 5277 ''' 5278 deadline = None if timeout is None else time.time() + timeout 5279 req = PeeringGroupPeerListRequest() 5280 req.meta.CopyFrom(ListRequestMetadata()) 5281 if self.parent.page_limit > 0: 5282 req.meta.limit = self.parent.page_limit 5283 if self.parent.snapshot_datetime is not None: 5284 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5285 5286 req.filter = plumbing.quote_filter_args(filter, *args) 5287 5288 def generator(svc, req): 5289 tries = 0 5290 while True: 5291 t = None if deadline is None else deadline - time.time() 5292 try: 5293 plumbing_response = svc.stub.List( 5294 req, 5295 metadata=svc.parent.get_metadata( 5296 'PeeringGroupPeers.List', req), 5297 timeout=t) 5298 except Exception as e: 5299 if self.parent.shouldRetry(tries, e, deadline): 5300 tries += 1 5301 time.sleep( 5302 self.parent.exponentialBackoff(tries, deadline)) 5303 continue 5304 raise plumbing.convert_error_to_porcelain(e) from e 5305 tries = 0 5306 for plumbing_item in plumbing_response.peering_group_peers: 5307 yield plumbing.convert_peering_group_peer_to_porcelain( 5308 plumbing_item) 5309 if plumbing_response.meta.next_cursor == '': 5310 break 5311 req.meta.cursor = plumbing_response.meta.next_cursor 5312 5313 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)
5165 def create(self, peering_group_peer, timeout=None): 5166 ''' 5167 Create links two peering groups. 5168 ''' 5169 deadline = None if timeout is None else time.time() + timeout 5170 req = PeeringGroupPeerCreateRequest() 5171 5172 if peering_group_peer is not None: 5173 req.peering_group_peer.CopyFrom( 5174 plumbing.convert_peering_group_peer_to_plumbing( 5175 peering_group_peer)) 5176 tries = 0 5177 plumbing_response = None 5178 while True: 5179 t = None if deadline is None else deadline - time.time() 5180 try: 5181 plumbing_response = self.stub.Create( 5182 req, 5183 metadata=self.parent.get_metadata( 5184 'PeeringGroupPeers.Create', req), 5185 timeout=t) 5186 except Exception as e: 5187 if self.parent.shouldRetry(tries, e, deadline): 5188 tries += 1 5189 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5190 continue 5191 raise plumbing.convert_error_to_porcelain(e) from e 5192 break 5193 5194 resp = models.PeeringGroupPeerCreateResponse() 5195 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5196 plumbing_response.meta) 5197 resp.peering_group_peer = plumbing.convert_peering_group_peer_to_porcelain( 5198 plumbing_response.peering_group_peer) 5199 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5200 plumbing_response.rate_limit) 5201 return resp
Create links two peering groups.
def
delete(self, id, timeout=None)
5203 def delete(self, id, timeout=None): 5204 ''' 5205 Delete unlinks two peering groups. 5206 ''' 5207 deadline = None if timeout is None else time.time() + timeout 5208 req = PeeringGroupPeerDeleteRequest() 5209 5210 req.id = (id) 5211 tries = 0 5212 plumbing_response = None 5213 while True: 5214 t = None if deadline is None else deadline - time.time() 5215 try: 5216 plumbing_response = self.stub.Delete( 5217 req, 5218 metadata=self.parent.get_metadata( 5219 'PeeringGroupPeers.Delete', req), 5220 timeout=t) 5221 except Exception as e: 5222 if self.parent.shouldRetry(tries, e, deadline): 5223 tries += 1 5224 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5225 continue 5226 raise plumbing.convert_error_to_porcelain(e) from e 5227 break 5228 5229 resp = models.PeeringGroupPeerDeleteResponse() 5230 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 5231 plumbing_response.meta) 5232 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5233 plumbing_response.rate_limit) 5234 return resp
Delete unlinks two peering groups.
def
get(self, id, timeout=None)
5236 def get(self, id, timeout=None): 5237 ''' 5238 Get reads the information of one peering group link. 5239 ''' 5240 deadline = None if timeout is None else time.time() + timeout 5241 req = PeeringGroupPeerGetRequest() 5242 if self.parent.snapshot_datetime is not None: 5243 req.meta.CopyFrom(GetRequestMetadata()) 5244 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5245 5246 req.id = (id) 5247 tries = 0 5248 plumbing_response = None 5249 while True: 5250 t = None if deadline is None else deadline - time.time() 5251 try: 5252 plumbing_response = self.stub.Get( 5253 req, 5254 metadata=self.parent.get_metadata('PeeringGroupPeers.Get', 5255 req), 5256 timeout=t) 5257 except Exception as e: 5258 if self.parent.shouldRetry(tries, e, deadline): 5259 tries += 1 5260 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5261 continue 5262 raise plumbing.convert_error_to_porcelain(e) from e 5263 break 5264 5265 resp = models.PeeringGroupPeerGetResponse() 5266 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5267 plumbing_response.meta) 5268 resp.peering_group_peer = plumbing.convert_peering_group_peer_to_porcelain( 5269 plumbing_response.peering_group_peer) 5270 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5271 plumbing_response.rate_limit) 5272 return resp
Get reads the information of one peering group link.
def
list(self, filter, *args, timeout=None)
5274 def list(self, filter, *args, timeout=None): 5275 ''' 5276 List gets a list of peering group links. 5277 ''' 5278 deadline = None if timeout is None else time.time() + timeout 5279 req = PeeringGroupPeerListRequest() 5280 req.meta.CopyFrom(ListRequestMetadata()) 5281 if self.parent.page_limit > 0: 5282 req.meta.limit = self.parent.page_limit 5283 if self.parent.snapshot_datetime is not None: 5284 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5285 5286 req.filter = plumbing.quote_filter_args(filter, *args) 5287 5288 def generator(svc, req): 5289 tries = 0 5290 while True: 5291 t = None if deadline is None else deadline - time.time() 5292 try: 5293 plumbing_response = svc.stub.List( 5294 req, 5295 metadata=svc.parent.get_metadata( 5296 'PeeringGroupPeers.List', req), 5297 timeout=t) 5298 except Exception as e: 5299 if self.parent.shouldRetry(tries, e, deadline): 5300 tries += 1 5301 time.sleep( 5302 self.parent.exponentialBackoff(tries, deadline)) 5303 continue 5304 raise plumbing.convert_error_to_porcelain(e) from e 5305 tries = 0 5306 for plumbing_item in plumbing_response.peering_group_peers: 5307 yield plumbing.convert_peering_group_peer_to_porcelain( 5308 plumbing_item) 5309 if plumbing_response.meta.next_cursor == '': 5310 break 5311 req.meta.cursor = plumbing_response.meta.next_cursor 5312 5313 return generator(self, req)
List gets a list of peering group links.
class
PeeringGroupResources:
5316class PeeringGroupResources: 5317 ''' 5318 PeeringGroupResources provides the building blocks necessary to obtain attach a resource to a peering group. 5319 See `strongdm.models.PeeringGroupResource`. 5320 ''' 5321 def __init__(self, channel, client): 5322 self.parent = client 5323 self.stub = PeeringGroupResourcesStub(channel) 5324 5325 def create(self, peering_group_resource, timeout=None): 5326 ''' 5327 Create attaches a Resource to a PeeringGroup 5328 ''' 5329 deadline = None if timeout is None else time.time() + timeout 5330 req = PeeringGroupResourceCreateRequest() 5331 5332 if peering_group_resource is not None: 5333 req.peering_group_resource.CopyFrom( 5334 plumbing.convert_peering_group_resource_to_plumbing( 5335 peering_group_resource)) 5336 tries = 0 5337 plumbing_response = None 5338 while True: 5339 t = None if deadline is None else deadline - time.time() 5340 try: 5341 plumbing_response = self.stub.Create( 5342 req, 5343 metadata=self.parent.get_metadata( 5344 'PeeringGroupResources.Create', req), 5345 timeout=t) 5346 except Exception as e: 5347 if self.parent.shouldRetry(tries, e, deadline): 5348 tries += 1 5349 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5350 continue 5351 raise plumbing.convert_error_to_porcelain(e) from e 5352 break 5353 5354 resp = models.PeeringGroupResourceCreateResponse() 5355 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5356 plumbing_response.meta) 5357 resp.peering_group_resource = plumbing.convert_peering_group_resource_to_porcelain( 5358 plumbing_response.peering_group_resource) 5359 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5360 plumbing_response.rate_limit) 5361 return resp 5362 5363 def delete(self, id, timeout=None): 5364 ''' 5365 Delete detaches a Resource to a PeeringGroup 5366 ''' 5367 deadline = None if timeout is None else time.time() + timeout 5368 req = PeeringGroupResourceDeleteRequest() 5369 5370 req.id = (id) 5371 tries = 0 5372 plumbing_response = None 5373 while True: 5374 t = None if deadline is None else deadline - time.time() 5375 try: 5376 plumbing_response = self.stub.Delete( 5377 req, 5378 metadata=self.parent.get_metadata( 5379 'PeeringGroupResources.Delete', req), 5380 timeout=t) 5381 except Exception as e: 5382 if self.parent.shouldRetry(tries, e, deadline): 5383 tries += 1 5384 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5385 continue 5386 raise plumbing.convert_error_to_porcelain(e) from e 5387 break 5388 5389 resp = models.PeeringGroupResourceDeleteResponse() 5390 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 5391 plumbing_response.meta) 5392 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5393 plumbing_response.rate_limit) 5394 return resp 5395 5396 def get(self, id, timeout=None): 5397 ''' 5398 Get reads the information of one peering group to resource attachment. 5399 ''' 5400 deadline = None if timeout is None else time.time() + timeout 5401 req = PeeringGroupResourceGetRequest() 5402 if self.parent.snapshot_datetime is not None: 5403 req.meta.CopyFrom(GetRequestMetadata()) 5404 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5405 5406 req.id = (id) 5407 tries = 0 5408 plumbing_response = None 5409 while True: 5410 t = None if deadline is None else deadline - time.time() 5411 try: 5412 plumbing_response = self.stub.Get( 5413 req, 5414 metadata=self.parent.get_metadata( 5415 'PeeringGroupResources.Get', req), 5416 timeout=t) 5417 except Exception as e: 5418 if self.parent.shouldRetry(tries, e, deadline): 5419 tries += 1 5420 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5421 continue 5422 raise plumbing.convert_error_to_porcelain(e) from e 5423 break 5424 5425 resp = models.PeeringGroupResourceGetResponse() 5426 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5427 plumbing_response.meta) 5428 resp.peering_group_resource = plumbing.convert_peering_group_resource_to_porcelain( 5429 plumbing_response.peering_group_resource) 5430 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5431 plumbing_response.rate_limit) 5432 return resp 5433 5434 def list(self, filter, *args, timeout=None): 5435 ''' 5436 List gets a list of peering group resource attachments. 5437 ''' 5438 deadline = None if timeout is None else time.time() + timeout 5439 req = PeeringGroupResourceListRequest() 5440 req.meta.CopyFrom(ListRequestMetadata()) 5441 if self.parent.page_limit > 0: 5442 req.meta.limit = self.parent.page_limit 5443 if self.parent.snapshot_datetime is not None: 5444 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5445 5446 req.filter = plumbing.quote_filter_args(filter, *args) 5447 5448 def generator(svc, req): 5449 tries = 0 5450 while True: 5451 t = None if deadline is None else deadline - time.time() 5452 try: 5453 plumbing_response = svc.stub.List( 5454 req, 5455 metadata=svc.parent.get_metadata( 5456 'PeeringGroupResources.List', req), 5457 timeout=t) 5458 except Exception as e: 5459 if self.parent.shouldRetry(tries, e, deadline): 5460 tries += 1 5461 time.sleep( 5462 self.parent.exponentialBackoff(tries, deadline)) 5463 continue 5464 raise plumbing.convert_error_to_porcelain(e) from e 5465 tries = 0 5466 for plumbing_item in plumbing_response.peering_group_resources: 5467 yield plumbing.convert_peering_group_resource_to_porcelain( 5468 plumbing_item) 5469 if plumbing_response.meta.next_cursor == '': 5470 break 5471 req.meta.cursor = plumbing_response.meta.next_cursor 5472 5473 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)
5325 def create(self, peering_group_resource, timeout=None): 5326 ''' 5327 Create attaches a Resource to a PeeringGroup 5328 ''' 5329 deadline = None if timeout is None else time.time() + timeout 5330 req = PeeringGroupResourceCreateRequest() 5331 5332 if peering_group_resource is not None: 5333 req.peering_group_resource.CopyFrom( 5334 plumbing.convert_peering_group_resource_to_plumbing( 5335 peering_group_resource)) 5336 tries = 0 5337 plumbing_response = None 5338 while True: 5339 t = None if deadline is None else deadline - time.time() 5340 try: 5341 plumbing_response = self.stub.Create( 5342 req, 5343 metadata=self.parent.get_metadata( 5344 'PeeringGroupResources.Create', req), 5345 timeout=t) 5346 except Exception as e: 5347 if self.parent.shouldRetry(tries, e, deadline): 5348 tries += 1 5349 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5350 continue 5351 raise plumbing.convert_error_to_porcelain(e) from e 5352 break 5353 5354 resp = models.PeeringGroupResourceCreateResponse() 5355 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5356 plumbing_response.meta) 5357 resp.peering_group_resource = plumbing.convert_peering_group_resource_to_porcelain( 5358 plumbing_response.peering_group_resource) 5359 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5360 plumbing_response.rate_limit) 5361 return resp
Create attaches a Resource to a PeeringGroup
def
delete(self, id, timeout=None)
5363 def delete(self, id, timeout=None): 5364 ''' 5365 Delete detaches a Resource to a PeeringGroup 5366 ''' 5367 deadline = None if timeout is None else time.time() + timeout 5368 req = PeeringGroupResourceDeleteRequest() 5369 5370 req.id = (id) 5371 tries = 0 5372 plumbing_response = None 5373 while True: 5374 t = None if deadline is None else deadline - time.time() 5375 try: 5376 plumbing_response = self.stub.Delete( 5377 req, 5378 metadata=self.parent.get_metadata( 5379 'PeeringGroupResources.Delete', req), 5380 timeout=t) 5381 except Exception as e: 5382 if self.parent.shouldRetry(tries, e, deadline): 5383 tries += 1 5384 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5385 continue 5386 raise plumbing.convert_error_to_porcelain(e) from e 5387 break 5388 5389 resp = models.PeeringGroupResourceDeleteResponse() 5390 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 5391 plumbing_response.meta) 5392 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5393 plumbing_response.rate_limit) 5394 return resp
Delete detaches a Resource to a PeeringGroup
def
get(self, id, timeout=None)
5396 def get(self, id, timeout=None): 5397 ''' 5398 Get reads the information of one peering group to resource attachment. 5399 ''' 5400 deadline = None if timeout is None else time.time() + timeout 5401 req = PeeringGroupResourceGetRequest() 5402 if self.parent.snapshot_datetime is not None: 5403 req.meta.CopyFrom(GetRequestMetadata()) 5404 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5405 5406 req.id = (id) 5407 tries = 0 5408 plumbing_response = None 5409 while True: 5410 t = None if deadline is None else deadline - time.time() 5411 try: 5412 plumbing_response = self.stub.Get( 5413 req, 5414 metadata=self.parent.get_metadata( 5415 'PeeringGroupResources.Get', req), 5416 timeout=t) 5417 except Exception as e: 5418 if self.parent.shouldRetry(tries, e, deadline): 5419 tries += 1 5420 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5421 continue 5422 raise plumbing.convert_error_to_porcelain(e) from e 5423 break 5424 5425 resp = models.PeeringGroupResourceGetResponse() 5426 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5427 plumbing_response.meta) 5428 resp.peering_group_resource = plumbing.convert_peering_group_resource_to_porcelain( 5429 plumbing_response.peering_group_resource) 5430 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5431 plumbing_response.rate_limit) 5432 return resp
Get reads the information of one peering group to resource attachment.
def
list(self, filter, *args, timeout=None)
5434 def list(self, filter, *args, timeout=None): 5435 ''' 5436 List gets a list of peering group resource attachments. 5437 ''' 5438 deadline = None if timeout is None else time.time() + timeout 5439 req = PeeringGroupResourceListRequest() 5440 req.meta.CopyFrom(ListRequestMetadata()) 5441 if self.parent.page_limit > 0: 5442 req.meta.limit = self.parent.page_limit 5443 if self.parent.snapshot_datetime is not None: 5444 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5445 5446 req.filter = plumbing.quote_filter_args(filter, *args) 5447 5448 def generator(svc, req): 5449 tries = 0 5450 while True: 5451 t = None if deadline is None else deadline - time.time() 5452 try: 5453 plumbing_response = svc.stub.List( 5454 req, 5455 metadata=svc.parent.get_metadata( 5456 'PeeringGroupResources.List', req), 5457 timeout=t) 5458 except Exception as e: 5459 if self.parent.shouldRetry(tries, e, deadline): 5460 tries += 1 5461 time.sleep( 5462 self.parent.exponentialBackoff(tries, deadline)) 5463 continue 5464 raise plumbing.convert_error_to_porcelain(e) from e 5465 tries = 0 5466 for plumbing_item in plumbing_response.peering_group_resources: 5467 yield plumbing.convert_peering_group_resource_to_porcelain( 5468 plumbing_item) 5469 if plumbing_response.meta.next_cursor == '': 5470 break 5471 req.meta.cursor = plumbing_response.meta.next_cursor 5472 5473 return generator(self, req)
List gets a list of peering group resource attachments.
class
PeeringGroups:
5476class PeeringGroups: 5477 ''' 5478 PeeringGroups provides the building blocks necessary to obtain explicit network topology and routing. 5479 See `strongdm.models.PeeringGroup`. 5480 ''' 5481 def __init__(self, channel, client): 5482 self.parent = client 5483 self.stub = PeeringGroupsStub(channel) 5484 5485 def create(self, peering_group, timeout=None): 5486 ''' 5487 Create registers a new PeeringGroup. 5488 ''' 5489 deadline = None if timeout is None else time.time() + timeout 5490 req = PeeringGroupCreateRequest() 5491 5492 if peering_group is not None: 5493 req.peering_group.CopyFrom( 5494 plumbing.convert_peering_group_to_plumbing(peering_group)) 5495 tries = 0 5496 plumbing_response = None 5497 while True: 5498 t = None if deadline is None else deadline - time.time() 5499 try: 5500 plumbing_response = self.stub.Create( 5501 req, 5502 metadata=self.parent.get_metadata('PeeringGroups.Create', 5503 req), 5504 timeout=t) 5505 except Exception as e: 5506 if self.parent.shouldRetry(tries, e, deadline): 5507 tries += 1 5508 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5509 continue 5510 raise plumbing.convert_error_to_porcelain(e) from e 5511 break 5512 5513 resp = models.PeeringGroupCreateResponse() 5514 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5515 plumbing_response.meta) 5516 resp.peering_group = plumbing.convert_peering_group_to_porcelain( 5517 plumbing_response.peering_group) 5518 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5519 plumbing_response.rate_limit) 5520 return resp 5521 5522 def delete(self, id, timeout=None): 5523 ''' 5524 Delete removes a PeeringGroup by ID. 5525 ''' 5526 deadline = None if timeout is None else time.time() + timeout 5527 req = PeeringGroupDeleteRequest() 5528 5529 req.id = (id) 5530 tries = 0 5531 plumbing_response = None 5532 while True: 5533 t = None if deadline is None else deadline - time.time() 5534 try: 5535 plumbing_response = self.stub.Delete( 5536 req, 5537 metadata=self.parent.get_metadata('PeeringGroups.Delete', 5538 req), 5539 timeout=t) 5540 except Exception as e: 5541 if self.parent.shouldRetry(tries, e, deadline): 5542 tries += 1 5543 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5544 continue 5545 raise plumbing.convert_error_to_porcelain(e) from e 5546 break 5547 5548 resp = models.PeeringGroupDeleteResponse() 5549 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 5550 plumbing_response.meta) 5551 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5552 plumbing_response.rate_limit) 5553 return resp 5554 5555 def get(self, id, timeout=None): 5556 ''' 5557 Get reads one PeeringGroup by ID. It will load all its dependencies. 5558 ''' 5559 deadline = None if timeout is None else time.time() + timeout 5560 req = PeeringGroupGetRequest() 5561 if self.parent.snapshot_datetime is not None: 5562 req.meta.CopyFrom(GetRequestMetadata()) 5563 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5564 5565 req.id = (id) 5566 tries = 0 5567 plumbing_response = None 5568 while True: 5569 t = None if deadline is None else deadline - time.time() 5570 try: 5571 plumbing_response = self.stub.Get( 5572 req, 5573 metadata=self.parent.get_metadata('PeeringGroups.Get', 5574 req), 5575 timeout=t) 5576 except Exception as e: 5577 if self.parent.shouldRetry(tries, e, deadline): 5578 tries += 1 5579 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5580 continue 5581 raise plumbing.convert_error_to_porcelain(e) from e 5582 break 5583 5584 resp = models.PeeringGroupGetResponse() 5585 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5586 plumbing_response.meta) 5587 resp.peering_group = plumbing.convert_peering_group_to_porcelain( 5588 plumbing_response.peering_group) 5589 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5590 plumbing_response.rate_limit) 5591 return resp 5592 5593 def list(self, filter, *args, timeout=None): 5594 ''' 5595 List gets a list of Peering Groups. 5596 ''' 5597 deadline = None if timeout is None else time.time() + timeout 5598 req = PeeringGroupListRequest() 5599 req.meta.CopyFrom(ListRequestMetadata()) 5600 if self.parent.page_limit > 0: 5601 req.meta.limit = self.parent.page_limit 5602 if self.parent.snapshot_datetime is not None: 5603 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5604 5605 req.filter = plumbing.quote_filter_args(filter, *args) 5606 5607 def generator(svc, req): 5608 tries = 0 5609 while True: 5610 t = None if deadline is None else deadline - time.time() 5611 try: 5612 plumbing_response = svc.stub.List( 5613 req, 5614 metadata=svc.parent.get_metadata( 5615 'PeeringGroups.List', req), 5616 timeout=t) 5617 except Exception as e: 5618 if self.parent.shouldRetry(tries, e, deadline): 5619 tries += 1 5620 time.sleep( 5621 self.parent.exponentialBackoff(tries, deadline)) 5622 continue 5623 raise plumbing.convert_error_to_porcelain(e) from e 5624 tries = 0 5625 for plumbing_item in plumbing_response.peering_groups: 5626 yield plumbing.convert_peering_group_to_porcelain( 5627 plumbing_item) 5628 if plumbing_response.meta.next_cursor == '': 5629 break 5630 req.meta.cursor = plumbing_response.meta.next_cursor 5631 5632 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)
5485 def create(self, peering_group, timeout=None): 5486 ''' 5487 Create registers a new PeeringGroup. 5488 ''' 5489 deadline = None if timeout is None else time.time() + timeout 5490 req = PeeringGroupCreateRequest() 5491 5492 if peering_group is not None: 5493 req.peering_group.CopyFrom( 5494 plumbing.convert_peering_group_to_plumbing(peering_group)) 5495 tries = 0 5496 plumbing_response = None 5497 while True: 5498 t = None if deadline is None else deadline - time.time() 5499 try: 5500 plumbing_response = self.stub.Create( 5501 req, 5502 metadata=self.parent.get_metadata('PeeringGroups.Create', 5503 req), 5504 timeout=t) 5505 except Exception as e: 5506 if self.parent.shouldRetry(tries, e, deadline): 5507 tries += 1 5508 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5509 continue 5510 raise plumbing.convert_error_to_porcelain(e) from e 5511 break 5512 5513 resp = models.PeeringGroupCreateResponse() 5514 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5515 plumbing_response.meta) 5516 resp.peering_group = plumbing.convert_peering_group_to_porcelain( 5517 plumbing_response.peering_group) 5518 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5519 plumbing_response.rate_limit) 5520 return resp
Create registers a new PeeringGroup.
def
delete(self, id, timeout=None)
5522 def delete(self, id, timeout=None): 5523 ''' 5524 Delete removes a PeeringGroup by ID. 5525 ''' 5526 deadline = None if timeout is None else time.time() + timeout 5527 req = PeeringGroupDeleteRequest() 5528 5529 req.id = (id) 5530 tries = 0 5531 plumbing_response = None 5532 while True: 5533 t = None if deadline is None else deadline - time.time() 5534 try: 5535 plumbing_response = self.stub.Delete( 5536 req, 5537 metadata=self.parent.get_metadata('PeeringGroups.Delete', 5538 req), 5539 timeout=t) 5540 except Exception as e: 5541 if self.parent.shouldRetry(tries, e, deadline): 5542 tries += 1 5543 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5544 continue 5545 raise plumbing.convert_error_to_porcelain(e) from e 5546 break 5547 5548 resp = models.PeeringGroupDeleteResponse() 5549 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 5550 plumbing_response.meta) 5551 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5552 plumbing_response.rate_limit) 5553 return resp
Delete removes a PeeringGroup by ID.
def
get(self, id, timeout=None)
5555 def get(self, id, timeout=None): 5556 ''' 5557 Get reads one PeeringGroup by ID. It will load all its dependencies. 5558 ''' 5559 deadline = None if timeout is None else time.time() + timeout 5560 req = PeeringGroupGetRequest() 5561 if self.parent.snapshot_datetime is not None: 5562 req.meta.CopyFrom(GetRequestMetadata()) 5563 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5564 5565 req.id = (id) 5566 tries = 0 5567 plumbing_response = None 5568 while True: 5569 t = None if deadline is None else deadline - time.time() 5570 try: 5571 plumbing_response = self.stub.Get( 5572 req, 5573 metadata=self.parent.get_metadata('PeeringGroups.Get', 5574 req), 5575 timeout=t) 5576 except Exception as e: 5577 if self.parent.shouldRetry(tries, e, deadline): 5578 tries += 1 5579 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5580 continue 5581 raise plumbing.convert_error_to_porcelain(e) from e 5582 break 5583 5584 resp = models.PeeringGroupGetResponse() 5585 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5586 plumbing_response.meta) 5587 resp.peering_group = plumbing.convert_peering_group_to_porcelain( 5588 plumbing_response.peering_group) 5589 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5590 plumbing_response.rate_limit) 5591 return resp
Get reads one PeeringGroup by ID. It will load all its dependencies.
def
list(self, filter, *args, timeout=None)
5593 def list(self, filter, *args, timeout=None): 5594 ''' 5595 List gets a list of Peering Groups. 5596 ''' 5597 deadline = None if timeout is None else time.time() + timeout 5598 req = PeeringGroupListRequest() 5599 req.meta.CopyFrom(ListRequestMetadata()) 5600 if self.parent.page_limit > 0: 5601 req.meta.limit = self.parent.page_limit 5602 if self.parent.snapshot_datetime is not None: 5603 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5604 5605 req.filter = plumbing.quote_filter_args(filter, *args) 5606 5607 def generator(svc, req): 5608 tries = 0 5609 while True: 5610 t = None if deadline is None else deadline - time.time() 5611 try: 5612 plumbing_response = svc.stub.List( 5613 req, 5614 metadata=svc.parent.get_metadata( 5615 'PeeringGroups.List', req), 5616 timeout=t) 5617 except Exception as e: 5618 if self.parent.shouldRetry(tries, e, deadline): 5619 tries += 1 5620 time.sleep( 5621 self.parent.exponentialBackoff(tries, deadline)) 5622 continue 5623 raise plumbing.convert_error_to_porcelain(e) from e 5624 tries = 0 5625 for plumbing_item in plumbing_response.peering_groups: 5626 yield plumbing.convert_peering_group_to_porcelain( 5627 plumbing_item) 5628 if plumbing_response.meta.next_cursor == '': 5629 break 5630 req.meta.cursor = plumbing_response.meta.next_cursor 5631 5632 return generator(self, req)
List gets a list of Peering Groups.
class
Policies:
5635class Policies: 5636 ''' 5637 Policies are the collection of one or more statements that enforce fine-grained access 5638 control for the users of an organization. 5639 See `strongdm.models.Policy`. 5640 ''' 5641 def __init__(self, channel, client): 5642 self.parent = client 5643 self.stub = PoliciesStub(channel) 5644 5645 def create(self, policy, timeout=None): 5646 ''' 5647 Create creates a new Policy. 5648 ''' 5649 deadline = None if timeout is None else time.time() + timeout 5650 req = PolicyCreateRequest() 5651 5652 if policy is not None: 5653 req.policy.CopyFrom(plumbing.convert_policy_to_plumbing(policy)) 5654 tries = 0 5655 plumbing_response = None 5656 while True: 5657 t = None if deadline is None else deadline - time.time() 5658 try: 5659 plumbing_response = self.stub.Create( 5660 req, 5661 metadata=self.parent.get_metadata('Policies.Create', req), 5662 timeout=t) 5663 except Exception as e: 5664 if self.parent.shouldRetry(tries, e, deadline): 5665 tries += 1 5666 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5667 continue 5668 raise plumbing.convert_error_to_porcelain(e) from e 5669 break 5670 5671 resp = models.PolicyCreateResponse() 5672 resp.policy = plumbing.convert_policy_to_porcelain( 5673 plumbing_response.policy) 5674 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5675 plumbing_response.rate_limit) 5676 return resp 5677 5678 def delete(self, id, timeout=None): 5679 ''' 5680 Delete removes a Policy by ID. 5681 ''' 5682 deadline = None if timeout is None else time.time() + timeout 5683 req = PolicyDeleteRequest() 5684 5685 req.id = (id) 5686 tries = 0 5687 plumbing_response = None 5688 while True: 5689 t = None if deadline is None else deadline - time.time() 5690 try: 5691 plumbing_response = self.stub.Delete( 5692 req, 5693 metadata=self.parent.get_metadata('Policies.Delete', req), 5694 timeout=t) 5695 except Exception as e: 5696 if self.parent.shouldRetry(tries, e, deadline): 5697 tries += 1 5698 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5699 continue 5700 raise plumbing.convert_error_to_porcelain(e) from e 5701 break 5702 5703 resp = models.PolicyDeleteResponse() 5704 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5705 plumbing_response.rate_limit) 5706 return resp 5707 5708 def update(self, policy, timeout=None): 5709 ''' 5710 Update replaces all the fields of a Policy by ID. 5711 ''' 5712 deadline = None if timeout is None else time.time() + timeout 5713 req = PolicyUpdateRequest() 5714 5715 if policy is not None: 5716 req.policy.CopyFrom(plumbing.convert_policy_to_plumbing(policy)) 5717 tries = 0 5718 plumbing_response = None 5719 while True: 5720 t = None if deadline is None else deadline - time.time() 5721 try: 5722 plumbing_response = self.stub.Update( 5723 req, 5724 metadata=self.parent.get_metadata('Policies.Update', req), 5725 timeout=t) 5726 except Exception as e: 5727 if self.parent.shouldRetry(tries, e, deadline): 5728 tries += 1 5729 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5730 continue 5731 raise plumbing.convert_error_to_porcelain(e) from e 5732 break 5733 5734 resp = models.PolicyUpdateResponse() 5735 resp.policy = plumbing.convert_policy_to_porcelain( 5736 plumbing_response.policy) 5737 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5738 plumbing_response.rate_limit) 5739 return resp 5740 5741 def get(self, id, timeout=None): 5742 ''' 5743 Get reads one Policy by ID. 5744 ''' 5745 deadline = None if timeout is None else time.time() + timeout 5746 req = PolicyGetRequest() 5747 if self.parent.snapshot_datetime is not None: 5748 req.meta.CopyFrom(GetRequestMetadata()) 5749 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5750 5751 req.id = (id) 5752 tries = 0 5753 plumbing_response = None 5754 while True: 5755 t = None if deadline is None else deadline - time.time() 5756 try: 5757 plumbing_response = self.stub.Get( 5758 req, 5759 metadata=self.parent.get_metadata('Policies.Get', req), 5760 timeout=t) 5761 except Exception as e: 5762 if self.parent.shouldRetry(tries, e, deadline): 5763 tries += 1 5764 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5765 continue 5766 raise plumbing.convert_error_to_porcelain(e) from e 5767 break 5768 5769 resp = models.PolicyGetResponse() 5770 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5771 plumbing_response.meta) 5772 resp.policy = plumbing.convert_policy_to_porcelain( 5773 plumbing_response.policy) 5774 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5775 plumbing_response.rate_limit) 5776 return resp 5777 5778 def list(self, filter, *args, timeout=None): 5779 ''' 5780 List gets a list of Policy matching a given set of criteria 5781 ''' 5782 deadline = None if timeout is None else time.time() + timeout 5783 req = PolicyListRequest() 5784 req.meta.CopyFrom(ListRequestMetadata()) 5785 if self.parent.page_limit > 0: 5786 req.meta.limit = self.parent.page_limit 5787 if self.parent.snapshot_datetime is not None: 5788 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5789 5790 req.filter = plumbing.quote_filter_args(filter, *args) 5791 5792 def generator(svc, req): 5793 tries = 0 5794 while True: 5795 t = None if deadline is None else deadline - time.time() 5796 try: 5797 plumbing_response = svc.stub.List( 5798 req, 5799 metadata=svc.parent.get_metadata('Policies.List', req), 5800 timeout=t) 5801 except Exception as e: 5802 if self.parent.shouldRetry(tries, e, deadline): 5803 tries += 1 5804 time.sleep( 5805 self.parent.exponentialBackoff(tries, deadline)) 5806 continue 5807 raise plumbing.convert_error_to_porcelain(e) from e 5808 tries = 0 5809 for plumbing_item in plumbing_response.policies: 5810 yield plumbing.convert_policy_to_porcelain(plumbing_item) 5811 if plumbing_response.meta.next_cursor == '': 5812 break 5813 req.meta.cursor = plumbing_response.meta.next_cursor 5814 5815 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)
5645 def create(self, policy, timeout=None): 5646 ''' 5647 Create creates a new Policy. 5648 ''' 5649 deadline = None if timeout is None else time.time() + timeout 5650 req = PolicyCreateRequest() 5651 5652 if policy is not None: 5653 req.policy.CopyFrom(plumbing.convert_policy_to_plumbing(policy)) 5654 tries = 0 5655 plumbing_response = None 5656 while True: 5657 t = None if deadline is None else deadline - time.time() 5658 try: 5659 plumbing_response = self.stub.Create( 5660 req, 5661 metadata=self.parent.get_metadata('Policies.Create', req), 5662 timeout=t) 5663 except Exception as e: 5664 if self.parent.shouldRetry(tries, e, deadline): 5665 tries += 1 5666 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5667 continue 5668 raise plumbing.convert_error_to_porcelain(e) from e 5669 break 5670 5671 resp = models.PolicyCreateResponse() 5672 resp.policy = plumbing.convert_policy_to_porcelain( 5673 plumbing_response.policy) 5674 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5675 plumbing_response.rate_limit) 5676 return resp
Create creates a new Policy.
def
delete(self, id, timeout=None)
5678 def delete(self, id, timeout=None): 5679 ''' 5680 Delete removes a Policy by ID. 5681 ''' 5682 deadline = None if timeout is None else time.time() + timeout 5683 req = PolicyDeleteRequest() 5684 5685 req.id = (id) 5686 tries = 0 5687 plumbing_response = None 5688 while True: 5689 t = None if deadline is None else deadline - time.time() 5690 try: 5691 plumbing_response = self.stub.Delete( 5692 req, 5693 metadata=self.parent.get_metadata('Policies.Delete', req), 5694 timeout=t) 5695 except Exception as e: 5696 if self.parent.shouldRetry(tries, e, deadline): 5697 tries += 1 5698 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5699 continue 5700 raise plumbing.convert_error_to_porcelain(e) from e 5701 break 5702 5703 resp = models.PolicyDeleteResponse() 5704 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5705 plumbing_response.rate_limit) 5706 return resp
Delete removes a Policy by ID.
def
update(self, policy, timeout=None)
5708 def update(self, policy, timeout=None): 5709 ''' 5710 Update replaces all the fields of a Policy by ID. 5711 ''' 5712 deadline = None if timeout is None else time.time() + timeout 5713 req = PolicyUpdateRequest() 5714 5715 if policy is not None: 5716 req.policy.CopyFrom(plumbing.convert_policy_to_plumbing(policy)) 5717 tries = 0 5718 plumbing_response = None 5719 while True: 5720 t = None if deadline is None else deadline - time.time() 5721 try: 5722 plumbing_response = self.stub.Update( 5723 req, 5724 metadata=self.parent.get_metadata('Policies.Update', req), 5725 timeout=t) 5726 except Exception as e: 5727 if self.parent.shouldRetry(tries, e, deadline): 5728 tries += 1 5729 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5730 continue 5731 raise plumbing.convert_error_to_porcelain(e) from e 5732 break 5733 5734 resp = models.PolicyUpdateResponse() 5735 resp.policy = plumbing.convert_policy_to_porcelain( 5736 plumbing_response.policy) 5737 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5738 plumbing_response.rate_limit) 5739 return resp
Update replaces all the fields of a Policy by ID.
def
get(self, id, timeout=None)
5741 def get(self, id, timeout=None): 5742 ''' 5743 Get reads one Policy by ID. 5744 ''' 5745 deadline = None if timeout is None else time.time() + timeout 5746 req = PolicyGetRequest() 5747 if self.parent.snapshot_datetime is not None: 5748 req.meta.CopyFrom(GetRequestMetadata()) 5749 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5750 5751 req.id = (id) 5752 tries = 0 5753 plumbing_response = None 5754 while True: 5755 t = None if deadline is None else deadline - time.time() 5756 try: 5757 plumbing_response = self.stub.Get( 5758 req, 5759 metadata=self.parent.get_metadata('Policies.Get', req), 5760 timeout=t) 5761 except Exception as e: 5762 if self.parent.shouldRetry(tries, e, deadline): 5763 tries += 1 5764 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5765 continue 5766 raise plumbing.convert_error_to_porcelain(e) from e 5767 break 5768 5769 resp = models.PolicyGetResponse() 5770 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5771 plumbing_response.meta) 5772 resp.policy = plumbing.convert_policy_to_porcelain( 5773 plumbing_response.policy) 5774 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5775 plumbing_response.rate_limit) 5776 return resp
Get reads one Policy by ID.
def
list(self, filter, *args, timeout=None)
5778 def list(self, filter, *args, timeout=None): 5779 ''' 5780 List gets a list of Policy matching a given set of criteria 5781 ''' 5782 deadline = None if timeout is None else time.time() + timeout 5783 req = PolicyListRequest() 5784 req.meta.CopyFrom(ListRequestMetadata()) 5785 if self.parent.page_limit > 0: 5786 req.meta.limit = self.parent.page_limit 5787 if self.parent.snapshot_datetime is not None: 5788 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5789 5790 req.filter = plumbing.quote_filter_args(filter, *args) 5791 5792 def generator(svc, req): 5793 tries = 0 5794 while True: 5795 t = None if deadline is None else deadline - time.time() 5796 try: 5797 plumbing_response = svc.stub.List( 5798 req, 5799 metadata=svc.parent.get_metadata('Policies.List', req), 5800 timeout=t) 5801 except Exception as e: 5802 if self.parent.shouldRetry(tries, e, deadline): 5803 tries += 1 5804 time.sleep( 5805 self.parent.exponentialBackoff(tries, deadline)) 5806 continue 5807 raise plumbing.convert_error_to_porcelain(e) from e 5808 tries = 0 5809 for plumbing_item in plumbing_response.policies: 5810 yield plumbing.convert_policy_to_porcelain(plumbing_item) 5811 if plumbing_response.meta.next_cursor == '': 5812 break 5813 req.meta.cursor = plumbing_response.meta.next_cursor 5814 5815 return generator(self, req)
List gets a list of Policy matching a given set of criteria
class
SnapshotPolicies:
5818class SnapshotPolicies: 5819 ''' 5820 SnapshotPolicies exposes the read only methods of the Policies 5821 service for historical queries. 5822 ''' 5823 def __init__(self, policies): 5824 self.policies = policies 5825 5826 def get(self, id, timeout=None): 5827 ''' 5828 Get reads one Policy by ID. 5829 ''' 5830 return self.policies.get(id, timeout=timeout) 5831 5832 def list(self, filter, *args, timeout=None): 5833 ''' 5834 List gets a list of Policy matching a given set of criteria 5835 ''' 5836 return self.policies.list(filter, *args, timeout=timeout)
SnapshotPolicies exposes the read only methods of the Policies service for historical queries.
class
PoliciesHistory:
5839class PoliciesHistory: 5840 ''' 5841 PoliciesHistory records all changes to the state of a Policy. 5842 See `strongdm.models.PolicyHistory`. 5843 ''' 5844 def __init__(self, channel, client): 5845 self.parent = client 5846 self.stub = PoliciesHistoryStub(channel) 5847 5848 def list(self, filter, *args, timeout=None): 5849 ''' 5850 List gets a list of PolicyHistory records matching a given set of criteria. 5851 ''' 5852 deadline = None if timeout is None else time.time() + timeout 5853 req = PoliciesHistoryListRequest() 5854 req.meta.CopyFrom(ListRequestMetadata()) 5855 if self.parent.page_limit > 0: 5856 req.meta.limit = self.parent.page_limit 5857 if self.parent.snapshot_datetime is not None: 5858 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5859 5860 req.filter = plumbing.quote_filter_args(filter, *args) 5861 5862 def generator(svc, req): 5863 tries = 0 5864 while True: 5865 t = None if deadline is None else deadline - time.time() 5866 try: 5867 plumbing_response = svc.stub.List( 5868 req, 5869 metadata=svc.parent.get_metadata( 5870 'PoliciesHistory.List', req), 5871 timeout=t) 5872 except Exception as e: 5873 if self.parent.shouldRetry(tries, e, deadline): 5874 tries += 1 5875 time.sleep( 5876 self.parent.exponentialBackoff(tries, deadline)) 5877 continue 5878 raise plumbing.convert_error_to_porcelain(e) from e 5879 tries = 0 5880 for plumbing_item in plumbing_response.history: 5881 yield plumbing.convert_policy_history_to_porcelain( 5882 plumbing_item) 5883 if plumbing_response.meta.next_cursor == '': 5884 break 5885 req.meta.cursor = plumbing_response.meta.next_cursor 5886 5887 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)
5848 def list(self, filter, *args, timeout=None): 5849 ''' 5850 List gets a list of PolicyHistory records matching a given set of criteria. 5851 ''' 5852 deadline = None if timeout is None else time.time() + timeout 5853 req = PoliciesHistoryListRequest() 5854 req.meta.CopyFrom(ListRequestMetadata()) 5855 if self.parent.page_limit > 0: 5856 req.meta.limit = self.parent.page_limit 5857 if self.parent.snapshot_datetime is not None: 5858 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5859 5860 req.filter = plumbing.quote_filter_args(filter, *args) 5861 5862 def generator(svc, req): 5863 tries = 0 5864 while True: 5865 t = None if deadline is None else deadline - time.time() 5866 try: 5867 plumbing_response = svc.stub.List( 5868 req, 5869 metadata=svc.parent.get_metadata( 5870 'PoliciesHistory.List', req), 5871 timeout=t) 5872 except Exception as e: 5873 if self.parent.shouldRetry(tries, e, deadline): 5874 tries += 1 5875 time.sleep( 5876 self.parent.exponentialBackoff(tries, deadline)) 5877 continue 5878 raise plumbing.convert_error_to_porcelain(e) from e 5879 tries = 0 5880 for plumbing_item in plumbing_response.history: 5881 yield plumbing.convert_policy_history_to_porcelain( 5882 plumbing_item) 5883 if plumbing_response.meta.next_cursor == '': 5884 break 5885 req.meta.cursor = plumbing_response.meta.next_cursor 5886 5887 return generator(self, req)
List gets a list of PolicyHistory records matching a given set of criteria.
class
ProxyClusterKeys:
5890class ProxyClusterKeys: 5891 ''' 5892 Proxy Cluster Keys are authentication keys for all proxies within a cluster. 5893 The proxies within a cluster share the same key. One cluster can have 5894 multiple keys in order to facilitate key rotation. 5895 See `strongdm.models.ProxyClusterKey`. 5896 ''' 5897 def __init__(self, channel, client): 5898 self.parent = client 5899 self.stub = ProxyClusterKeysStub(channel) 5900 5901 def create(self, proxy_cluster_key, timeout=None): 5902 ''' 5903 Create registers a new ProxyClusterKey. 5904 ''' 5905 deadline = None if timeout is None else time.time() + timeout 5906 req = ProxyClusterKeyCreateRequest() 5907 5908 if proxy_cluster_key is not None: 5909 req.proxy_cluster_key.CopyFrom( 5910 plumbing.convert_proxy_cluster_key_to_plumbing( 5911 proxy_cluster_key)) 5912 tries = 0 5913 plumbing_response = None 5914 while True: 5915 t = None if deadline is None else deadline - time.time() 5916 try: 5917 plumbing_response = self.stub.Create( 5918 req, 5919 metadata=self.parent.get_metadata( 5920 'ProxyClusterKeys.Create', req), 5921 timeout=t) 5922 except Exception as e: 5923 if self.parent.shouldRetry(tries, e, deadline): 5924 tries += 1 5925 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5926 continue 5927 raise plumbing.convert_error_to_porcelain(e) from e 5928 break 5929 5930 resp = models.ProxyClusterKeyCreateResponse() 5931 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5932 plumbing_response.meta) 5933 resp.proxy_cluster_key = plumbing.convert_proxy_cluster_key_to_porcelain( 5934 plumbing_response.proxy_cluster_key) 5935 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5936 plumbing_response.rate_limit) 5937 resp.secret_key = (plumbing_response.secret_key) 5938 return resp 5939 5940 def get(self, id, timeout=None): 5941 ''' 5942 Get reads one ProxyClusterKey by ID. 5943 ''' 5944 deadline = None if timeout is None else time.time() + timeout 5945 req = ProxyClusterKeyGetRequest() 5946 if self.parent.snapshot_datetime is not None: 5947 req.meta.CopyFrom(GetRequestMetadata()) 5948 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5949 5950 req.id = (id) 5951 tries = 0 5952 plumbing_response = None 5953 while True: 5954 t = None if deadline is None else deadline - time.time() 5955 try: 5956 plumbing_response = self.stub.Get( 5957 req, 5958 metadata=self.parent.get_metadata('ProxyClusterKeys.Get', 5959 req), 5960 timeout=t) 5961 except Exception as e: 5962 if self.parent.shouldRetry(tries, e, deadline): 5963 tries += 1 5964 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5965 continue 5966 raise plumbing.convert_error_to_porcelain(e) from e 5967 break 5968 5969 resp = models.ProxyClusterKeyGetResponse() 5970 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5971 plumbing_response.meta) 5972 resp.proxy_cluster_key = plumbing.convert_proxy_cluster_key_to_porcelain( 5973 plumbing_response.proxy_cluster_key) 5974 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5975 plumbing_response.rate_limit) 5976 return resp 5977 5978 def delete(self, id, timeout=None): 5979 ''' 5980 Delete removes a ProxyClusterKey by ID. 5981 ''' 5982 deadline = None if timeout is None else time.time() + timeout 5983 req = ProxyClusterKeyDeleteRequest() 5984 5985 req.id = (id) 5986 tries = 0 5987 plumbing_response = None 5988 while True: 5989 t = None if deadline is None else deadline - time.time() 5990 try: 5991 plumbing_response = self.stub.Delete( 5992 req, 5993 metadata=self.parent.get_metadata( 5994 'ProxyClusterKeys.Delete', req), 5995 timeout=t) 5996 except Exception as e: 5997 if self.parent.shouldRetry(tries, e, deadline): 5998 tries += 1 5999 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6000 continue 6001 raise plumbing.convert_error_to_porcelain(e) from e 6002 break 6003 6004 resp = models.ProxyClusterKeyDeleteResponse() 6005 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 6006 plumbing_response.meta) 6007 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6008 plumbing_response.rate_limit) 6009 return resp 6010 6011 def list(self, filter, *args, timeout=None): 6012 ''' 6013 List gets a list of ProxyClusterKeys matching a given set of criteria. 6014 ''' 6015 deadline = None if timeout is None else time.time() + timeout 6016 req = ProxyClusterKeyListRequest() 6017 req.meta.CopyFrom(ListRequestMetadata()) 6018 if self.parent.page_limit > 0: 6019 req.meta.limit = self.parent.page_limit 6020 if self.parent.snapshot_datetime is not None: 6021 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6022 6023 req.filter = plumbing.quote_filter_args(filter, *args) 6024 6025 def generator(svc, req): 6026 tries = 0 6027 while True: 6028 t = None if deadline is None else deadline - time.time() 6029 try: 6030 plumbing_response = svc.stub.List( 6031 req, 6032 metadata=svc.parent.get_metadata( 6033 'ProxyClusterKeys.List', req), 6034 timeout=t) 6035 except Exception as e: 6036 if self.parent.shouldRetry(tries, e, deadline): 6037 tries += 1 6038 time.sleep( 6039 self.parent.exponentialBackoff(tries, deadline)) 6040 continue 6041 raise plumbing.convert_error_to_porcelain(e) from e 6042 tries = 0 6043 for plumbing_item in plumbing_response.proxy_cluster_keys: 6044 yield plumbing.convert_proxy_cluster_key_to_porcelain( 6045 plumbing_item) 6046 if plumbing_response.meta.next_cursor == '': 6047 break 6048 req.meta.cursor = plumbing_response.meta.next_cursor 6049 6050 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)
5901 def create(self, proxy_cluster_key, timeout=None): 5902 ''' 5903 Create registers a new ProxyClusterKey. 5904 ''' 5905 deadline = None if timeout is None else time.time() + timeout 5906 req = ProxyClusterKeyCreateRequest() 5907 5908 if proxy_cluster_key is not None: 5909 req.proxy_cluster_key.CopyFrom( 5910 plumbing.convert_proxy_cluster_key_to_plumbing( 5911 proxy_cluster_key)) 5912 tries = 0 5913 plumbing_response = None 5914 while True: 5915 t = None if deadline is None else deadline - time.time() 5916 try: 5917 plumbing_response = self.stub.Create( 5918 req, 5919 metadata=self.parent.get_metadata( 5920 'ProxyClusterKeys.Create', req), 5921 timeout=t) 5922 except Exception as e: 5923 if self.parent.shouldRetry(tries, e, deadline): 5924 tries += 1 5925 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5926 continue 5927 raise plumbing.convert_error_to_porcelain(e) from e 5928 break 5929 5930 resp = models.ProxyClusterKeyCreateResponse() 5931 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5932 plumbing_response.meta) 5933 resp.proxy_cluster_key = plumbing.convert_proxy_cluster_key_to_porcelain( 5934 plumbing_response.proxy_cluster_key) 5935 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5936 plumbing_response.rate_limit) 5937 resp.secret_key = (plumbing_response.secret_key) 5938 return resp
Create registers a new ProxyClusterKey.
def
get(self, id, timeout=None)
5940 def get(self, id, timeout=None): 5941 ''' 5942 Get reads one ProxyClusterKey by ID. 5943 ''' 5944 deadline = None if timeout is None else time.time() + timeout 5945 req = ProxyClusterKeyGetRequest() 5946 if self.parent.snapshot_datetime is not None: 5947 req.meta.CopyFrom(GetRequestMetadata()) 5948 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5949 5950 req.id = (id) 5951 tries = 0 5952 plumbing_response = None 5953 while True: 5954 t = None if deadline is None else deadline - time.time() 5955 try: 5956 plumbing_response = self.stub.Get( 5957 req, 5958 metadata=self.parent.get_metadata('ProxyClusterKeys.Get', 5959 req), 5960 timeout=t) 5961 except Exception as e: 5962 if self.parent.shouldRetry(tries, e, deadline): 5963 tries += 1 5964 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5965 continue 5966 raise plumbing.convert_error_to_porcelain(e) from e 5967 break 5968 5969 resp = models.ProxyClusterKeyGetResponse() 5970 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5971 plumbing_response.meta) 5972 resp.proxy_cluster_key = plumbing.convert_proxy_cluster_key_to_porcelain( 5973 plumbing_response.proxy_cluster_key) 5974 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5975 plumbing_response.rate_limit) 5976 return resp
Get reads one ProxyClusterKey by ID.
def
delete(self, id, timeout=None)
5978 def delete(self, id, timeout=None): 5979 ''' 5980 Delete removes a ProxyClusterKey by ID. 5981 ''' 5982 deadline = None if timeout is None else time.time() + timeout 5983 req = ProxyClusterKeyDeleteRequest() 5984 5985 req.id = (id) 5986 tries = 0 5987 plumbing_response = None 5988 while True: 5989 t = None if deadline is None else deadline - time.time() 5990 try: 5991 plumbing_response = self.stub.Delete( 5992 req, 5993 metadata=self.parent.get_metadata( 5994 'ProxyClusterKeys.Delete', req), 5995 timeout=t) 5996 except Exception as e: 5997 if self.parent.shouldRetry(tries, e, deadline): 5998 tries += 1 5999 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6000 continue 6001 raise plumbing.convert_error_to_porcelain(e) from e 6002 break 6003 6004 resp = models.ProxyClusterKeyDeleteResponse() 6005 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 6006 plumbing_response.meta) 6007 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6008 plumbing_response.rate_limit) 6009 return resp
Delete removes a ProxyClusterKey by ID.
def
list(self, filter, *args, timeout=None)
6011 def list(self, filter, *args, timeout=None): 6012 ''' 6013 List gets a list of ProxyClusterKeys matching a given set of criteria. 6014 ''' 6015 deadline = None if timeout is None else time.time() + timeout 6016 req = ProxyClusterKeyListRequest() 6017 req.meta.CopyFrom(ListRequestMetadata()) 6018 if self.parent.page_limit > 0: 6019 req.meta.limit = self.parent.page_limit 6020 if self.parent.snapshot_datetime is not None: 6021 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6022 6023 req.filter = plumbing.quote_filter_args(filter, *args) 6024 6025 def generator(svc, req): 6026 tries = 0 6027 while True: 6028 t = None if deadline is None else deadline - time.time() 6029 try: 6030 plumbing_response = svc.stub.List( 6031 req, 6032 metadata=svc.parent.get_metadata( 6033 'ProxyClusterKeys.List', req), 6034 timeout=t) 6035 except Exception as e: 6036 if self.parent.shouldRetry(tries, e, deadline): 6037 tries += 1 6038 time.sleep( 6039 self.parent.exponentialBackoff(tries, deadline)) 6040 continue 6041 raise plumbing.convert_error_to_porcelain(e) from e 6042 tries = 0 6043 for plumbing_item in plumbing_response.proxy_cluster_keys: 6044 yield plumbing.convert_proxy_cluster_key_to_porcelain( 6045 plumbing_item) 6046 if plumbing_response.meta.next_cursor == '': 6047 break 6048 req.meta.cursor = plumbing_response.meta.next_cursor 6049 6050 return generator(self, req)
List gets a list of ProxyClusterKeys matching a given set of criteria.
class
SnapshotProxyClusterKeys:
6053class SnapshotProxyClusterKeys: 6054 ''' 6055 SnapshotProxyClusterKeys exposes the read only methods of the ProxyClusterKeys 6056 service for historical queries. 6057 ''' 6058 def __init__(self, proxy_cluster_keys): 6059 self.proxy_cluster_keys = proxy_cluster_keys 6060 6061 def get(self, id, timeout=None): 6062 ''' 6063 Get reads one ProxyClusterKey by ID. 6064 ''' 6065 return self.proxy_cluster_keys.get(id, timeout=timeout) 6066 6067 def list(self, filter, *args, timeout=None): 6068 ''' 6069 List gets a list of ProxyClusterKeys matching a given set of criteria. 6070 ''' 6071 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)
6061 def get(self, id, timeout=None): 6062 ''' 6063 Get reads one ProxyClusterKey by ID. 6064 ''' 6065 return self.proxy_cluster_keys.get(id, timeout=timeout)
Get reads one ProxyClusterKey by ID.
def
list(self, filter, *args, timeout=None)
6067 def list(self, filter, *args, timeout=None): 6068 ''' 6069 List gets a list of ProxyClusterKeys matching a given set of criteria. 6070 ''' 6071 return self.proxy_cluster_keys.list(filter, *args, timeout=timeout)
List gets a list of ProxyClusterKeys matching a given set of criteria.
class
Queries:
6074class Queries: 6075 ''' 6076 A Query is a record of a single client request to a resource, such as a SQL query. 6077 Long-running SSH, RDP, or Kubernetes interactive sessions also count as queries. 6078 The Queries service is read-only. 6079 See `strongdm.models.Query`. 6080 ''' 6081 def __init__(self, channel, client): 6082 self.parent = client 6083 self.stub = QueriesStub(channel) 6084 6085 def list(self, filter, *args, timeout=None): 6086 ''' 6087 List gets a list of Queries matching a given set of criteria. 6088 ''' 6089 deadline = None if timeout is None else time.time() + timeout 6090 req = QueryListRequest() 6091 req.meta.CopyFrom(ListRequestMetadata()) 6092 if self.parent.page_limit > 0: 6093 req.meta.limit = self.parent.page_limit 6094 if self.parent.snapshot_datetime is not None: 6095 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6096 6097 req.filter = plumbing.quote_filter_args(filter, *args) 6098 6099 def generator(svc, req): 6100 tries = 0 6101 while True: 6102 t = None if deadline is None else deadline - time.time() 6103 try: 6104 plumbing_response = svc.stub.List( 6105 req, 6106 metadata=svc.parent.get_metadata('Queries.List', req), 6107 timeout=t) 6108 except Exception as e: 6109 if self.parent.shouldRetry(tries, e, deadline): 6110 tries += 1 6111 time.sleep( 6112 self.parent.exponentialBackoff(tries, deadline)) 6113 continue 6114 raise plumbing.convert_error_to_porcelain(e) from e 6115 tries = 0 6116 for plumbing_item in plumbing_response.queries: 6117 yield plumbing.convert_query_to_porcelain(plumbing_item) 6118 if plumbing_response.meta.next_cursor == '': 6119 break 6120 req.meta.cursor = plumbing_response.meta.next_cursor 6121 6122 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)
6085 def list(self, filter, *args, timeout=None): 6086 ''' 6087 List gets a list of Queries matching a given set of criteria. 6088 ''' 6089 deadline = None if timeout is None else time.time() + timeout 6090 req = QueryListRequest() 6091 req.meta.CopyFrom(ListRequestMetadata()) 6092 if self.parent.page_limit > 0: 6093 req.meta.limit = self.parent.page_limit 6094 if self.parent.snapshot_datetime is not None: 6095 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6096 6097 req.filter = plumbing.quote_filter_args(filter, *args) 6098 6099 def generator(svc, req): 6100 tries = 0 6101 while True: 6102 t = None if deadline is None else deadline - time.time() 6103 try: 6104 plumbing_response = svc.stub.List( 6105 req, 6106 metadata=svc.parent.get_metadata('Queries.List', req), 6107 timeout=t) 6108 except Exception as e: 6109 if self.parent.shouldRetry(tries, e, deadline): 6110 tries += 1 6111 time.sleep( 6112 self.parent.exponentialBackoff(tries, deadline)) 6113 continue 6114 raise plumbing.convert_error_to_porcelain(e) from e 6115 tries = 0 6116 for plumbing_item in plumbing_response.queries: 6117 yield plumbing.convert_query_to_porcelain(plumbing_item) 6118 if plumbing_response.meta.next_cursor == '': 6119 break 6120 req.meta.cursor = plumbing_response.meta.next_cursor 6121 6122 return generator(self, req)
List gets a list of Queries matching a given set of criteria.
class
RemoteIdentities:
6125class RemoteIdentities: 6126 ''' 6127 RemoteIdentities assign a resource directly to an account, giving the account the permission to connect to that resource. 6128 See `strongdm.models.RemoteIdentity`. 6129 ''' 6130 def __init__(self, channel, client): 6131 self.parent = client 6132 self.stub = RemoteIdentitiesStub(channel) 6133 6134 def create(self, remote_identity, timeout=None): 6135 ''' 6136 Create registers a new RemoteIdentity. 6137 ''' 6138 deadline = None if timeout is None else time.time() + timeout 6139 req = RemoteIdentityCreateRequest() 6140 6141 if remote_identity is not None: 6142 req.remote_identity.CopyFrom( 6143 plumbing.convert_remote_identity_to_plumbing(remote_identity)) 6144 tries = 0 6145 plumbing_response = None 6146 while True: 6147 t = None if deadline is None else deadline - time.time() 6148 try: 6149 plumbing_response = self.stub.Create( 6150 req, 6151 metadata=self.parent.get_metadata( 6152 'RemoteIdentities.Create', req), 6153 timeout=t) 6154 except Exception as e: 6155 if self.parent.shouldRetry(tries, e, deadline): 6156 tries += 1 6157 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6158 continue 6159 raise plumbing.convert_error_to_porcelain(e) from e 6160 break 6161 6162 resp = models.RemoteIdentityCreateResponse() 6163 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 6164 plumbing_response.meta) 6165 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6166 plumbing_response.rate_limit) 6167 resp.remote_identity = plumbing.convert_remote_identity_to_porcelain( 6168 plumbing_response.remote_identity) 6169 return resp 6170 6171 def get(self, id, timeout=None): 6172 ''' 6173 Get reads one RemoteIdentity by ID. 6174 ''' 6175 deadline = None if timeout is None else time.time() + timeout 6176 req = RemoteIdentityGetRequest() 6177 if self.parent.snapshot_datetime is not None: 6178 req.meta.CopyFrom(GetRequestMetadata()) 6179 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6180 6181 req.id = (id) 6182 tries = 0 6183 plumbing_response = None 6184 while True: 6185 t = None if deadline is None else deadline - time.time() 6186 try: 6187 plumbing_response = self.stub.Get( 6188 req, 6189 metadata=self.parent.get_metadata('RemoteIdentities.Get', 6190 req), 6191 timeout=t) 6192 except Exception as e: 6193 if self.parent.shouldRetry(tries, e, deadline): 6194 tries += 1 6195 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6196 continue 6197 raise plumbing.convert_error_to_porcelain(e) from e 6198 break 6199 6200 resp = models.RemoteIdentityGetResponse() 6201 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 6202 plumbing_response.meta) 6203 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6204 plumbing_response.rate_limit) 6205 resp.remote_identity = plumbing.convert_remote_identity_to_porcelain( 6206 plumbing_response.remote_identity) 6207 return resp 6208 6209 def update(self, remote_identity, timeout=None): 6210 ''' 6211 Update replaces all the fields of a RemoteIdentity by ID. 6212 ''' 6213 deadline = None if timeout is None else time.time() + timeout 6214 req = RemoteIdentityUpdateRequest() 6215 6216 if remote_identity is not None: 6217 req.remote_identity.CopyFrom( 6218 plumbing.convert_remote_identity_to_plumbing(remote_identity)) 6219 tries = 0 6220 plumbing_response = None 6221 while True: 6222 t = None if deadline is None else deadline - time.time() 6223 try: 6224 plumbing_response = self.stub.Update( 6225 req, 6226 metadata=self.parent.get_metadata( 6227 'RemoteIdentities.Update', req), 6228 timeout=t) 6229 except Exception as e: 6230 if self.parent.shouldRetry(tries, e, deadline): 6231 tries += 1 6232 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6233 continue 6234 raise plumbing.convert_error_to_porcelain(e) from e 6235 break 6236 6237 resp = models.RemoteIdentityUpdateResponse() 6238 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 6239 plumbing_response.meta) 6240 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6241 plumbing_response.rate_limit) 6242 resp.remote_identity = plumbing.convert_remote_identity_to_porcelain( 6243 plumbing_response.remote_identity) 6244 return resp 6245 6246 def delete(self, id, timeout=None): 6247 ''' 6248 Delete removes a RemoteIdentity by ID. 6249 ''' 6250 deadline = None if timeout is None else time.time() + timeout 6251 req = RemoteIdentityDeleteRequest() 6252 6253 req.id = (id) 6254 tries = 0 6255 plumbing_response = None 6256 while True: 6257 t = None if deadline is None else deadline - time.time() 6258 try: 6259 plumbing_response = self.stub.Delete( 6260 req, 6261 metadata=self.parent.get_metadata( 6262 'RemoteIdentities.Delete', req), 6263 timeout=t) 6264 except Exception as e: 6265 if self.parent.shouldRetry(tries, e, deadline): 6266 tries += 1 6267 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6268 continue 6269 raise plumbing.convert_error_to_porcelain(e) from e 6270 break 6271 6272 resp = models.RemoteIdentityDeleteResponse() 6273 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 6274 plumbing_response.meta) 6275 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6276 plumbing_response.rate_limit) 6277 return resp 6278 6279 def list(self, filter, *args, timeout=None): 6280 ''' 6281 List gets a list of RemoteIdentities matching a given set of criteria. 6282 ''' 6283 deadline = None if timeout is None else time.time() + timeout 6284 req = RemoteIdentityListRequest() 6285 req.meta.CopyFrom(ListRequestMetadata()) 6286 if self.parent.page_limit > 0: 6287 req.meta.limit = self.parent.page_limit 6288 if self.parent.snapshot_datetime is not None: 6289 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6290 6291 req.filter = plumbing.quote_filter_args(filter, *args) 6292 6293 def generator(svc, req): 6294 tries = 0 6295 while True: 6296 t = None if deadline is None else deadline - time.time() 6297 try: 6298 plumbing_response = svc.stub.List( 6299 req, 6300 metadata=svc.parent.get_metadata( 6301 'RemoteIdentities.List', req), 6302 timeout=t) 6303 except Exception as e: 6304 if self.parent.shouldRetry(tries, e, deadline): 6305 tries += 1 6306 time.sleep( 6307 self.parent.exponentialBackoff(tries, deadline)) 6308 continue 6309 raise plumbing.convert_error_to_porcelain(e) from e 6310 tries = 0 6311 for plumbing_item in plumbing_response.remote_identities: 6312 yield plumbing.convert_remote_identity_to_porcelain( 6313 plumbing_item) 6314 if plumbing_response.meta.next_cursor == '': 6315 break 6316 req.meta.cursor = plumbing_response.meta.next_cursor 6317 6318 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)
6134 def create(self, remote_identity, timeout=None): 6135 ''' 6136 Create registers a new RemoteIdentity. 6137 ''' 6138 deadline = None if timeout is None else time.time() + timeout 6139 req = RemoteIdentityCreateRequest() 6140 6141 if remote_identity is not None: 6142 req.remote_identity.CopyFrom( 6143 plumbing.convert_remote_identity_to_plumbing(remote_identity)) 6144 tries = 0 6145 plumbing_response = None 6146 while True: 6147 t = None if deadline is None else deadline - time.time() 6148 try: 6149 plumbing_response = self.stub.Create( 6150 req, 6151 metadata=self.parent.get_metadata( 6152 'RemoteIdentities.Create', req), 6153 timeout=t) 6154 except Exception as e: 6155 if self.parent.shouldRetry(tries, e, deadline): 6156 tries += 1 6157 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6158 continue 6159 raise plumbing.convert_error_to_porcelain(e) from e 6160 break 6161 6162 resp = models.RemoteIdentityCreateResponse() 6163 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 6164 plumbing_response.meta) 6165 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6166 plumbing_response.rate_limit) 6167 resp.remote_identity = plumbing.convert_remote_identity_to_porcelain( 6168 plumbing_response.remote_identity) 6169 return resp
Create registers a new RemoteIdentity.
def
get(self, id, timeout=None)
6171 def get(self, id, timeout=None): 6172 ''' 6173 Get reads one RemoteIdentity by ID. 6174 ''' 6175 deadline = None if timeout is None else time.time() + timeout 6176 req = RemoteIdentityGetRequest() 6177 if self.parent.snapshot_datetime is not None: 6178 req.meta.CopyFrom(GetRequestMetadata()) 6179 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6180 6181 req.id = (id) 6182 tries = 0 6183 plumbing_response = None 6184 while True: 6185 t = None if deadline is None else deadline - time.time() 6186 try: 6187 plumbing_response = self.stub.Get( 6188 req, 6189 metadata=self.parent.get_metadata('RemoteIdentities.Get', 6190 req), 6191 timeout=t) 6192 except Exception as e: 6193 if self.parent.shouldRetry(tries, e, deadline): 6194 tries += 1 6195 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6196 continue 6197 raise plumbing.convert_error_to_porcelain(e) from e 6198 break 6199 6200 resp = models.RemoteIdentityGetResponse() 6201 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 6202 plumbing_response.meta) 6203 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6204 plumbing_response.rate_limit) 6205 resp.remote_identity = plumbing.convert_remote_identity_to_porcelain( 6206 plumbing_response.remote_identity) 6207 return resp
Get reads one RemoteIdentity by ID.
def
update(self, remote_identity, timeout=None)
6209 def update(self, remote_identity, timeout=None): 6210 ''' 6211 Update replaces all the fields of a RemoteIdentity by ID. 6212 ''' 6213 deadline = None if timeout is None else time.time() + timeout 6214 req = RemoteIdentityUpdateRequest() 6215 6216 if remote_identity is not None: 6217 req.remote_identity.CopyFrom( 6218 plumbing.convert_remote_identity_to_plumbing(remote_identity)) 6219 tries = 0 6220 plumbing_response = None 6221 while True: 6222 t = None if deadline is None else deadline - time.time() 6223 try: 6224 plumbing_response = self.stub.Update( 6225 req, 6226 metadata=self.parent.get_metadata( 6227 'RemoteIdentities.Update', req), 6228 timeout=t) 6229 except Exception as e: 6230 if self.parent.shouldRetry(tries, e, deadline): 6231 tries += 1 6232 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6233 continue 6234 raise plumbing.convert_error_to_porcelain(e) from e 6235 break 6236 6237 resp = models.RemoteIdentityUpdateResponse() 6238 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 6239 plumbing_response.meta) 6240 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6241 plumbing_response.rate_limit) 6242 resp.remote_identity = plumbing.convert_remote_identity_to_porcelain( 6243 plumbing_response.remote_identity) 6244 return resp
Update replaces all the fields of a RemoteIdentity by ID.
def
delete(self, id, timeout=None)
6246 def delete(self, id, timeout=None): 6247 ''' 6248 Delete removes a RemoteIdentity by ID. 6249 ''' 6250 deadline = None if timeout is None else time.time() + timeout 6251 req = RemoteIdentityDeleteRequest() 6252 6253 req.id = (id) 6254 tries = 0 6255 plumbing_response = None 6256 while True: 6257 t = None if deadline is None else deadline - time.time() 6258 try: 6259 plumbing_response = self.stub.Delete( 6260 req, 6261 metadata=self.parent.get_metadata( 6262 'RemoteIdentities.Delete', req), 6263 timeout=t) 6264 except Exception as e: 6265 if self.parent.shouldRetry(tries, e, deadline): 6266 tries += 1 6267 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6268 continue 6269 raise plumbing.convert_error_to_porcelain(e) from e 6270 break 6271 6272 resp = models.RemoteIdentityDeleteResponse() 6273 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 6274 plumbing_response.meta) 6275 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6276 plumbing_response.rate_limit) 6277 return resp
Delete removes a RemoteIdentity by ID.
def
list(self, filter, *args, timeout=None)
6279 def list(self, filter, *args, timeout=None): 6280 ''' 6281 List gets a list of RemoteIdentities matching a given set of criteria. 6282 ''' 6283 deadline = None if timeout is None else time.time() + timeout 6284 req = RemoteIdentityListRequest() 6285 req.meta.CopyFrom(ListRequestMetadata()) 6286 if self.parent.page_limit > 0: 6287 req.meta.limit = self.parent.page_limit 6288 if self.parent.snapshot_datetime is not None: 6289 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6290 6291 req.filter = plumbing.quote_filter_args(filter, *args) 6292 6293 def generator(svc, req): 6294 tries = 0 6295 while True: 6296 t = None if deadline is None else deadline - time.time() 6297 try: 6298 plumbing_response = svc.stub.List( 6299 req, 6300 metadata=svc.parent.get_metadata( 6301 'RemoteIdentities.List', req), 6302 timeout=t) 6303 except Exception as e: 6304 if self.parent.shouldRetry(tries, e, deadline): 6305 tries += 1 6306 time.sleep( 6307 self.parent.exponentialBackoff(tries, deadline)) 6308 continue 6309 raise plumbing.convert_error_to_porcelain(e) from e 6310 tries = 0 6311 for plumbing_item in plumbing_response.remote_identities: 6312 yield plumbing.convert_remote_identity_to_porcelain( 6313 plumbing_item) 6314 if plumbing_response.meta.next_cursor == '': 6315 break 6316 req.meta.cursor = plumbing_response.meta.next_cursor 6317 6318 return generator(self, req)
List gets a list of RemoteIdentities matching a given set of criteria.
class
SnapshotRemoteIdentities:
6321class SnapshotRemoteIdentities: 6322 ''' 6323 SnapshotRemoteIdentities exposes the read only methods of the RemoteIdentities 6324 service for historical queries. 6325 ''' 6326 def __init__(self, remote_identities): 6327 self.remote_identities = remote_identities 6328 6329 def get(self, id, timeout=None): 6330 ''' 6331 Get reads one RemoteIdentity by ID. 6332 ''' 6333 return self.remote_identities.get(id, timeout=timeout) 6334 6335 def list(self, filter, *args, timeout=None): 6336 ''' 6337 List gets a list of RemoteIdentities matching a given set of criteria. 6338 ''' 6339 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)
6329 def get(self, id, timeout=None): 6330 ''' 6331 Get reads one RemoteIdentity by ID. 6332 ''' 6333 return self.remote_identities.get(id, timeout=timeout)
Get reads one RemoteIdentity by ID.
def
list(self, filter, *args, timeout=None)
6335 def list(self, filter, *args, timeout=None): 6336 ''' 6337 List gets a list of RemoteIdentities matching a given set of criteria. 6338 ''' 6339 return self.remote_identities.list(filter, *args, timeout=timeout)
List gets a list of RemoteIdentities matching a given set of criteria.
class
RemoteIdentitiesHistory:
6342class RemoteIdentitiesHistory: 6343 ''' 6344 RemoteIdentitiesHistory records all changes to the state of a RemoteIdentity. 6345 See `strongdm.models.RemoteIdentityHistory`. 6346 ''' 6347 def __init__(self, channel, client): 6348 self.parent = client 6349 self.stub = RemoteIdentitiesHistoryStub(channel) 6350 6351 def list(self, filter, *args, timeout=None): 6352 ''' 6353 List gets a list of RemoteIdentityHistory records matching a given set of criteria. 6354 ''' 6355 deadline = None if timeout is None else time.time() + timeout 6356 req = RemoteIdentityHistoryListRequest() 6357 req.meta.CopyFrom(ListRequestMetadata()) 6358 if self.parent.page_limit > 0: 6359 req.meta.limit = self.parent.page_limit 6360 if self.parent.snapshot_datetime is not None: 6361 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6362 6363 req.filter = plumbing.quote_filter_args(filter, *args) 6364 6365 def generator(svc, req): 6366 tries = 0 6367 while True: 6368 t = None if deadline is None else deadline - time.time() 6369 try: 6370 plumbing_response = svc.stub.List( 6371 req, 6372 metadata=svc.parent.get_metadata( 6373 'RemoteIdentitiesHistory.List', req), 6374 timeout=t) 6375 except Exception as e: 6376 if self.parent.shouldRetry(tries, e, deadline): 6377 tries += 1 6378 time.sleep( 6379 self.parent.exponentialBackoff(tries, deadline)) 6380 continue 6381 raise plumbing.convert_error_to_porcelain(e) from e 6382 tries = 0 6383 for plumbing_item in plumbing_response.history: 6384 yield plumbing.convert_remote_identity_history_to_porcelain( 6385 plumbing_item) 6386 if plumbing_response.meta.next_cursor == '': 6387 break 6388 req.meta.cursor = plumbing_response.meta.next_cursor 6389 6390 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)
6351 def list(self, filter, *args, timeout=None): 6352 ''' 6353 List gets a list of RemoteIdentityHistory records matching a given set of criteria. 6354 ''' 6355 deadline = None if timeout is None else time.time() + timeout 6356 req = RemoteIdentityHistoryListRequest() 6357 req.meta.CopyFrom(ListRequestMetadata()) 6358 if self.parent.page_limit > 0: 6359 req.meta.limit = self.parent.page_limit 6360 if self.parent.snapshot_datetime is not None: 6361 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6362 6363 req.filter = plumbing.quote_filter_args(filter, *args) 6364 6365 def generator(svc, req): 6366 tries = 0 6367 while True: 6368 t = None if deadline is None else deadline - time.time() 6369 try: 6370 plumbing_response = svc.stub.List( 6371 req, 6372 metadata=svc.parent.get_metadata( 6373 'RemoteIdentitiesHistory.List', req), 6374 timeout=t) 6375 except Exception as e: 6376 if self.parent.shouldRetry(tries, e, deadline): 6377 tries += 1 6378 time.sleep( 6379 self.parent.exponentialBackoff(tries, deadline)) 6380 continue 6381 raise plumbing.convert_error_to_porcelain(e) from e 6382 tries = 0 6383 for plumbing_item in plumbing_response.history: 6384 yield plumbing.convert_remote_identity_history_to_porcelain( 6385 plumbing_item) 6386 if plumbing_response.meta.next_cursor == '': 6387 break 6388 req.meta.cursor = plumbing_response.meta.next_cursor 6389 6390 return generator(self, req)
List gets a list of RemoteIdentityHistory records matching a given set of criteria.
class
RemoteIdentityGroups:
6393class RemoteIdentityGroups: 6394 ''' 6395 A RemoteIdentityGroup is a named grouping of Remote Identities for Accounts. 6396 An Account's relationship to a RemoteIdentityGroup is defined via RemoteIdentity objects. 6397 See `strongdm.models.RemoteIdentityGroup`. 6398 ''' 6399 def __init__(self, channel, client): 6400 self.parent = client 6401 self.stub = RemoteIdentityGroupsStub(channel) 6402 6403 def get(self, id, timeout=None): 6404 ''' 6405 Get reads one RemoteIdentityGroup by ID. 6406 ''' 6407 deadline = None if timeout is None else time.time() + timeout 6408 req = RemoteIdentityGroupGetRequest() 6409 if self.parent.snapshot_datetime is not None: 6410 req.meta.CopyFrom(GetRequestMetadata()) 6411 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6412 6413 req.id = (id) 6414 tries = 0 6415 plumbing_response = None 6416 while True: 6417 t = None if deadline is None else deadline - time.time() 6418 try: 6419 plumbing_response = self.stub.Get( 6420 req, 6421 metadata=self.parent.get_metadata( 6422 'RemoteIdentityGroups.Get', req), 6423 timeout=t) 6424 except Exception as e: 6425 if self.parent.shouldRetry(tries, e, deadline): 6426 tries += 1 6427 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6428 continue 6429 raise plumbing.convert_error_to_porcelain(e) from e 6430 break 6431 6432 resp = models.RemoteIdentityGroupGetResponse() 6433 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 6434 plumbing_response.meta) 6435 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6436 plumbing_response.rate_limit) 6437 resp.remote_identity_group = plumbing.convert_remote_identity_group_to_porcelain( 6438 plumbing_response.remote_identity_group) 6439 return resp 6440 6441 def list(self, filter, *args, timeout=None): 6442 ''' 6443 List gets a list of RemoteIdentityGroups matching a given set of criteria. 6444 ''' 6445 deadline = None if timeout is None else time.time() + timeout 6446 req = RemoteIdentityGroupListRequest() 6447 req.meta.CopyFrom(ListRequestMetadata()) 6448 if self.parent.page_limit > 0: 6449 req.meta.limit = self.parent.page_limit 6450 if self.parent.snapshot_datetime is not None: 6451 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6452 6453 req.filter = plumbing.quote_filter_args(filter, *args) 6454 6455 def generator(svc, req): 6456 tries = 0 6457 while True: 6458 t = None if deadline is None else deadline - time.time() 6459 try: 6460 plumbing_response = svc.stub.List( 6461 req, 6462 metadata=svc.parent.get_metadata( 6463 'RemoteIdentityGroups.List', req), 6464 timeout=t) 6465 except Exception as e: 6466 if self.parent.shouldRetry(tries, e, deadline): 6467 tries += 1 6468 time.sleep( 6469 self.parent.exponentialBackoff(tries, deadline)) 6470 continue 6471 raise plumbing.convert_error_to_porcelain(e) from e 6472 tries = 0 6473 for plumbing_item in plumbing_response.remote_identity_groups: 6474 yield plumbing.convert_remote_identity_group_to_porcelain( 6475 plumbing_item) 6476 if plumbing_response.meta.next_cursor == '': 6477 break 6478 req.meta.cursor = plumbing_response.meta.next_cursor 6479 6480 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)
6403 def get(self, id, timeout=None): 6404 ''' 6405 Get reads one RemoteIdentityGroup by ID. 6406 ''' 6407 deadline = None if timeout is None else time.time() + timeout 6408 req = RemoteIdentityGroupGetRequest() 6409 if self.parent.snapshot_datetime is not None: 6410 req.meta.CopyFrom(GetRequestMetadata()) 6411 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6412 6413 req.id = (id) 6414 tries = 0 6415 plumbing_response = None 6416 while True: 6417 t = None if deadline is None else deadline - time.time() 6418 try: 6419 plumbing_response = self.stub.Get( 6420 req, 6421 metadata=self.parent.get_metadata( 6422 'RemoteIdentityGroups.Get', req), 6423 timeout=t) 6424 except Exception as e: 6425 if self.parent.shouldRetry(tries, e, deadline): 6426 tries += 1 6427 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6428 continue 6429 raise plumbing.convert_error_to_porcelain(e) from e 6430 break 6431 6432 resp = models.RemoteIdentityGroupGetResponse() 6433 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 6434 plumbing_response.meta) 6435 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6436 plumbing_response.rate_limit) 6437 resp.remote_identity_group = plumbing.convert_remote_identity_group_to_porcelain( 6438 plumbing_response.remote_identity_group) 6439 return resp
Get reads one RemoteIdentityGroup by ID.
def
list(self, filter, *args, timeout=None)
6441 def list(self, filter, *args, timeout=None): 6442 ''' 6443 List gets a list of RemoteIdentityGroups matching a given set of criteria. 6444 ''' 6445 deadline = None if timeout is None else time.time() + timeout 6446 req = RemoteIdentityGroupListRequest() 6447 req.meta.CopyFrom(ListRequestMetadata()) 6448 if self.parent.page_limit > 0: 6449 req.meta.limit = self.parent.page_limit 6450 if self.parent.snapshot_datetime is not None: 6451 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6452 6453 req.filter = plumbing.quote_filter_args(filter, *args) 6454 6455 def generator(svc, req): 6456 tries = 0 6457 while True: 6458 t = None if deadline is None else deadline - time.time() 6459 try: 6460 plumbing_response = svc.stub.List( 6461 req, 6462 metadata=svc.parent.get_metadata( 6463 'RemoteIdentityGroups.List', req), 6464 timeout=t) 6465 except Exception as e: 6466 if self.parent.shouldRetry(tries, e, deadline): 6467 tries += 1 6468 time.sleep( 6469 self.parent.exponentialBackoff(tries, deadline)) 6470 continue 6471 raise plumbing.convert_error_to_porcelain(e) from e 6472 tries = 0 6473 for plumbing_item in plumbing_response.remote_identity_groups: 6474 yield plumbing.convert_remote_identity_group_to_porcelain( 6475 plumbing_item) 6476 if plumbing_response.meta.next_cursor == '': 6477 break 6478 req.meta.cursor = plumbing_response.meta.next_cursor 6479 6480 return generator(self, req)
List gets a list of RemoteIdentityGroups matching a given set of criteria.
class
SnapshotRemoteIdentityGroups:
6483class SnapshotRemoteIdentityGroups: 6484 ''' 6485 SnapshotRemoteIdentityGroups exposes the read only methods of the RemoteIdentityGroups 6486 service for historical queries. 6487 ''' 6488 def __init__(self, remote_identity_groups): 6489 self.remote_identity_groups = remote_identity_groups 6490 6491 def get(self, id, timeout=None): 6492 ''' 6493 Get reads one RemoteIdentityGroup by ID. 6494 ''' 6495 return self.remote_identity_groups.get(id, timeout=timeout) 6496 6497 def list(self, filter, *args, timeout=None): 6498 ''' 6499 List gets a list of RemoteIdentityGroups matching a given set of criteria. 6500 ''' 6501 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)
6491 def get(self, id, timeout=None): 6492 ''' 6493 Get reads one RemoteIdentityGroup by ID. 6494 ''' 6495 return self.remote_identity_groups.get(id, timeout=timeout)
Get reads one RemoteIdentityGroup by ID.
def
list(self, filter, *args, timeout=None)
6497 def list(self, filter, *args, timeout=None): 6498 ''' 6499 List gets a list of RemoteIdentityGroups matching a given set of criteria. 6500 ''' 6501 return self.remote_identity_groups.list(filter, *args, timeout=timeout)
List gets a list of RemoteIdentityGroups matching a given set of criteria.
class
RemoteIdentityGroupsHistory:
6504class RemoteIdentityGroupsHistory: 6505 ''' 6506 RemoteIdentityGroupsHistory records all changes to the state of a RemoteIdentityGroup. 6507 See `strongdm.models.RemoteIdentityGroupHistory`. 6508 ''' 6509 def __init__(self, channel, client): 6510 self.parent = client 6511 self.stub = RemoteIdentityGroupsHistoryStub(channel) 6512 6513 def list(self, filter, *args, timeout=None): 6514 ''' 6515 List gets a list of RemoteIdentityGroupHistory records matching a given set of criteria. 6516 ''' 6517 deadline = None if timeout is None else time.time() + timeout 6518 req = RemoteIdentityGroupHistoryListRequest() 6519 req.meta.CopyFrom(ListRequestMetadata()) 6520 if self.parent.page_limit > 0: 6521 req.meta.limit = self.parent.page_limit 6522 if self.parent.snapshot_datetime is not None: 6523 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6524 6525 req.filter = plumbing.quote_filter_args(filter, *args) 6526 6527 def generator(svc, req): 6528 tries = 0 6529 while True: 6530 t = None if deadline is None else deadline - time.time() 6531 try: 6532 plumbing_response = svc.stub.List( 6533 req, 6534 metadata=svc.parent.get_metadata( 6535 'RemoteIdentityGroupsHistory.List', req), 6536 timeout=t) 6537 except Exception as e: 6538 if self.parent.shouldRetry(tries, e, deadline): 6539 tries += 1 6540 time.sleep( 6541 self.parent.exponentialBackoff(tries, deadline)) 6542 continue 6543 raise plumbing.convert_error_to_porcelain(e) from e 6544 tries = 0 6545 for plumbing_item in plumbing_response.history: 6546 yield plumbing.convert_remote_identity_group_history_to_porcelain( 6547 plumbing_item) 6548 if plumbing_response.meta.next_cursor == '': 6549 break 6550 req.meta.cursor = plumbing_response.meta.next_cursor 6551 6552 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)
6513 def list(self, filter, *args, timeout=None): 6514 ''' 6515 List gets a list of RemoteIdentityGroupHistory records matching a given set of criteria. 6516 ''' 6517 deadline = None if timeout is None else time.time() + timeout 6518 req = RemoteIdentityGroupHistoryListRequest() 6519 req.meta.CopyFrom(ListRequestMetadata()) 6520 if self.parent.page_limit > 0: 6521 req.meta.limit = self.parent.page_limit 6522 if self.parent.snapshot_datetime is not None: 6523 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6524 6525 req.filter = plumbing.quote_filter_args(filter, *args) 6526 6527 def generator(svc, req): 6528 tries = 0 6529 while True: 6530 t = None if deadline is None else deadline - time.time() 6531 try: 6532 plumbing_response = svc.stub.List( 6533 req, 6534 metadata=svc.parent.get_metadata( 6535 'RemoteIdentityGroupsHistory.List', req), 6536 timeout=t) 6537 except Exception as e: 6538 if self.parent.shouldRetry(tries, e, deadline): 6539 tries += 1 6540 time.sleep( 6541 self.parent.exponentialBackoff(tries, deadline)) 6542 continue 6543 raise plumbing.convert_error_to_porcelain(e) from e 6544 tries = 0 6545 for plumbing_item in plumbing_response.history: 6546 yield plumbing.convert_remote_identity_group_history_to_porcelain( 6547 plumbing_item) 6548 if plumbing_response.meta.next_cursor == '': 6549 break 6550 req.meta.cursor = plumbing_response.meta.next_cursor 6551 6552 return generator(self, req)
List gets a list of RemoteIdentityGroupHistory records matching a given set of criteria.
class
Replays:
6555class Replays: 6556 ''' 6557 A Replay captures the data transferred over a long-running SSH, RDP, or Kubernetes interactive session 6558 (otherwise referred to as a query). The Replays service is read-only. 6559 See `strongdm.models.ReplayChunk`. 6560 ''' 6561 def __init__(self, channel, client): 6562 self.parent = client 6563 self.stub = ReplaysStub(channel) 6564 6565 def list(self, filter, *args, timeout=None): 6566 ''' 6567 List gets a list of ReplayChunks for the Query ID specified by the filter criteria. 6568 ''' 6569 deadline = None if timeout is None else time.time() + timeout 6570 req = ReplayListRequest() 6571 req.meta.CopyFrom(ListRequestMetadata()) 6572 if self.parent.page_limit > 0: 6573 req.meta.limit = self.parent.page_limit 6574 if self.parent.snapshot_datetime is not None: 6575 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6576 6577 req.filter = plumbing.quote_filter_args(filter, *args) 6578 6579 def generator(svc, req): 6580 tries = 0 6581 while True: 6582 t = None if deadline is None else deadline - time.time() 6583 try: 6584 plumbing_response = svc.stub.List( 6585 req, 6586 metadata=svc.parent.get_metadata('Replays.List', req), 6587 timeout=t) 6588 except Exception as e: 6589 if self.parent.shouldRetry(tries, e, deadline): 6590 tries += 1 6591 time.sleep( 6592 self.parent.exponentialBackoff(tries, deadline)) 6593 continue 6594 raise plumbing.convert_error_to_porcelain(e) from e 6595 tries = 0 6596 for plumbing_item in plumbing_response.chunks: 6597 yield plumbing.convert_replay_chunk_to_porcelain( 6598 plumbing_item) 6599 if plumbing_response.meta.next_cursor == '': 6600 break 6601 req.meta.cursor = plumbing_response.meta.next_cursor 6602 6603 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)
6565 def list(self, filter, *args, timeout=None): 6566 ''' 6567 List gets a list of ReplayChunks for the Query ID specified by the filter criteria. 6568 ''' 6569 deadline = None if timeout is None else time.time() + timeout 6570 req = ReplayListRequest() 6571 req.meta.CopyFrom(ListRequestMetadata()) 6572 if self.parent.page_limit > 0: 6573 req.meta.limit = self.parent.page_limit 6574 if self.parent.snapshot_datetime is not None: 6575 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6576 6577 req.filter = plumbing.quote_filter_args(filter, *args) 6578 6579 def generator(svc, req): 6580 tries = 0 6581 while True: 6582 t = None if deadline is None else deadline - time.time() 6583 try: 6584 plumbing_response = svc.stub.List( 6585 req, 6586 metadata=svc.parent.get_metadata('Replays.List', req), 6587 timeout=t) 6588 except Exception as e: 6589 if self.parent.shouldRetry(tries, e, deadline): 6590 tries += 1 6591 time.sleep( 6592 self.parent.exponentialBackoff(tries, deadline)) 6593 continue 6594 raise plumbing.convert_error_to_porcelain(e) from e 6595 tries = 0 6596 for plumbing_item in plumbing_response.chunks: 6597 yield plumbing.convert_replay_chunk_to_porcelain( 6598 plumbing_item) 6599 if plumbing_response.meta.next_cursor == '': 6600 break 6601 req.meta.cursor = plumbing_response.meta.next_cursor 6602 6603 return generator(self, req)
List gets a list of ReplayChunks for the Query ID specified by the filter criteria.
class
RequestableAccountEntitlements:
6606class RequestableAccountEntitlements: 6607 ''' 6608 RequestableAccountEntitlements enumerates the resources that an account is permitted to request access to. 6609 The RequestableAccountEntitlements service is read-only. 6610 See `strongdm.models.RequestableAccountEntitlement`. 6611 ''' 6612 def __init__(self, channel, client): 6613 self.parent = client 6614 self.stub = RequestableAccountEntitlementsStub(channel) 6615 6616 def list(self, account_id, filter, *args, timeout=None): 6617 ''' 6618 List gets a list of RequestableAccountEntitlement records matching a given set of criteria. 6619 ''' 6620 deadline = None if timeout is None else time.time() + timeout 6621 req = RequestableAccountEntitlementListRequest() 6622 req.meta.CopyFrom(ListRequestMetadata()) 6623 if self.parent.page_limit > 0: 6624 req.meta.limit = self.parent.page_limit 6625 if self.parent.snapshot_datetime is not None: 6626 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6627 6628 req.account_id = (account_id) 6629 req.filter = plumbing.quote_filter_args(filter, *args) 6630 6631 def generator(svc, req): 6632 tries = 0 6633 while True: 6634 t = None if deadline is None else deadline - time.time() 6635 try: 6636 plumbing_response = svc.stub.List( 6637 req, 6638 metadata=svc.parent.get_metadata( 6639 'RequestableAccountEntitlements.List', req), 6640 timeout=t) 6641 except Exception as e: 6642 if self.parent.shouldRetry(tries, e, deadline): 6643 tries += 1 6644 time.sleep( 6645 self.parent.exponentialBackoff(tries, deadline)) 6646 continue 6647 raise plumbing.convert_error_to_porcelain(e) from e 6648 tries = 0 6649 for plumbing_item in plumbing_response.requestable_account_entitlements: 6650 yield plumbing.convert_requestable_account_entitlement_to_porcelain( 6651 plumbing_item) 6652 if plumbing_response.meta.next_cursor == '': 6653 break 6654 req.meta.cursor = plumbing_response.meta.next_cursor 6655 6656 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)
6616 def list(self, account_id, filter, *args, timeout=None): 6617 ''' 6618 List gets a list of RequestableAccountEntitlement records matching a given set of criteria. 6619 ''' 6620 deadline = None if timeout is None else time.time() + timeout 6621 req = RequestableAccountEntitlementListRequest() 6622 req.meta.CopyFrom(ListRequestMetadata()) 6623 if self.parent.page_limit > 0: 6624 req.meta.limit = self.parent.page_limit 6625 if self.parent.snapshot_datetime is not None: 6626 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6627 6628 req.account_id = (account_id) 6629 req.filter = plumbing.quote_filter_args(filter, *args) 6630 6631 def generator(svc, req): 6632 tries = 0 6633 while True: 6634 t = None if deadline is None else deadline - time.time() 6635 try: 6636 plumbing_response = svc.stub.List( 6637 req, 6638 metadata=svc.parent.get_metadata( 6639 'RequestableAccountEntitlements.List', req), 6640 timeout=t) 6641 except Exception as e: 6642 if self.parent.shouldRetry(tries, e, deadline): 6643 tries += 1 6644 time.sleep( 6645 self.parent.exponentialBackoff(tries, deadline)) 6646 continue 6647 raise plumbing.convert_error_to_porcelain(e) from e 6648 tries = 0 6649 for plumbing_item in plumbing_response.requestable_account_entitlements: 6650 yield plumbing.convert_requestable_account_entitlement_to_porcelain( 6651 plumbing_item) 6652 if plumbing_response.meta.next_cursor == '': 6653 break 6654 req.meta.cursor = plumbing_response.meta.next_cursor 6655 6656 return generator(self, req)
List gets a list of RequestableAccountEntitlement records matching a given set of criteria.
class
SnapshotRequestableAccountEntitlements:
6659class SnapshotRequestableAccountEntitlements: 6660 ''' 6661 SnapshotRequestableAccountEntitlements exposes the read only methods of the RequestableAccountEntitlements 6662 service for historical queries. 6663 ''' 6664 def __init__(self, requestable_account_entitlements): 6665 self.requestable_account_entitlements = requestable_account_entitlements 6666 6667 def list(self, account_id, filter, *args, timeout=None): 6668 ''' 6669 List gets a list of RequestableAccountEntitlement records matching a given set of criteria. 6670 ''' 6671 return self.requestable_account_entitlements.list(account_id, 6672 filter, 6673 *args, 6674 timeout=timeout)
SnapshotRequestableAccountEntitlements exposes the read only methods of the RequestableAccountEntitlements service for historical queries.
def
list(self, account_id, filter, *args, timeout=None)
6667 def list(self, account_id, filter, *args, timeout=None): 6668 ''' 6669 List gets a list of RequestableAccountEntitlement records matching a given set of criteria. 6670 ''' 6671 return self.requestable_account_entitlements.list(account_id, 6672 filter, 6673 *args, 6674 timeout=timeout)
List gets a list of RequestableAccountEntitlement records matching a given set of criteria.
class
RequestableResourceEntitlements:
6677class RequestableResourceEntitlements: 6678 ''' 6679 RequestableResourceEntitlements enumerates the accounts that are permitted to request access to a given resource. 6680 The RequestableResourceEntitlements service is read-only. 6681 See `strongdm.models.RequestableResourceEntitlement`. 6682 ''' 6683 def __init__(self, channel, client): 6684 self.parent = client 6685 self.stub = RequestableResourceEntitlementsStub(channel) 6686 6687 def list(self, resource_id, filter, *args, timeout=None): 6688 ''' 6689 List gets a list of RequestableResourceEntitlement records matching a given set of criteria. 6690 ''' 6691 deadline = None if timeout is None else time.time() + timeout 6692 req = RequestableResourceEntitlementListRequest() 6693 req.meta.CopyFrom(ListRequestMetadata()) 6694 if self.parent.page_limit > 0: 6695 req.meta.limit = self.parent.page_limit 6696 if self.parent.snapshot_datetime is not None: 6697 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6698 6699 req.resource_id = (resource_id) 6700 req.filter = plumbing.quote_filter_args(filter, *args) 6701 6702 def generator(svc, req): 6703 tries = 0 6704 while True: 6705 t = None if deadline is None else deadline - time.time() 6706 try: 6707 plumbing_response = svc.stub.List( 6708 req, 6709 metadata=svc.parent.get_metadata( 6710 'RequestableResourceEntitlements.List', req), 6711 timeout=t) 6712 except Exception as e: 6713 if self.parent.shouldRetry(tries, e, deadline): 6714 tries += 1 6715 time.sleep( 6716 self.parent.exponentialBackoff(tries, deadline)) 6717 continue 6718 raise plumbing.convert_error_to_porcelain(e) from e 6719 tries = 0 6720 for plumbing_item in plumbing_response.requestable_resource_entitlements: 6721 yield plumbing.convert_requestable_resource_entitlement_to_porcelain( 6722 plumbing_item) 6723 if plumbing_response.meta.next_cursor == '': 6724 break 6725 req.meta.cursor = plumbing_response.meta.next_cursor 6726 6727 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)
6687 def list(self, resource_id, filter, *args, timeout=None): 6688 ''' 6689 List gets a list of RequestableResourceEntitlement records matching a given set of criteria. 6690 ''' 6691 deadline = None if timeout is None else time.time() + timeout 6692 req = RequestableResourceEntitlementListRequest() 6693 req.meta.CopyFrom(ListRequestMetadata()) 6694 if self.parent.page_limit > 0: 6695 req.meta.limit = self.parent.page_limit 6696 if self.parent.snapshot_datetime is not None: 6697 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6698 6699 req.resource_id = (resource_id) 6700 req.filter = plumbing.quote_filter_args(filter, *args) 6701 6702 def generator(svc, req): 6703 tries = 0 6704 while True: 6705 t = None if deadline is None else deadline - time.time() 6706 try: 6707 plumbing_response = svc.stub.List( 6708 req, 6709 metadata=svc.parent.get_metadata( 6710 'RequestableResourceEntitlements.List', req), 6711 timeout=t) 6712 except Exception as e: 6713 if self.parent.shouldRetry(tries, e, deadline): 6714 tries += 1 6715 time.sleep( 6716 self.parent.exponentialBackoff(tries, deadline)) 6717 continue 6718 raise plumbing.convert_error_to_porcelain(e) from e 6719 tries = 0 6720 for plumbing_item in plumbing_response.requestable_resource_entitlements: 6721 yield plumbing.convert_requestable_resource_entitlement_to_porcelain( 6722 plumbing_item) 6723 if plumbing_response.meta.next_cursor == '': 6724 break 6725 req.meta.cursor = plumbing_response.meta.next_cursor 6726 6727 return generator(self, req)
List gets a list of RequestableResourceEntitlement records matching a given set of criteria.
class
SnapshotRequestableResourceEntitlements:
6730class SnapshotRequestableResourceEntitlements: 6731 ''' 6732 SnapshotRequestableResourceEntitlements exposes the read only methods of the RequestableResourceEntitlements 6733 service for historical queries. 6734 ''' 6735 def __init__(self, requestable_resource_entitlements): 6736 self.requestable_resource_entitlements = requestable_resource_entitlements 6737 6738 def list(self, resource_id, filter, *args, timeout=None): 6739 ''' 6740 List gets a list of RequestableResourceEntitlement records matching a given set of criteria. 6741 ''' 6742 return self.requestable_resource_entitlements.list(resource_id, 6743 filter, 6744 *args, 6745 timeout=timeout)
SnapshotRequestableResourceEntitlements exposes the read only methods of the RequestableResourceEntitlements service for historical queries.
def
list(self, resource_id, filter, *args, timeout=None)
6738 def list(self, resource_id, filter, *args, timeout=None): 6739 ''' 6740 List gets a list of RequestableResourceEntitlement records matching a given set of criteria. 6741 ''' 6742 return self.requestable_resource_entitlements.list(resource_id, 6743 filter, 6744 *args, 6745 timeout=timeout)
List gets a list of RequestableResourceEntitlement records matching a given set of criteria.
class
RequestableRoleEntitlements:
6748class RequestableRoleEntitlements: 6749 ''' 6750 RequestableRoleEntitlements enumerates the resources that a role permits its members to request access to. 6751 The RequestableRoleEntitlements service is read-only. 6752 See `strongdm.models.RequestableRoleEntitlement`. 6753 ''' 6754 def __init__(self, channel, client): 6755 self.parent = client 6756 self.stub = RequestableRoleEntitlementsStub(channel) 6757 6758 def list(self, role_id, filter, *args, timeout=None): 6759 ''' 6760 List gets a list of RequestableRoleEntitlement records matching a given set of criteria. 6761 ''' 6762 deadline = None if timeout is None else time.time() + timeout 6763 req = RequestableRoleEntitlementListRequest() 6764 req.meta.CopyFrom(ListRequestMetadata()) 6765 if self.parent.page_limit > 0: 6766 req.meta.limit = self.parent.page_limit 6767 if self.parent.snapshot_datetime is not None: 6768 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6769 6770 req.role_id = (role_id) 6771 req.filter = plumbing.quote_filter_args(filter, *args) 6772 6773 def generator(svc, req): 6774 tries = 0 6775 while True: 6776 t = None if deadline is None else deadline - time.time() 6777 try: 6778 plumbing_response = svc.stub.List( 6779 req, 6780 metadata=svc.parent.get_metadata( 6781 'RequestableRoleEntitlements.List', req), 6782 timeout=t) 6783 except Exception as e: 6784 if self.parent.shouldRetry(tries, e, deadline): 6785 tries += 1 6786 time.sleep( 6787 self.parent.exponentialBackoff(tries, deadline)) 6788 continue 6789 raise plumbing.convert_error_to_porcelain(e) from e 6790 tries = 0 6791 for plumbing_item in plumbing_response.requestable_role_entitlements: 6792 yield plumbing.convert_requestable_role_entitlement_to_porcelain( 6793 plumbing_item) 6794 if plumbing_response.meta.next_cursor == '': 6795 break 6796 req.meta.cursor = plumbing_response.meta.next_cursor 6797 6798 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)
6758 def list(self, role_id, filter, *args, timeout=None): 6759 ''' 6760 List gets a list of RequestableRoleEntitlement records matching a given set of criteria. 6761 ''' 6762 deadline = None if timeout is None else time.time() + timeout 6763 req = RequestableRoleEntitlementListRequest() 6764 req.meta.CopyFrom(ListRequestMetadata()) 6765 if self.parent.page_limit > 0: 6766 req.meta.limit = self.parent.page_limit 6767 if self.parent.snapshot_datetime is not None: 6768 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6769 6770 req.role_id = (role_id) 6771 req.filter = plumbing.quote_filter_args(filter, *args) 6772 6773 def generator(svc, req): 6774 tries = 0 6775 while True: 6776 t = None if deadline is None else deadline - time.time() 6777 try: 6778 plumbing_response = svc.stub.List( 6779 req, 6780 metadata=svc.parent.get_metadata( 6781 'RequestableRoleEntitlements.List', req), 6782 timeout=t) 6783 except Exception as e: 6784 if self.parent.shouldRetry(tries, e, deadline): 6785 tries += 1 6786 time.sleep( 6787 self.parent.exponentialBackoff(tries, deadline)) 6788 continue 6789 raise plumbing.convert_error_to_porcelain(e) from e 6790 tries = 0 6791 for plumbing_item in plumbing_response.requestable_role_entitlements: 6792 yield plumbing.convert_requestable_role_entitlement_to_porcelain( 6793 plumbing_item) 6794 if plumbing_response.meta.next_cursor == '': 6795 break 6796 req.meta.cursor = plumbing_response.meta.next_cursor 6797 6798 return generator(self, req)
List gets a list of RequestableRoleEntitlement records matching a given set of criteria.
class
SnapshotRequestableRoleEntitlements:
6801class SnapshotRequestableRoleEntitlements: 6802 ''' 6803 SnapshotRequestableRoleEntitlements exposes the read only methods of the RequestableRoleEntitlements 6804 service for historical queries. 6805 ''' 6806 def __init__(self, requestable_role_entitlements): 6807 self.requestable_role_entitlements = requestable_role_entitlements 6808 6809 def list(self, role_id, filter, *args, timeout=None): 6810 ''' 6811 List gets a list of RequestableRoleEntitlement records matching a given set of criteria. 6812 ''' 6813 return self.requestable_role_entitlements.list(role_id, 6814 filter, 6815 *args, 6816 timeout=timeout)
SnapshotRequestableRoleEntitlements exposes the read only methods of the RequestableRoleEntitlements service for historical queries.
def
list(self, role_id, filter, *args, timeout=None)
6809 def list(self, role_id, filter, *args, timeout=None): 6810 ''' 6811 List gets a list of RequestableRoleEntitlement records matching a given set of criteria. 6812 ''' 6813 return self.requestable_role_entitlements.list(role_id, 6814 filter, 6815 *args, 6816 timeout=timeout)
List gets a list of RequestableRoleEntitlement records matching a given set of criteria.
class
Resources:
6819class Resources: 6820 ''' 6821 Resources are databases, servers, clusters, websites, or clouds that strongDM 6822 delegates access to. 6823 See: 6824 `strongdm.models.Aerospike` 6825 `strongdm.models.AKS` 6826 `strongdm.models.AKSBasicAuth` 6827 `strongdm.models.AKSServiceAccount` 6828 `strongdm.models.AKSServiceAccountUserImpersonation` 6829 `strongdm.models.AKSUserImpersonation` 6830 `strongdm.models.AmazonEKS` 6831 `strongdm.models.AmazonEKSInstanceProfile` 6832 `strongdm.models.AmazonEKSInstanceProfileUserImpersonation` 6833 `strongdm.models.AmazonEKSUserImpersonation` 6834 `strongdm.models.AmazonES` 6835 `strongdm.models.AmazonESIAM` 6836 `strongdm.models.AmazonMQAMQP091` 6837 `strongdm.models.AMQP` 6838 `strongdm.models.Athena` 6839 `strongdm.models.AthenaIAM` 6840 `strongdm.models.AuroraMysql` 6841 `strongdm.models.AuroraMysqlIAM` 6842 `strongdm.models.AuroraPostgres` 6843 `strongdm.models.AuroraPostgresIAM` 6844 `strongdm.models.AWS` 6845 `strongdm.models.AWSConsole` 6846 `strongdm.models.AWSConsoleStaticKeyPair` 6847 `strongdm.models.AWSInstanceProfile` 6848 `strongdm.models.Azure` 6849 `strongdm.models.AzureCertificate` 6850 `strongdm.models.AzureMysql` 6851 `strongdm.models.AzureMysqlManagedIdentity` 6852 `strongdm.models.AzurePostgres` 6853 `strongdm.models.AzurePostgresManagedIdentity` 6854 `strongdm.models.BigQuery` 6855 `strongdm.models.Cassandra` 6856 `strongdm.models.Citus` 6857 `strongdm.models.ClickHouseHTTP` 6858 `strongdm.models.ClickHouseMySQL` 6859 `strongdm.models.ClickHouseTCP` 6860 `strongdm.models.Clustrix` 6861 `strongdm.models.Cockroach` 6862 `strongdm.models.CouchbaseDatabase` 6863 `strongdm.models.CouchbaseWebUI` 6864 `strongdm.models.Databricks` 6865 `strongdm.models.DB2I` 6866 `strongdm.models.DB2LUW` 6867 `strongdm.models.DocumentDBHost` 6868 `strongdm.models.DocumentDBHostIAM` 6869 `strongdm.models.DocumentDBReplicaSet` 6870 `strongdm.models.DocumentDBReplicaSetIAM` 6871 `strongdm.models.Druid` 6872 `strongdm.models.DynamoDB` 6873 `strongdm.models.DynamoDBIAM` 6874 `strongdm.models.Elastic` 6875 `strongdm.models.ElasticacheRedis` 6876 `strongdm.models.ElasticacheRedisIAM` 6877 `strongdm.models.EntraID` 6878 `strongdm.models.GCP` 6879 `strongdm.models.GCPConsole` 6880 `strongdm.models.GCPWIF` 6881 `strongdm.models.GoogleGKE` 6882 `strongdm.models.GoogleGKEUserImpersonation` 6883 `strongdm.models.GoogleSpanner` 6884 `strongdm.models.Greenplum` 6885 `strongdm.models.HTTPAuth` 6886 `strongdm.models.HTTPBasicAuth` 6887 `strongdm.models.HTTPNoAuth` 6888 `strongdm.models.Kubernetes` 6889 `strongdm.models.KubernetesBasicAuth` 6890 `strongdm.models.KubernetesPodIdentity` 6891 `strongdm.models.KubernetesServiceAccount` 6892 `strongdm.models.KubernetesServiceAccountUserImpersonation` 6893 `strongdm.models.KubernetesUserImpersonation` 6894 `strongdm.models.Maria` 6895 `strongdm.models.MCPGatewayNoAuth` 6896 `strongdm.models.MCPGatewayOAuth` 6897 `strongdm.models.MCPGatewayOAuthDCR` 6898 `strongdm.models.MCPGatewayPAT` 6899 `strongdm.models.Memcached` 6900 `strongdm.models.Memsql` 6901 `strongdm.models.MongoHost` 6902 `strongdm.models.MongoLegacyHost` 6903 `strongdm.models.MongoLegacyReplicaset` 6904 `strongdm.models.MongoReplicaSet` 6905 `strongdm.models.MongoShardedCluster` 6906 `strongdm.models.MTLSMysql` 6907 `strongdm.models.MTLSPostgres` 6908 `strongdm.models.Mysql` 6909 `strongdm.models.Neptune` 6910 `strongdm.models.NeptuneIAM` 6911 `strongdm.models.OktaGroups` 6912 `strongdm.models.Oracle` 6913 `strongdm.models.OracleNNE` 6914 `strongdm.models.Postgres` 6915 `strongdm.models.Presto` 6916 `strongdm.models.RabbitMQAMQP091` 6917 `strongdm.models.RawTCP` 6918 `strongdm.models.RDP` 6919 `strongdm.models.RDPCert` 6920 `strongdm.models.RDSPostgresIAM` 6921 `strongdm.models.Redis` 6922 `strongdm.models.RedisCluster` 6923 `strongdm.models.Redshift` 6924 `strongdm.models.RedshiftIAM` 6925 `strongdm.models.RedshiftServerlessIAM` 6926 `strongdm.models.SingleStore` 6927 `strongdm.models.Snowflake` 6928 `strongdm.models.Snowsight` 6929 `strongdm.models.SQLServer` 6930 `strongdm.models.SQLServerAzureAD` 6931 `strongdm.models.SQLServerKerberosAD` 6932 `strongdm.models.SSH` 6933 `strongdm.models.SSHCert` 6934 `strongdm.models.SSHCustomerKey` 6935 `strongdm.models.SSHPassword` 6936 `strongdm.models.Sybase` 6937 `strongdm.models.SybaseIQ` 6938 `strongdm.models.Teradata` 6939 `strongdm.models.Trino` 6940 `strongdm.models.Vertica` 6941 ''' 6942 def __init__(self, channel, client): 6943 self.parent = client 6944 self.stub = ResourcesStub(channel) 6945 6946 def enumerate_tags(self, filter, *args, timeout=None): 6947 ''' 6948 EnumerateTags gets a list of the filter matching tags. 6949 ''' 6950 deadline = None if timeout is None else time.time() + timeout 6951 req = EnumerateTagsRequest() 6952 req.meta.CopyFrom(ListRequestMetadata()) 6953 if self.parent.page_limit > 0: 6954 req.meta.limit = self.parent.page_limit 6955 if self.parent.snapshot_datetime is not None: 6956 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6957 6958 req.filter = plumbing.quote_filter_args(filter, *args) 6959 6960 def generator(svc, req): 6961 tries = 0 6962 while True: 6963 t = None if deadline is None else deadline - time.time() 6964 try: 6965 plumbing_response = svc.stub.EnumerateTags( 6966 req, 6967 metadata=svc.parent.get_metadata( 6968 'Resources.EnumerateTags', req), 6969 timeout=t) 6970 except Exception as e: 6971 if self.parent.shouldRetry(tries, e, deadline): 6972 tries += 1 6973 time.sleep( 6974 self.parent.exponentialBackoff(tries, deadline)) 6975 continue 6976 raise plumbing.convert_error_to_porcelain(e) from e 6977 tries = 0 6978 for plumbing_item in plumbing_response.matches: 6979 yield plumbing.convert_tag_to_porcelain(plumbing_item) 6980 if plumbing_response.meta.next_cursor == '': 6981 break 6982 req.meta.cursor = plumbing_response.meta.next_cursor 6983 6984 return generator(self, req) 6985 6986 def create(self, resource, timeout=None): 6987 ''' 6988 Create registers a new Resource. 6989 ''' 6990 deadline = None if timeout is None else time.time() + timeout 6991 req = ResourceCreateRequest() 6992 6993 if resource is not None: 6994 req.resource.CopyFrom( 6995 plumbing.convert_resource_to_plumbing(resource)) 6996 tries = 0 6997 plumbing_response = None 6998 while True: 6999 t = None if deadline is None else deadline - time.time() 7000 try: 7001 plumbing_response = self.stub.Create( 7002 req, 7003 metadata=self.parent.get_metadata('Resources.Create', req), 7004 timeout=t) 7005 except Exception as e: 7006 if self.parent.shouldRetry(tries, e, deadline): 7007 tries += 1 7008 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7009 continue 7010 raise plumbing.convert_error_to_porcelain(e) from e 7011 break 7012 7013 resp = models.ResourceCreateResponse() 7014 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 7015 plumbing_response.meta) 7016 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7017 plumbing_response.rate_limit) 7018 resp.resource = plumbing.convert_resource_to_porcelain( 7019 plumbing_response.resource) 7020 return resp 7021 7022 def get(self, id, timeout=None): 7023 ''' 7024 Get reads one Resource by ID. 7025 ''' 7026 deadline = None if timeout is None else time.time() + timeout 7027 req = ResourceGetRequest() 7028 if self.parent.snapshot_datetime is not None: 7029 req.meta.CopyFrom(GetRequestMetadata()) 7030 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7031 7032 req.id = (id) 7033 tries = 0 7034 plumbing_response = None 7035 while True: 7036 t = None if deadline is None else deadline - time.time() 7037 try: 7038 plumbing_response = self.stub.Get( 7039 req, 7040 metadata=self.parent.get_metadata('Resources.Get', req), 7041 timeout=t) 7042 except Exception as e: 7043 if self.parent.shouldRetry(tries, e, deadline): 7044 tries += 1 7045 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7046 continue 7047 raise plumbing.convert_error_to_porcelain(e) from e 7048 break 7049 7050 resp = models.ResourceGetResponse() 7051 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 7052 plumbing_response.meta) 7053 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7054 plumbing_response.rate_limit) 7055 resp.resource = plumbing.convert_resource_to_porcelain( 7056 plumbing_response.resource) 7057 return resp 7058 7059 def update(self, resource, timeout=None): 7060 ''' 7061 Update replaces all the fields of a Resource by ID. 7062 ''' 7063 deadline = None if timeout is None else time.time() + timeout 7064 req = ResourceUpdateRequest() 7065 7066 if resource is not None: 7067 req.resource.CopyFrom( 7068 plumbing.convert_resource_to_plumbing(resource)) 7069 tries = 0 7070 plumbing_response = None 7071 while True: 7072 t = None if deadline is None else deadline - time.time() 7073 try: 7074 plumbing_response = self.stub.Update( 7075 req, 7076 metadata=self.parent.get_metadata('Resources.Update', req), 7077 timeout=t) 7078 except Exception as e: 7079 if self.parent.shouldRetry(tries, e, deadline): 7080 tries += 1 7081 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7082 continue 7083 raise plumbing.convert_error_to_porcelain(e) from e 7084 break 7085 7086 resp = models.ResourceUpdateResponse() 7087 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 7088 plumbing_response.meta) 7089 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7090 plumbing_response.rate_limit) 7091 resp.resource = plumbing.convert_resource_to_porcelain( 7092 plumbing_response.resource) 7093 return resp 7094 7095 def delete(self, id, timeout=None): 7096 ''' 7097 Delete removes a Resource by ID. 7098 ''' 7099 deadline = None if timeout is None else time.time() + timeout 7100 req = ResourceDeleteRequest() 7101 7102 req.id = (id) 7103 tries = 0 7104 plumbing_response = None 7105 while True: 7106 t = None if deadline is None else deadline - time.time() 7107 try: 7108 plumbing_response = self.stub.Delete( 7109 req, 7110 metadata=self.parent.get_metadata('Resources.Delete', req), 7111 timeout=t) 7112 except Exception as e: 7113 if self.parent.shouldRetry(tries, e, deadline): 7114 tries += 1 7115 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7116 continue 7117 raise plumbing.convert_error_to_porcelain(e) from e 7118 break 7119 7120 resp = models.ResourceDeleteResponse() 7121 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 7122 plumbing_response.meta) 7123 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7124 plumbing_response.rate_limit) 7125 return resp 7126 7127 def list(self, filter, *args, timeout=None): 7128 ''' 7129 List gets a list of Resources matching a given set of criteria. 7130 ''' 7131 deadline = None if timeout is None else time.time() + timeout 7132 req = ResourceListRequest() 7133 req.meta.CopyFrom(ListRequestMetadata()) 7134 if self.parent.page_limit > 0: 7135 req.meta.limit = self.parent.page_limit 7136 if self.parent.snapshot_datetime is not None: 7137 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7138 7139 req.filter = plumbing.quote_filter_args(filter, *args) 7140 7141 def generator(svc, req): 7142 tries = 0 7143 while True: 7144 t = None if deadline is None else deadline - time.time() 7145 try: 7146 plumbing_response = svc.stub.List( 7147 req, 7148 metadata=svc.parent.get_metadata( 7149 'Resources.List', req), 7150 timeout=t) 7151 except Exception as e: 7152 if self.parent.shouldRetry(tries, e, deadline): 7153 tries += 1 7154 time.sleep( 7155 self.parent.exponentialBackoff(tries, deadline)) 7156 continue 7157 raise plumbing.convert_error_to_porcelain(e) from e 7158 tries = 0 7159 for plumbing_item in plumbing_response.resources: 7160 yield plumbing.convert_resource_to_porcelain(plumbing_item) 7161 if plumbing_response.meta.next_cursor == '': 7162 break 7163 req.meta.cursor = plumbing_response.meta.next_cursor 7164 7165 return generator(self, req) 7166 7167 def healthcheck(self, id, timeout=None): 7168 ''' 7169 Healthcheck triggers a remote healthcheck. It may take minutes to propagate across a 7170 large network of Nodes. The call will return immediately, and the updated health of the 7171 Resource can be retrieved via Get or List. 7172 ''' 7173 deadline = None if timeout is None else time.time() + timeout 7174 req = ResourceHealthcheckRequest() 7175 7176 req.id = (id) 7177 tries = 0 7178 plumbing_response = None 7179 while True: 7180 t = None if deadline is None else deadline - time.time() 7181 try: 7182 plumbing_response = self.stub.Healthcheck( 7183 req, 7184 metadata=self.parent.get_metadata('Resources.Healthcheck', 7185 req), 7186 timeout=t) 7187 except Exception as e: 7188 if self.parent.shouldRetry(tries, e, deadline): 7189 tries += 1 7190 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7191 continue 7192 raise plumbing.convert_error_to_porcelain(e) from e 7193 break 7194 7195 resp = models.ResourceHealthcheckResponse() 7196 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 7197 plumbing_response.meta) 7198 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7199 plumbing_response.rate_limit) 7200 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.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)
6986 def create(self, resource, timeout=None): 6987 ''' 6988 Create registers a new Resource. 6989 ''' 6990 deadline = None if timeout is None else time.time() + timeout 6991 req = ResourceCreateRequest() 6992 6993 if resource is not None: 6994 req.resource.CopyFrom( 6995 plumbing.convert_resource_to_plumbing(resource)) 6996 tries = 0 6997 plumbing_response = None 6998 while True: 6999 t = None if deadline is None else deadline - time.time() 7000 try: 7001 plumbing_response = self.stub.Create( 7002 req, 7003 metadata=self.parent.get_metadata('Resources.Create', req), 7004 timeout=t) 7005 except Exception as e: 7006 if self.parent.shouldRetry(tries, e, deadline): 7007 tries += 1 7008 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7009 continue 7010 raise plumbing.convert_error_to_porcelain(e) from e 7011 break 7012 7013 resp = models.ResourceCreateResponse() 7014 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 7015 plumbing_response.meta) 7016 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7017 plumbing_response.rate_limit) 7018 resp.resource = plumbing.convert_resource_to_porcelain( 7019 plumbing_response.resource) 7020 return resp
Create registers a new Resource.
def
get(self, id, timeout=None)
7022 def get(self, id, timeout=None): 7023 ''' 7024 Get reads one Resource by ID. 7025 ''' 7026 deadline = None if timeout is None else time.time() + timeout 7027 req = ResourceGetRequest() 7028 if self.parent.snapshot_datetime is not None: 7029 req.meta.CopyFrom(GetRequestMetadata()) 7030 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7031 7032 req.id = (id) 7033 tries = 0 7034 plumbing_response = None 7035 while True: 7036 t = None if deadline is None else deadline - time.time() 7037 try: 7038 plumbing_response = self.stub.Get( 7039 req, 7040 metadata=self.parent.get_metadata('Resources.Get', req), 7041 timeout=t) 7042 except Exception as e: 7043 if self.parent.shouldRetry(tries, e, deadline): 7044 tries += 1 7045 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7046 continue 7047 raise plumbing.convert_error_to_porcelain(e) from e 7048 break 7049 7050 resp = models.ResourceGetResponse() 7051 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 7052 plumbing_response.meta) 7053 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7054 plumbing_response.rate_limit) 7055 resp.resource = plumbing.convert_resource_to_porcelain( 7056 plumbing_response.resource) 7057 return resp
Get reads one Resource by ID.
def
update(self, resource, timeout=None)
7059 def update(self, resource, timeout=None): 7060 ''' 7061 Update replaces all the fields of a Resource by ID. 7062 ''' 7063 deadline = None if timeout is None else time.time() + timeout 7064 req = ResourceUpdateRequest() 7065 7066 if resource is not None: 7067 req.resource.CopyFrom( 7068 plumbing.convert_resource_to_plumbing(resource)) 7069 tries = 0 7070 plumbing_response = None 7071 while True: 7072 t = None if deadline is None else deadline - time.time() 7073 try: 7074 plumbing_response = self.stub.Update( 7075 req, 7076 metadata=self.parent.get_metadata('Resources.Update', req), 7077 timeout=t) 7078 except Exception as e: 7079 if self.parent.shouldRetry(tries, e, deadline): 7080 tries += 1 7081 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7082 continue 7083 raise plumbing.convert_error_to_porcelain(e) from e 7084 break 7085 7086 resp = models.ResourceUpdateResponse() 7087 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 7088 plumbing_response.meta) 7089 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7090 plumbing_response.rate_limit) 7091 resp.resource = plumbing.convert_resource_to_porcelain( 7092 plumbing_response.resource) 7093 return resp
Update replaces all the fields of a Resource by ID.
def
delete(self, id, timeout=None)
7095 def delete(self, id, timeout=None): 7096 ''' 7097 Delete removes a Resource by ID. 7098 ''' 7099 deadline = None if timeout is None else time.time() + timeout 7100 req = ResourceDeleteRequest() 7101 7102 req.id = (id) 7103 tries = 0 7104 plumbing_response = None 7105 while True: 7106 t = None if deadline is None else deadline - time.time() 7107 try: 7108 plumbing_response = self.stub.Delete( 7109 req, 7110 metadata=self.parent.get_metadata('Resources.Delete', req), 7111 timeout=t) 7112 except Exception as e: 7113 if self.parent.shouldRetry(tries, e, deadline): 7114 tries += 1 7115 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7116 continue 7117 raise plumbing.convert_error_to_porcelain(e) from e 7118 break 7119 7120 resp = models.ResourceDeleteResponse() 7121 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 7122 plumbing_response.meta) 7123 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7124 plumbing_response.rate_limit) 7125 return resp
Delete removes a Resource by ID.
def
list(self, filter, *args, timeout=None)
7127 def list(self, filter, *args, timeout=None): 7128 ''' 7129 List gets a list of Resources matching a given set of criteria. 7130 ''' 7131 deadline = None if timeout is None else time.time() + timeout 7132 req = ResourceListRequest() 7133 req.meta.CopyFrom(ListRequestMetadata()) 7134 if self.parent.page_limit > 0: 7135 req.meta.limit = self.parent.page_limit 7136 if self.parent.snapshot_datetime is not None: 7137 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7138 7139 req.filter = plumbing.quote_filter_args(filter, *args) 7140 7141 def generator(svc, req): 7142 tries = 0 7143 while True: 7144 t = None if deadline is None else deadline - time.time() 7145 try: 7146 plumbing_response = svc.stub.List( 7147 req, 7148 metadata=svc.parent.get_metadata( 7149 'Resources.List', req), 7150 timeout=t) 7151 except Exception as e: 7152 if self.parent.shouldRetry(tries, e, deadline): 7153 tries += 1 7154 time.sleep( 7155 self.parent.exponentialBackoff(tries, deadline)) 7156 continue 7157 raise plumbing.convert_error_to_porcelain(e) from e 7158 tries = 0 7159 for plumbing_item in plumbing_response.resources: 7160 yield plumbing.convert_resource_to_porcelain(plumbing_item) 7161 if plumbing_response.meta.next_cursor == '': 7162 break 7163 req.meta.cursor = plumbing_response.meta.next_cursor 7164 7165 return generator(self, req)
List gets a list of Resources matching a given set of criteria.
def
healthcheck(self, id, timeout=None)
7167 def healthcheck(self, id, timeout=None): 7168 ''' 7169 Healthcheck triggers a remote healthcheck. It may take minutes to propagate across a 7170 large network of Nodes. The call will return immediately, and the updated health of the 7171 Resource can be retrieved via Get or List. 7172 ''' 7173 deadline = None if timeout is None else time.time() + timeout 7174 req = ResourceHealthcheckRequest() 7175 7176 req.id = (id) 7177 tries = 0 7178 plumbing_response = None 7179 while True: 7180 t = None if deadline is None else deadline - time.time() 7181 try: 7182 plumbing_response = self.stub.Healthcheck( 7183 req, 7184 metadata=self.parent.get_metadata('Resources.Healthcheck', 7185 req), 7186 timeout=t) 7187 except Exception as e: 7188 if self.parent.shouldRetry(tries, e, deadline): 7189 tries += 1 7190 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7191 continue 7192 raise plumbing.convert_error_to_porcelain(e) from e 7193 break 7194 7195 resp = models.ResourceHealthcheckResponse() 7196 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 7197 plumbing_response.meta) 7198 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7199 plumbing_response.rate_limit) 7200 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:
7203class SnapshotResources: 7204 ''' 7205 SnapshotResources exposes the read only methods of the Resources 7206 service for historical queries. 7207 ''' 7208 def __init__(self, resources): 7209 self.resources = resources 7210 7211 def get(self, id, timeout=None): 7212 ''' 7213 Get reads one Resource by ID. 7214 ''' 7215 return self.resources.get(id, timeout=timeout) 7216 7217 def list(self, filter, *args, timeout=None): 7218 ''' 7219 List gets a list of Resources matching a given set of criteria. 7220 ''' 7221 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)
7211 def get(self, id, timeout=None): 7212 ''' 7213 Get reads one Resource by ID. 7214 ''' 7215 return self.resources.get(id, timeout=timeout)
Get reads one Resource by ID.
def
list(self, filter, *args, timeout=None)
7217 def list(self, filter, *args, timeout=None): 7218 ''' 7219 List gets a list of Resources matching a given set of criteria. 7220 ''' 7221 return self.resources.list(filter, *args, timeout=timeout)
List gets a list of Resources matching a given set of criteria.
class
ResourcesHistory:
7224class ResourcesHistory: 7225 ''' 7226 ResourcesHistory records all changes to the state of a Resource. 7227 See `strongdm.models.ResourceHistory`. 7228 ''' 7229 def __init__(self, channel, client): 7230 self.parent = client 7231 self.stub = ResourcesHistoryStub(channel) 7232 7233 def list(self, filter, *args, timeout=None): 7234 ''' 7235 List gets a list of ResourceHistory records matching a given set of criteria. 7236 ''' 7237 deadline = None if timeout is None else time.time() + timeout 7238 req = ResourceHistoryListRequest() 7239 req.meta.CopyFrom(ListRequestMetadata()) 7240 if self.parent.page_limit > 0: 7241 req.meta.limit = self.parent.page_limit 7242 if self.parent.snapshot_datetime is not None: 7243 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7244 7245 req.filter = plumbing.quote_filter_args(filter, *args) 7246 7247 def generator(svc, req): 7248 tries = 0 7249 while True: 7250 t = None if deadline is None else deadline - time.time() 7251 try: 7252 plumbing_response = svc.stub.List( 7253 req, 7254 metadata=svc.parent.get_metadata( 7255 'ResourcesHistory.List', req), 7256 timeout=t) 7257 except Exception as e: 7258 if self.parent.shouldRetry(tries, e, deadline): 7259 tries += 1 7260 time.sleep( 7261 self.parent.exponentialBackoff(tries, deadline)) 7262 continue 7263 raise plumbing.convert_error_to_porcelain(e) from e 7264 tries = 0 7265 for plumbing_item in plumbing_response.history: 7266 yield plumbing.convert_resource_history_to_porcelain( 7267 plumbing_item) 7268 if plumbing_response.meta.next_cursor == '': 7269 break 7270 req.meta.cursor = plumbing_response.meta.next_cursor 7271 7272 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)
7233 def list(self, filter, *args, timeout=None): 7234 ''' 7235 List gets a list of ResourceHistory records matching a given set of criteria. 7236 ''' 7237 deadline = None if timeout is None else time.time() + timeout 7238 req = ResourceHistoryListRequest() 7239 req.meta.CopyFrom(ListRequestMetadata()) 7240 if self.parent.page_limit > 0: 7241 req.meta.limit = self.parent.page_limit 7242 if self.parent.snapshot_datetime is not None: 7243 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7244 7245 req.filter = plumbing.quote_filter_args(filter, *args) 7246 7247 def generator(svc, req): 7248 tries = 0 7249 while True: 7250 t = None if deadline is None else deadline - time.time() 7251 try: 7252 plumbing_response = svc.stub.List( 7253 req, 7254 metadata=svc.parent.get_metadata( 7255 'ResourcesHistory.List', req), 7256 timeout=t) 7257 except Exception as e: 7258 if self.parent.shouldRetry(tries, e, deadline): 7259 tries += 1 7260 time.sleep( 7261 self.parent.exponentialBackoff(tries, deadline)) 7262 continue 7263 raise plumbing.convert_error_to_porcelain(e) from e 7264 tries = 0 7265 for plumbing_item in plumbing_response.history: 7266 yield plumbing.convert_resource_history_to_porcelain( 7267 plumbing_item) 7268 if plumbing_response.meta.next_cursor == '': 7269 break 7270 req.meta.cursor = plumbing_response.meta.next_cursor 7271 7272 return generator(self, req)
List gets a list of ResourceHistory records matching a given set of criteria.
class
RoleResources:
7275class RoleResources: 7276 ''' 7277 RoleResources enumerates the resources to which roles have access. 7278 The RoleResources service is read-only. 7279 See `strongdm.models.RoleResource`. 7280 ''' 7281 def __init__(self, channel, client): 7282 self.parent = client 7283 self.stub = RoleResourcesStub(channel) 7284 7285 def list(self, filter, *args, timeout=None): 7286 ''' 7287 List gets a list of RoleResource records matching a given set of criteria. 7288 ''' 7289 deadline = None if timeout is None else time.time() + timeout 7290 req = RoleResourceListRequest() 7291 req.meta.CopyFrom(ListRequestMetadata()) 7292 if self.parent.page_limit > 0: 7293 req.meta.limit = self.parent.page_limit 7294 if self.parent.snapshot_datetime is not None: 7295 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7296 7297 req.filter = plumbing.quote_filter_args(filter, *args) 7298 7299 def generator(svc, req): 7300 tries = 0 7301 while True: 7302 t = None if deadline is None else deadline - time.time() 7303 try: 7304 plumbing_response = svc.stub.List( 7305 req, 7306 metadata=svc.parent.get_metadata( 7307 'RoleResources.List', req), 7308 timeout=t) 7309 except Exception as e: 7310 if self.parent.shouldRetry(tries, e, deadline): 7311 tries += 1 7312 time.sleep( 7313 self.parent.exponentialBackoff(tries, deadline)) 7314 continue 7315 raise plumbing.convert_error_to_porcelain(e) from e 7316 tries = 0 7317 for plumbing_item in plumbing_response.role_resources: 7318 yield plumbing.convert_role_resource_to_porcelain( 7319 plumbing_item) 7320 if plumbing_response.meta.next_cursor == '': 7321 break 7322 req.meta.cursor = plumbing_response.meta.next_cursor 7323 7324 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)
7285 def list(self, filter, *args, timeout=None): 7286 ''' 7287 List gets a list of RoleResource records matching a given set of criteria. 7288 ''' 7289 deadline = None if timeout is None else time.time() + timeout 7290 req = RoleResourceListRequest() 7291 req.meta.CopyFrom(ListRequestMetadata()) 7292 if self.parent.page_limit > 0: 7293 req.meta.limit = self.parent.page_limit 7294 if self.parent.snapshot_datetime is not None: 7295 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7296 7297 req.filter = plumbing.quote_filter_args(filter, *args) 7298 7299 def generator(svc, req): 7300 tries = 0 7301 while True: 7302 t = None if deadline is None else deadline - time.time() 7303 try: 7304 plumbing_response = svc.stub.List( 7305 req, 7306 metadata=svc.parent.get_metadata( 7307 'RoleResources.List', req), 7308 timeout=t) 7309 except Exception as e: 7310 if self.parent.shouldRetry(tries, e, deadline): 7311 tries += 1 7312 time.sleep( 7313 self.parent.exponentialBackoff(tries, deadline)) 7314 continue 7315 raise plumbing.convert_error_to_porcelain(e) from e 7316 tries = 0 7317 for plumbing_item in plumbing_response.role_resources: 7318 yield plumbing.convert_role_resource_to_porcelain( 7319 plumbing_item) 7320 if plumbing_response.meta.next_cursor == '': 7321 break 7322 req.meta.cursor = plumbing_response.meta.next_cursor 7323 7324 return generator(self, req)
List gets a list of RoleResource records matching a given set of criteria.
class
SnapshotRoleResources:
7327class SnapshotRoleResources: 7328 ''' 7329 SnapshotRoleResources exposes the read only methods of the RoleResources 7330 service for historical queries. 7331 ''' 7332 def __init__(self, role_resources): 7333 self.role_resources = role_resources 7334 7335 def list(self, filter, *args, timeout=None): 7336 ''' 7337 List gets a list of RoleResource records matching a given set of criteria. 7338 ''' 7339 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)
7335 def list(self, filter, *args, timeout=None): 7336 ''' 7337 List gets a list of RoleResource records matching a given set of criteria. 7338 ''' 7339 return self.role_resources.list(filter, *args, timeout=timeout)
List gets a list of RoleResource records matching a given set of criteria.
class
RoleResourcesHistory:
7342class RoleResourcesHistory: 7343 ''' 7344 RoleResourcesHistory records all changes to the state of a RoleResource. 7345 See `strongdm.models.RoleResourceHistory`. 7346 ''' 7347 def __init__(self, channel, client): 7348 self.parent = client 7349 self.stub = RoleResourcesHistoryStub(channel) 7350 7351 def list(self, filter, *args, timeout=None): 7352 ''' 7353 List gets a list of RoleResourceHistory records matching a given set of criteria. 7354 ''' 7355 deadline = None if timeout is None else time.time() + timeout 7356 req = RoleResourceHistoryListRequest() 7357 req.meta.CopyFrom(ListRequestMetadata()) 7358 if self.parent.page_limit > 0: 7359 req.meta.limit = self.parent.page_limit 7360 if self.parent.snapshot_datetime is not None: 7361 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7362 7363 req.filter = plumbing.quote_filter_args(filter, *args) 7364 7365 def generator(svc, req): 7366 tries = 0 7367 while True: 7368 t = None if deadline is None else deadline - time.time() 7369 try: 7370 plumbing_response = svc.stub.List( 7371 req, 7372 metadata=svc.parent.get_metadata( 7373 'RoleResourcesHistory.List', req), 7374 timeout=t) 7375 except Exception as e: 7376 if self.parent.shouldRetry(tries, e, deadline): 7377 tries += 1 7378 time.sleep( 7379 self.parent.exponentialBackoff(tries, deadline)) 7380 continue 7381 raise plumbing.convert_error_to_porcelain(e) from e 7382 tries = 0 7383 for plumbing_item in plumbing_response.history: 7384 yield plumbing.convert_role_resource_history_to_porcelain( 7385 plumbing_item) 7386 if plumbing_response.meta.next_cursor == '': 7387 break 7388 req.meta.cursor = plumbing_response.meta.next_cursor 7389 7390 return generator(self, req)
RoleResourcesHistory records all changes to the state of a RoleResource.
See strongdm.models.RoleResourceHistory.
def
list(self, filter, *args, timeout=None)
7351 def list(self, filter, *args, timeout=None): 7352 ''' 7353 List gets a list of RoleResourceHistory records matching a given set of criteria. 7354 ''' 7355 deadline = None if timeout is None else time.time() + timeout 7356 req = RoleResourceHistoryListRequest() 7357 req.meta.CopyFrom(ListRequestMetadata()) 7358 if self.parent.page_limit > 0: 7359 req.meta.limit = self.parent.page_limit 7360 if self.parent.snapshot_datetime is not None: 7361 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7362 7363 req.filter = plumbing.quote_filter_args(filter, *args) 7364 7365 def generator(svc, req): 7366 tries = 0 7367 while True: 7368 t = None if deadline is None else deadline - time.time() 7369 try: 7370 plumbing_response = svc.stub.List( 7371 req, 7372 metadata=svc.parent.get_metadata( 7373 'RoleResourcesHistory.List', req), 7374 timeout=t) 7375 except Exception as e: 7376 if self.parent.shouldRetry(tries, e, deadline): 7377 tries += 1 7378 time.sleep( 7379 self.parent.exponentialBackoff(tries, deadline)) 7380 continue 7381 raise plumbing.convert_error_to_porcelain(e) from e 7382 tries = 0 7383 for plumbing_item in plumbing_response.history: 7384 yield plumbing.convert_role_resource_history_to_porcelain( 7385 plumbing_item) 7386 if plumbing_response.meta.next_cursor == '': 7387 break 7388 req.meta.cursor = plumbing_response.meta.next_cursor 7389 7390 return generator(self, req)
List gets a list of RoleResourceHistory records matching a given set of criteria.
class
RolesHistory:
7393class RolesHistory: 7394 ''' 7395 RolesHistory records all changes to the state of a Role. 7396 See `strongdm.models.RoleHistory`. 7397 ''' 7398 def __init__(self, channel, client): 7399 self.parent = client 7400 self.stub = RolesHistoryStub(channel) 7401 7402 def list(self, filter, *args, timeout=None): 7403 ''' 7404 List gets a list of RoleHistory records matching a given set of criteria. 7405 ''' 7406 deadline = None if timeout is None else time.time() + timeout 7407 req = RoleHistoryListRequest() 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 'RolesHistory.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.history: 7435 yield plumbing.convert_role_history_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)
RolesHistory records all changes to the state of a Role.
See strongdm.models.RoleHistory.
def
list(self, filter, *args, timeout=None)
7402 def list(self, filter, *args, timeout=None): 7403 ''' 7404 List gets a list of RoleHistory records matching a given set of criteria. 7405 ''' 7406 deadline = None if timeout is None else time.time() + timeout 7407 req = RoleHistoryListRequest() 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 'RolesHistory.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.history: 7435 yield plumbing.convert_role_history_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 RoleHistory records matching a given set of criteria.
class
SecretStores:
7444class SecretStores: 7445 ''' 7446 SecretStores are servers where resource secrets (passwords, keys) are stored. 7447 See: 7448 `strongdm.models.ActiveDirectoryStore` 7449 `strongdm.models.AWSStore` 7450 `strongdm.models.AWSCertX509Store` 7451 `strongdm.models.AzureStore` 7452 `strongdm.models.CyberarkConjurStore` 7453 `strongdm.models.CyberarkPAMStore` 7454 `strongdm.models.CyberarkPAMExperimentalStore` 7455 `strongdm.models.DelineaStore` 7456 `strongdm.models.GCPStore` 7457 `strongdm.models.GCPCertX509Store` 7458 `strongdm.models.KeyfactorSSHStore` 7459 `strongdm.models.KeyfactorX509Store` 7460 `strongdm.models.StrongVaultStore` 7461 `strongdm.models.VaultAppRoleStore` 7462 `strongdm.models.VaultAppRoleCertSSHStore` 7463 `strongdm.models.VaultAppRoleCertX509Store` 7464 `strongdm.models.VaultAWSEC2Store` 7465 `strongdm.models.VaultAWSEC2CertSSHStore` 7466 `strongdm.models.VaultAWSEC2CertX509Store` 7467 `strongdm.models.VaultAWSIAMStore` 7468 `strongdm.models.VaultAWSIAMCertSSHStore` 7469 `strongdm.models.VaultAWSIAMCertX509Store` 7470 `strongdm.models.VaultTLSStore` 7471 `strongdm.models.VaultTLSCertSSHStore` 7472 `strongdm.models.VaultTLSCertX509Store` 7473 `strongdm.models.VaultTokenStore` 7474 `strongdm.models.VaultTokenCertSSHStore` 7475 `strongdm.models.VaultTokenCertX509Store` 7476 ''' 7477 def __init__(self, channel, client): 7478 self.parent = client 7479 self.stub = SecretStoresStub(channel) 7480 7481 def create(self, secret_store, timeout=None): 7482 deadline = None if timeout is None else time.time() + timeout 7483 req = SecretStoreCreateRequest() 7484 7485 if secret_store is not None: 7486 req.secret_store.CopyFrom( 7487 plumbing.convert_secret_store_to_plumbing(secret_store)) 7488 tries = 0 7489 plumbing_response = None 7490 while True: 7491 t = None if deadline is None else deadline - time.time() 7492 try: 7493 plumbing_response = self.stub.Create( 7494 req, 7495 metadata=self.parent.get_metadata('SecretStores.Create', 7496 req), 7497 timeout=t) 7498 except Exception as e: 7499 if self.parent.shouldRetry(tries, e, deadline): 7500 tries += 1 7501 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7502 continue 7503 raise plumbing.convert_error_to_porcelain(e) from e 7504 break 7505 7506 resp = models.SecretStoreCreateResponse() 7507 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 7508 plumbing_response.meta) 7509 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7510 plumbing_response.rate_limit) 7511 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 7512 plumbing_response.secret_store) 7513 return resp 7514 7515 def get(self, id, timeout=None): 7516 ''' 7517 Get reads one SecretStore by ID. 7518 ''' 7519 deadline = None if timeout is None else time.time() + timeout 7520 req = SecretStoreGetRequest() 7521 if self.parent.snapshot_datetime is not None: 7522 req.meta.CopyFrom(GetRequestMetadata()) 7523 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7524 7525 req.id = (id) 7526 tries = 0 7527 plumbing_response = None 7528 while True: 7529 t = None if deadline is None else deadline - time.time() 7530 try: 7531 plumbing_response = self.stub.Get( 7532 req, 7533 metadata=self.parent.get_metadata('SecretStores.Get', req), 7534 timeout=t) 7535 except Exception as e: 7536 if self.parent.shouldRetry(tries, e, deadline): 7537 tries += 1 7538 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7539 continue 7540 raise plumbing.convert_error_to_porcelain(e) from e 7541 break 7542 7543 resp = models.SecretStoreGetResponse() 7544 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 7545 plumbing_response.meta) 7546 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7547 plumbing_response.rate_limit) 7548 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 7549 plumbing_response.secret_store) 7550 return resp 7551 7552 def update(self, secret_store, timeout=None): 7553 ''' 7554 Update replaces all the fields of a SecretStore by ID. 7555 ''' 7556 deadline = None if timeout is None else time.time() + timeout 7557 req = SecretStoreUpdateRequest() 7558 7559 if secret_store is not None: 7560 req.secret_store.CopyFrom( 7561 plumbing.convert_secret_store_to_plumbing(secret_store)) 7562 tries = 0 7563 plumbing_response = None 7564 while True: 7565 t = None if deadline is None else deadline - time.time() 7566 try: 7567 plumbing_response = self.stub.Update( 7568 req, 7569 metadata=self.parent.get_metadata('SecretStores.Update', 7570 req), 7571 timeout=t) 7572 except Exception as e: 7573 if self.parent.shouldRetry(tries, e, deadline): 7574 tries += 1 7575 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7576 continue 7577 raise plumbing.convert_error_to_porcelain(e) from e 7578 break 7579 7580 resp = models.SecretStoreUpdateResponse() 7581 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 7582 plumbing_response.meta) 7583 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7584 plumbing_response.rate_limit) 7585 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 7586 plumbing_response.secret_store) 7587 return resp 7588 7589 def delete(self, id, timeout=None): 7590 ''' 7591 Delete removes a SecretStore by ID. 7592 ''' 7593 deadline = None if timeout is None else time.time() + timeout 7594 req = SecretStoreDeleteRequest() 7595 7596 req.id = (id) 7597 tries = 0 7598 plumbing_response = None 7599 while True: 7600 t = None if deadline is None else deadline - time.time() 7601 try: 7602 plumbing_response = self.stub.Delete( 7603 req, 7604 metadata=self.parent.get_metadata('SecretStores.Delete', 7605 req), 7606 timeout=t) 7607 except Exception as e: 7608 if self.parent.shouldRetry(tries, e, deadline): 7609 tries += 1 7610 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7611 continue 7612 raise plumbing.convert_error_to_porcelain(e) from e 7613 break 7614 7615 resp = models.SecretStoreDeleteResponse() 7616 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 7617 plumbing_response.meta) 7618 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7619 plumbing_response.rate_limit) 7620 return resp 7621 7622 def list(self, filter, *args, timeout=None): 7623 ''' 7624 List gets a list of SecretStores matching a given set of criteria. 7625 ''' 7626 deadline = None if timeout is None else time.time() + timeout 7627 req = SecretStoreListRequest() 7628 req.meta.CopyFrom(ListRequestMetadata()) 7629 if self.parent.page_limit > 0: 7630 req.meta.limit = self.parent.page_limit 7631 if self.parent.snapshot_datetime is not None: 7632 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7633 7634 req.filter = plumbing.quote_filter_args(filter, *args) 7635 7636 def generator(svc, req): 7637 tries = 0 7638 while True: 7639 t = None if deadline is None else deadline - time.time() 7640 try: 7641 plumbing_response = svc.stub.List( 7642 req, 7643 metadata=svc.parent.get_metadata( 7644 'SecretStores.List', req), 7645 timeout=t) 7646 except Exception as e: 7647 if self.parent.shouldRetry(tries, e, deadline): 7648 tries += 1 7649 time.sleep( 7650 self.parent.exponentialBackoff(tries, deadline)) 7651 continue 7652 raise plumbing.convert_error_to_porcelain(e) from e 7653 tries = 0 7654 for plumbing_item in plumbing_response.secret_stores: 7655 yield plumbing.convert_secret_store_to_porcelain( 7656 plumbing_item) 7657 if plumbing_response.meta.next_cursor == '': 7658 break 7659 req.meta.cursor = plumbing_response.meta.next_cursor 7660 7661 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)
7481 def create(self, secret_store, timeout=None): 7482 deadline = None if timeout is None else time.time() + timeout 7483 req = SecretStoreCreateRequest() 7484 7485 if secret_store is not None: 7486 req.secret_store.CopyFrom( 7487 plumbing.convert_secret_store_to_plumbing(secret_store)) 7488 tries = 0 7489 plumbing_response = None 7490 while True: 7491 t = None if deadline is None else deadline - time.time() 7492 try: 7493 plumbing_response = self.stub.Create( 7494 req, 7495 metadata=self.parent.get_metadata('SecretStores.Create', 7496 req), 7497 timeout=t) 7498 except Exception as e: 7499 if self.parent.shouldRetry(tries, e, deadline): 7500 tries += 1 7501 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7502 continue 7503 raise plumbing.convert_error_to_porcelain(e) from e 7504 break 7505 7506 resp = models.SecretStoreCreateResponse() 7507 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 7508 plumbing_response.meta) 7509 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7510 plumbing_response.rate_limit) 7511 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 7512 plumbing_response.secret_store) 7513 return resp
def
get(self, id, timeout=None)
7515 def get(self, id, timeout=None): 7516 ''' 7517 Get reads one SecretStore by ID. 7518 ''' 7519 deadline = None if timeout is None else time.time() + timeout 7520 req = SecretStoreGetRequest() 7521 if self.parent.snapshot_datetime is not None: 7522 req.meta.CopyFrom(GetRequestMetadata()) 7523 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7524 7525 req.id = (id) 7526 tries = 0 7527 plumbing_response = None 7528 while True: 7529 t = None if deadline is None else deadline - time.time() 7530 try: 7531 plumbing_response = self.stub.Get( 7532 req, 7533 metadata=self.parent.get_metadata('SecretStores.Get', req), 7534 timeout=t) 7535 except Exception as e: 7536 if self.parent.shouldRetry(tries, e, deadline): 7537 tries += 1 7538 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7539 continue 7540 raise plumbing.convert_error_to_porcelain(e) from e 7541 break 7542 7543 resp = models.SecretStoreGetResponse() 7544 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 7545 plumbing_response.meta) 7546 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7547 plumbing_response.rate_limit) 7548 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 7549 plumbing_response.secret_store) 7550 return resp
Get reads one SecretStore by ID.
def
update(self, secret_store, timeout=None)
7552 def update(self, secret_store, timeout=None): 7553 ''' 7554 Update replaces all the fields of a SecretStore by ID. 7555 ''' 7556 deadline = None if timeout is None else time.time() + timeout 7557 req = SecretStoreUpdateRequest() 7558 7559 if secret_store is not None: 7560 req.secret_store.CopyFrom( 7561 plumbing.convert_secret_store_to_plumbing(secret_store)) 7562 tries = 0 7563 plumbing_response = None 7564 while True: 7565 t = None if deadline is None else deadline - time.time() 7566 try: 7567 plumbing_response = self.stub.Update( 7568 req, 7569 metadata=self.parent.get_metadata('SecretStores.Update', 7570 req), 7571 timeout=t) 7572 except Exception as e: 7573 if self.parent.shouldRetry(tries, e, deadline): 7574 tries += 1 7575 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7576 continue 7577 raise plumbing.convert_error_to_porcelain(e) from e 7578 break 7579 7580 resp = models.SecretStoreUpdateResponse() 7581 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 7582 plumbing_response.meta) 7583 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7584 plumbing_response.rate_limit) 7585 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 7586 plumbing_response.secret_store) 7587 return resp
Update replaces all the fields of a SecretStore by ID.
def
delete(self, id, timeout=None)
7589 def delete(self, id, timeout=None): 7590 ''' 7591 Delete removes a SecretStore by ID. 7592 ''' 7593 deadline = None if timeout is None else time.time() + timeout 7594 req = SecretStoreDeleteRequest() 7595 7596 req.id = (id) 7597 tries = 0 7598 plumbing_response = None 7599 while True: 7600 t = None if deadline is None else deadline - time.time() 7601 try: 7602 plumbing_response = self.stub.Delete( 7603 req, 7604 metadata=self.parent.get_metadata('SecretStores.Delete', 7605 req), 7606 timeout=t) 7607 except Exception as e: 7608 if self.parent.shouldRetry(tries, e, deadline): 7609 tries += 1 7610 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7611 continue 7612 raise plumbing.convert_error_to_porcelain(e) from e 7613 break 7614 7615 resp = models.SecretStoreDeleteResponse() 7616 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 7617 plumbing_response.meta) 7618 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7619 plumbing_response.rate_limit) 7620 return resp
Delete removes a SecretStore by ID.
def
list(self, filter, *args, timeout=None)
7622 def list(self, filter, *args, timeout=None): 7623 ''' 7624 List gets a list of SecretStores matching a given set of criteria. 7625 ''' 7626 deadline = None if timeout is None else time.time() + timeout 7627 req = SecretStoreListRequest() 7628 req.meta.CopyFrom(ListRequestMetadata()) 7629 if self.parent.page_limit > 0: 7630 req.meta.limit = self.parent.page_limit 7631 if self.parent.snapshot_datetime is not None: 7632 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7633 7634 req.filter = plumbing.quote_filter_args(filter, *args) 7635 7636 def generator(svc, req): 7637 tries = 0 7638 while True: 7639 t = None if deadline is None else deadline - time.time() 7640 try: 7641 plumbing_response = svc.stub.List( 7642 req, 7643 metadata=svc.parent.get_metadata( 7644 'SecretStores.List', req), 7645 timeout=t) 7646 except Exception as e: 7647 if self.parent.shouldRetry(tries, e, deadline): 7648 tries += 1 7649 time.sleep( 7650 self.parent.exponentialBackoff(tries, deadline)) 7651 continue 7652 raise plumbing.convert_error_to_porcelain(e) from e 7653 tries = 0 7654 for plumbing_item in plumbing_response.secret_stores: 7655 yield plumbing.convert_secret_store_to_porcelain( 7656 plumbing_item) 7657 if plumbing_response.meta.next_cursor == '': 7658 break 7659 req.meta.cursor = plumbing_response.meta.next_cursor 7660 7661 return generator(self, req)
List gets a list of SecretStores matching a given set of criteria.
class
SnapshotSecretStores:
7664class SnapshotSecretStores: 7665 ''' 7666 SnapshotSecretStores exposes the read only methods of the SecretStores 7667 service for historical queries. 7668 ''' 7669 def __init__(self, secret_stores): 7670 self.secret_stores = secret_stores 7671 7672 def get(self, id, timeout=None): 7673 ''' 7674 Get reads one SecretStore by ID. 7675 ''' 7676 return self.secret_stores.get(id, timeout=timeout) 7677 7678 def list(self, filter, *args, timeout=None): 7679 ''' 7680 List gets a list of SecretStores matching a given set of criteria. 7681 ''' 7682 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)
7672 def get(self, id, timeout=None): 7673 ''' 7674 Get reads one SecretStore by ID. 7675 ''' 7676 return self.secret_stores.get(id, timeout=timeout)
Get reads one SecretStore by ID.
def
list(self, filter, *args, timeout=None)
7678 def list(self, filter, *args, timeout=None): 7679 ''' 7680 List gets a list of SecretStores matching a given set of criteria. 7681 ''' 7682 return self.secret_stores.list(filter, *args, timeout=timeout)
List gets a list of SecretStores matching a given set of criteria.
class
SecretEngines:
7685class SecretEngines: 7686 ''' 7687 7688 See: 7689 `strongdm.models.ActiveDirectoryEngine` 7690 `strongdm.models.KeyValueEngine` 7691 `strongdm.models.MysqlEngine` 7692 `strongdm.models.PostgresEngine` 7693 `strongdm.models.SqlserverEngine` 7694 ''' 7695 def __init__(self, channel, client): 7696 self.parent = client 7697 self.stub = SecretEnginesStub(channel) 7698 7699 def list(self, filter, *args, timeout=None): 7700 ''' 7701 List returns a list of Secret Engines 7702 ''' 7703 deadline = None if timeout is None else time.time() + timeout 7704 req = SecretEngineListRequest() 7705 req.meta.CopyFrom(ListRequestMetadata()) 7706 if self.parent.page_limit > 0: 7707 req.meta.limit = self.parent.page_limit 7708 if self.parent.snapshot_datetime is not None: 7709 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7710 7711 req.filter = plumbing.quote_filter_args(filter, *args) 7712 7713 def generator(svc, req): 7714 tries = 0 7715 while True: 7716 t = None if deadline is None else deadline - time.time() 7717 try: 7718 plumbing_response = svc.stub.List( 7719 req, 7720 metadata=svc.parent.get_metadata( 7721 'SecretEngines.List', req), 7722 timeout=t) 7723 except Exception as e: 7724 if self.parent.shouldRetry(tries, e, deadline): 7725 tries += 1 7726 time.sleep( 7727 self.parent.exponentialBackoff(tries, deadline)) 7728 continue 7729 raise plumbing.convert_error_to_porcelain(e) from e 7730 tries = 0 7731 for plumbing_item in plumbing_response.secret_engines: 7732 yield plumbing.convert_secret_engine_to_porcelain( 7733 plumbing_item) 7734 if plumbing_response.meta.next_cursor == '': 7735 break 7736 req.meta.cursor = plumbing_response.meta.next_cursor 7737 7738 return generator(self, req) 7739 7740 def get(self, id, timeout=None): 7741 ''' 7742 Get returns a secret engine details 7743 ''' 7744 deadline = None if timeout is None else time.time() + timeout 7745 req = SecretEngineGetRequest() 7746 if self.parent.snapshot_datetime is not None: 7747 req.meta.CopyFrom(GetRequestMetadata()) 7748 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7749 7750 req.id = (id) 7751 tries = 0 7752 plumbing_response = None 7753 while True: 7754 t = None if deadline is None else deadline - time.time() 7755 try: 7756 plumbing_response = self.stub.Get( 7757 req, 7758 metadata=self.parent.get_metadata('SecretEngines.Get', 7759 req), 7760 timeout=t) 7761 except Exception as e: 7762 if self.parent.shouldRetry(tries, e, deadline): 7763 tries += 1 7764 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7765 continue 7766 raise plumbing.convert_error_to_porcelain(e) from e 7767 break 7768 7769 resp = models.SecretEngineGetResponse() 7770 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 7771 plumbing_response.meta) 7772 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7773 plumbing_response.rate_limit) 7774 resp.secret_engine = plumbing.convert_secret_engine_to_porcelain( 7775 plumbing_response.secret_engine) 7776 return resp 7777 7778 def create(self, secret_engine, timeout=None): 7779 ''' 7780 Create creates a secret engine 7781 ''' 7782 deadline = None if timeout is None else time.time() + timeout 7783 req = SecretEngineCreateRequest() 7784 7785 if secret_engine is not None: 7786 req.secret_engine.CopyFrom( 7787 plumbing.convert_secret_engine_to_plumbing(secret_engine)) 7788 tries = 0 7789 plumbing_response = None 7790 while True: 7791 t = None if deadline is None else deadline - time.time() 7792 try: 7793 plumbing_response = self.stub.Create( 7794 req, 7795 metadata=self.parent.get_metadata('SecretEngines.Create', 7796 req), 7797 timeout=t) 7798 except Exception as e: 7799 if self.parent.shouldRetry(tries, e, deadline): 7800 tries += 1 7801 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7802 continue 7803 raise plumbing.convert_error_to_porcelain(e) from e 7804 break 7805 7806 resp = models.SecretEngineCreateResponse() 7807 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 7808 plumbing_response.meta) 7809 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7810 plumbing_response.rate_limit) 7811 resp.secret_engine = plumbing.convert_secret_engine_to_porcelain( 7812 plumbing_response.secret_engine) 7813 return resp 7814 7815 def update(self, secret_engine, timeout=None): 7816 ''' 7817 Update updates a secret engine 7818 ''' 7819 deadline = None if timeout is None else time.time() + timeout 7820 req = SecretEngineUpdateRequest() 7821 7822 if secret_engine is not None: 7823 req.secret_engine.CopyFrom( 7824 plumbing.convert_secret_engine_to_plumbing(secret_engine)) 7825 tries = 0 7826 plumbing_response = None 7827 while True: 7828 t = None if deadline is None else deadline - time.time() 7829 try: 7830 plumbing_response = self.stub.Update( 7831 req, 7832 metadata=self.parent.get_metadata('SecretEngines.Update', 7833 req), 7834 timeout=t) 7835 except Exception as e: 7836 if self.parent.shouldRetry(tries, e, deadline): 7837 tries += 1 7838 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7839 continue 7840 raise plumbing.convert_error_to_porcelain(e) from e 7841 break 7842 7843 resp = models.SecretEngineUpdateResponse() 7844 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 7845 plumbing_response.meta) 7846 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7847 plumbing_response.rate_limit) 7848 resp.secret_engine = plumbing.convert_secret_engine_to_porcelain( 7849 plumbing_response.secret_engine) 7850 return resp 7851 7852 def delete(self, id, timeout=None): 7853 ''' 7854 Delete deletes a secret engine 7855 ''' 7856 deadline = None if timeout is None else time.time() + timeout 7857 req = SecretEngineDeleteRequest() 7858 7859 req.id = (id) 7860 tries = 0 7861 plumbing_response = None 7862 while True: 7863 t = None if deadline is None else deadline - time.time() 7864 try: 7865 plumbing_response = self.stub.Delete( 7866 req, 7867 metadata=self.parent.get_metadata('SecretEngines.Delete', 7868 req), 7869 timeout=t) 7870 except Exception as e: 7871 if self.parent.shouldRetry(tries, e, deadline): 7872 tries += 1 7873 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7874 continue 7875 raise plumbing.convert_error_to_porcelain(e) from e 7876 break 7877 7878 resp = models.SecretEngineDeleteResponse() 7879 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7880 plumbing_response.rate_limit) 7881 return resp 7882 7883 def list_secret_stores(self, filter, *args, timeout=None): 7884 ''' 7885 ListSecretStores returns a list of Secret Stores that can be used as a backing store 7886 for Secret Engine 7887 ''' 7888 deadline = None if timeout is None else time.time() + timeout 7889 req = SecretStoreListRequest() 7890 req.meta.CopyFrom(ListRequestMetadata()) 7891 if self.parent.page_limit > 0: 7892 req.meta.limit = self.parent.page_limit 7893 if self.parent.snapshot_datetime is not None: 7894 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7895 7896 req.filter = plumbing.quote_filter_args(filter, *args) 7897 7898 def generator(svc, req): 7899 tries = 0 7900 while True: 7901 t = None if deadline is None else deadline - time.time() 7902 try: 7903 plumbing_response = svc.stub.ListSecretStores( 7904 req, 7905 metadata=svc.parent.get_metadata( 7906 'SecretEngines.ListSecretStores', req), 7907 timeout=t) 7908 except Exception as e: 7909 if self.parent.shouldRetry(tries, e, deadline): 7910 tries += 1 7911 time.sleep( 7912 self.parent.exponentialBackoff(tries, deadline)) 7913 continue 7914 raise plumbing.convert_error_to_porcelain(e) from e 7915 tries = 0 7916 for plumbing_item in plumbing_response.secret_stores: 7917 yield plumbing.convert_secret_store_to_porcelain( 7918 plumbing_item) 7919 if plumbing_response.meta.next_cursor == '': 7920 break 7921 req.meta.cursor = plumbing_response.meta.next_cursor 7922 7923 return generator(self, req) 7924 7925 def generate_keys(self, secret_engine_id, timeout=None): 7926 ''' 7927 GenerateKeys generates a private key, stores it in a secret store and stores a public key in a secret engine 7928 ''' 7929 deadline = None if timeout is None else time.time() + timeout 7930 req = GenerateKeysRequest() 7931 7932 req.secret_engine_id = (secret_engine_id) 7933 tries = 0 7934 plumbing_response = None 7935 while True: 7936 t = None if deadline is None else deadline - time.time() 7937 try: 7938 plumbing_response = self.stub.GenerateKeys( 7939 req, 7940 metadata=self.parent.get_metadata( 7941 'SecretEngines.GenerateKeys', req), 7942 timeout=t) 7943 except Exception as e: 7944 if self.parent.shouldRetry(tries, e, deadline): 7945 tries += 1 7946 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7947 continue 7948 raise plumbing.convert_error_to_porcelain(e) from e 7949 break 7950 7951 resp = models.GenerateKeysResponse() 7952 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7953 plumbing_response.rate_limit) 7954 return resp 7955 7956 def healthcheck(self, secret_engine_id, timeout=None): 7957 ''' 7958 Healthcheck triggers a healthcheck for all nodes serving a secret engine 7959 ''' 7960 deadline = None if timeout is None else time.time() + timeout 7961 req = HealthcheckRequest() 7962 7963 req.secret_engine_id = (secret_engine_id) 7964 tries = 0 7965 plumbing_response = None 7966 while True: 7967 t = None if deadline is None else deadline - time.time() 7968 try: 7969 plumbing_response = self.stub.Healthcheck( 7970 req, 7971 metadata=self.parent.get_metadata( 7972 'SecretEngines.Healthcheck', req), 7973 timeout=t) 7974 except Exception as e: 7975 if self.parent.shouldRetry(tries, e, deadline): 7976 tries += 1 7977 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7978 continue 7979 raise plumbing.convert_error_to_porcelain(e) from e 7980 break 7981 7982 resp = models.HealthcheckResponse() 7983 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7984 plumbing_response.rate_limit) 7985 resp.status = plumbing.convert_repeated_healthcheck_status_to_porcelain( 7986 plumbing_response.status) 7987 return resp 7988 7989 def rotate(self, id, password_policy, timeout=None): 7990 ''' 7991 Rotate rotates secret engine's credentials 7992 ''' 7993 deadline = None if timeout is None else time.time() + timeout 7994 req = SecretEngineRotateRequest() 7995 7996 req.id = (id) 7997 if password_policy is not None: 7998 req.password_policy.CopyFrom( 7999 plumbing.convert_secret_engine_password_policy_to_plumbing( 8000 password_policy)) 8001 tries = 0 8002 plumbing_response = None 8003 while True: 8004 t = None if deadline is None else deadline - time.time() 8005 try: 8006 plumbing_response = self.stub.Rotate( 8007 req, 8008 metadata=self.parent.get_metadata('SecretEngines.Rotate', 8009 req), 8010 timeout=t) 8011 except Exception as e: 8012 if self.parent.shouldRetry(tries, e, deadline): 8013 tries += 1 8014 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8015 continue 8016 raise plumbing.convert_error_to_porcelain(e) from e 8017 break 8018 8019 resp = models.SecretEngineRotateResponse() 8020 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8021 plumbing_response.rate_limit) 8022 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)
7699 def list(self, filter, *args, timeout=None): 7700 ''' 7701 List returns a list of Secret Engines 7702 ''' 7703 deadline = None if timeout is None else time.time() + timeout 7704 req = SecretEngineListRequest() 7705 req.meta.CopyFrom(ListRequestMetadata()) 7706 if self.parent.page_limit > 0: 7707 req.meta.limit = self.parent.page_limit 7708 if self.parent.snapshot_datetime is not None: 7709 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7710 7711 req.filter = plumbing.quote_filter_args(filter, *args) 7712 7713 def generator(svc, req): 7714 tries = 0 7715 while True: 7716 t = None if deadline is None else deadline - time.time() 7717 try: 7718 plumbing_response = svc.stub.List( 7719 req, 7720 metadata=svc.parent.get_metadata( 7721 'SecretEngines.List', req), 7722 timeout=t) 7723 except Exception as e: 7724 if self.parent.shouldRetry(tries, e, deadline): 7725 tries += 1 7726 time.sleep( 7727 self.parent.exponentialBackoff(tries, deadline)) 7728 continue 7729 raise plumbing.convert_error_to_porcelain(e) from e 7730 tries = 0 7731 for plumbing_item in plumbing_response.secret_engines: 7732 yield plumbing.convert_secret_engine_to_porcelain( 7733 plumbing_item) 7734 if plumbing_response.meta.next_cursor == '': 7735 break 7736 req.meta.cursor = plumbing_response.meta.next_cursor 7737 7738 return generator(self, req)
List returns a list of Secret Engines
def
get(self, id, timeout=None)
7740 def get(self, id, timeout=None): 7741 ''' 7742 Get returns a secret engine details 7743 ''' 7744 deadline = None if timeout is None else time.time() + timeout 7745 req = SecretEngineGetRequest() 7746 if self.parent.snapshot_datetime is not None: 7747 req.meta.CopyFrom(GetRequestMetadata()) 7748 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7749 7750 req.id = (id) 7751 tries = 0 7752 plumbing_response = None 7753 while True: 7754 t = None if deadline is None else deadline - time.time() 7755 try: 7756 plumbing_response = self.stub.Get( 7757 req, 7758 metadata=self.parent.get_metadata('SecretEngines.Get', 7759 req), 7760 timeout=t) 7761 except Exception as e: 7762 if self.parent.shouldRetry(tries, e, deadline): 7763 tries += 1 7764 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7765 continue 7766 raise plumbing.convert_error_to_porcelain(e) from e 7767 break 7768 7769 resp = models.SecretEngineGetResponse() 7770 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 7771 plumbing_response.meta) 7772 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7773 plumbing_response.rate_limit) 7774 resp.secret_engine = plumbing.convert_secret_engine_to_porcelain( 7775 plumbing_response.secret_engine) 7776 return resp
Get returns a secret engine details
def
create(self, secret_engine, timeout=None)
7778 def create(self, secret_engine, timeout=None): 7779 ''' 7780 Create creates a secret engine 7781 ''' 7782 deadline = None if timeout is None else time.time() + timeout 7783 req = SecretEngineCreateRequest() 7784 7785 if secret_engine is not None: 7786 req.secret_engine.CopyFrom( 7787 plumbing.convert_secret_engine_to_plumbing(secret_engine)) 7788 tries = 0 7789 plumbing_response = None 7790 while True: 7791 t = None if deadline is None else deadline - time.time() 7792 try: 7793 plumbing_response = self.stub.Create( 7794 req, 7795 metadata=self.parent.get_metadata('SecretEngines.Create', 7796 req), 7797 timeout=t) 7798 except Exception as e: 7799 if self.parent.shouldRetry(tries, e, deadline): 7800 tries += 1 7801 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7802 continue 7803 raise plumbing.convert_error_to_porcelain(e) from e 7804 break 7805 7806 resp = models.SecretEngineCreateResponse() 7807 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 7808 plumbing_response.meta) 7809 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7810 plumbing_response.rate_limit) 7811 resp.secret_engine = plumbing.convert_secret_engine_to_porcelain( 7812 plumbing_response.secret_engine) 7813 return resp
Create creates a secret engine
def
update(self, secret_engine, timeout=None)
7815 def update(self, secret_engine, timeout=None): 7816 ''' 7817 Update updates a secret engine 7818 ''' 7819 deadline = None if timeout is None else time.time() + timeout 7820 req = SecretEngineUpdateRequest() 7821 7822 if secret_engine is not None: 7823 req.secret_engine.CopyFrom( 7824 plumbing.convert_secret_engine_to_plumbing(secret_engine)) 7825 tries = 0 7826 plumbing_response = None 7827 while True: 7828 t = None if deadline is None else deadline - time.time() 7829 try: 7830 plumbing_response = self.stub.Update( 7831 req, 7832 metadata=self.parent.get_metadata('SecretEngines.Update', 7833 req), 7834 timeout=t) 7835 except Exception as e: 7836 if self.parent.shouldRetry(tries, e, deadline): 7837 tries += 1 7838 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7839 continue 7840 raise plumbing.convert_error_to_porcelain(e) from e 7841 break 7842 7843 resp = models.SecretEngineUpdateResponse() 7844 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 7845 plumbing_response.meta) 7846 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7847 plumbing_response.rate_limit) 7848 resp.secret_engine = plumbing.convert_secret_engine_to_porcelain( 7849 plumbing_response.secret_engine) 7850 return resp
Update updates a secret engine
def
delete(self, id, timeout=None)
7852 def delete(self, id, timeout=None): 7853 ''' 7854 Delete deletes a secret engine 7855 ''' 7856 deadline = None if timeout is None else time.time() + timeout 7857 req = SecretEngineDeleteRequest() 7858 7859 req.id = (id) 7860 tries = 0 7861 plumbing_response = None 7862 while True: 7863 t = None if deadline is None else deadline - time.time() 7864 try: 7865 plumbing_response = self.stub.Delete( 7866 req, 7867 metadata=self.parent.get_metadata('SecretEngines.Delete', 7868 req), 7869 timeout=t) 7870 except Exception as e: 7871 if self.parent.shouldRetry(tries, e, deadline): 7872 tries += 1 7873 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7874 continue 7875 raise plumbing.convert_error_to_porcelain(e) from e 7876 break 7877 7878 resp = models.SecretEngineDeleteResponse() 7879 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7880 plumbing_response.rate_limit) 7881 return resp
Delete deletes a secret engine
def
list_secret_stores(self, filter, *args, timeout=None)
7883 def list_secret_stores(self, filter, *args, timeout=None): 7884 ''' 7885 ListSecretStores returns a list of Secret Stores that can be used as a backing store 7886 for Secret Engine 7887 ''' 7888 deadline = None if timeout is None else time.time() + timeout 7889 req = SecretStoreListRequest() 7890 req.meta.CopyFrom(ListRequestMetadata()) 7891 if self.parent.page_limit > 0: 7892 req.meta.limit = self.parent.page_limit 7893 if self.parent.snapshot_datetime is not None: 7894 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7895 7896 req.filter = plumbing.quote_filter_args(filter, *args) 7897 7898 def generator(svc, req): 7899 tries = 0 7900 while True: 7901 t = None if deadline is None else deadline - time.time() 7902 try: 7903 plumbing_response = svc.stub.ListSecretStores( 7904 req, 7905 metadata=svc.parent.get_metadata( 7906 'SecretEngines.ListSecretStores', req), 7907 timeout=t) 7908 except Exception as e: 7909 if self.parent.shouldRetry(tries, e, deadline): 7910 tries += 1 7911 time.sleep( 7912 self.parent.exponentialBackoff(tries, deadline)) 7913 continue 7914 raise plumbing.convert_error_to_porcelain(e) from e 7915 tries = 0 7916 for plumbing_item in plumbing_response.secret_stores: 7917 yield plumbing.convert_secret_store_to_porcelain( 7918 plumbing_item) 7919 if plumbing_response.meta.next_cursor == '': 7920 break 7921 req.meta.cursor = plumbing_response.meta.next_cursor 7922 7923 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)
7925 def generate_keys(self, secret_engine_id, timeout=None): 7926 ''' 7927 GenerateKeys generates a private key, stores it in a secret store and stores a public key in a secret engine 7928 ''' 7929 deadline = None if timeout is None else time.time() + timeout 7930 req = GenerateKeysRequest() 7931 7932 req.secret_engine_id = (secret_engine_id) 7933 tries = 0 7934 plumbing_response = None 7935 while True: 7936 t = None if deadline is None else deadline - time.time() 7937 try: 7938 plumbing_response = self.stub.GenerateKeys( 7939 req, 7940 metadata=self.parent.get_metadata( 7941 'SecretEngines.GenerateKeys', req), 7942 timeout=t) 7943 except Exception as e: 7944 if self.parent.shouldRetry(tries, e, deadline): 7945 tries += 1 7946 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7947 continue 7948 raise plumbing.convert_error_to_porcelain(e) from e 7949 break 7950 7951 resp = models.GenerateKeysResponse() 7952 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7953 plumbing_response.rate_limit) 7954 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)
7956 def healthcheck(self, secret_engine_id, timeout=None): 7957 ''' 7958 Healthcheck triggers a healthcheck for all nodes serving a secret engine 7959 ''' 7960 deadline = None if timeout is None else time.time() + timeout 7961 req = HealthcheckRequest() 7962 7963 req.secret_engine_id = (secret_engine_id) 7964 tries = 0 7965 plumbing_response = None 7966 while True: 7967 t = None if deadline is None else deadline - time.time() 7968 try: 7969 plumbing_response = self.stub.Healthcheck( 7970 req, 7971 metadata=self.parent.get_metadata( 7972 'SecretEngines.Healthcheck', req), 7973 timeout=t) 7974 except Exception as e: 7975 if self.parent.shouldRetry(tries, e, deadline): 7976 tries += 1 7977 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7978 continue 7979 raise plumbing.convert_error_to_porcelain(e) from e 7980 break 7981 7982 resp = models.HealthcheckResponse() 7983 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7984 plumbing_response.rate_limit) 7985 resp.status = plumbing.convert_repeated_healthcheck_status_to_porcelain( 7986 plumbing_response.status) 7987 return resp
Healthcheck triggers a healthcheck for all nodes serving a secret engine
def
rotate(self, id, password_policy, timeout=None)
7989 def rotate(self, id, password_policy, timeout=None): 7990 ''' 7991 Rotate rotates secret engine's credentials 7992 ''' 7993 deadline = None if timeout is None else time.time() + timeout 7994 req = SecretEngineRotateRequest() 7995 7996 req.id = (id) 7997 if password_policy is not None: 7998 req.password_policy.CopyFrom( 7999 plumbing.convert_secret_engine_password_policy_to_plumbing( 8000 password_policy)) 8001 tries = 0 8002 plumbing_response = None 8003 while True: 8004 t = None if deadline is None else deadline - time.time() 8005 try: 8006 plumbing_response = self.stub.Rotate( 8007 req, 8008 metadata=self.parent.get_metadata('SecretEngines.Rotate', 8009 req), 8010 timeout=t) 8011 except Exception as e: 8012 if self.parent.shouldRetry(tries, e, deadline): 8013 tries += 1 8014 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8015 continue 8016 raise plumbing.convert_error_to_porcelain(e) from e 8017 break 8018 8019 resp = models.SecretEngineRotateResponse() 8020 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8021 plumbing_response.rate_limit) 8022 return resp
Rotate rotates secret engine's credentials
class
SecretStoreHealths:
8025class SecretStoreHealths: 8026 ''' 8027 SecretStoreHealths exposes health states for secret stores. 8028 See `strongdm.models.SecretStoreHealth`. 8029 ''' 8030 def __init__(self, channel, client): 8031 self.parent = client 8032 self.stub = SecretStoreHealthsStub(channel) 8033 8034 def list(self, filter, *args, timeout=None): 8035 ''' 8036 List reports the health status of node to secret store pairs. 8037 ''' 8038 deadline = None if timeout is None else time.time() + timeout 8039 req = SecretStoreHealthListRequest() 8040 req.meta.CopyFrom(ListRequestMetadata()) 8041 if self.parent.page_limit > 0: 8042 req.meta.limit = self.parent.page_limit 8043 if self.parent.snapshot_datetime is not None: 8044 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8045 8046 req.filter = plumbing.quote_filter_args(filter, *args) 8047 8048 def generator(svc, req): 8049 tries = 0 8050 while True: 8051 t = None if deadline is None else deadline - time.time() 8052 try: 8053 plumbing_response = svc.stub.List( 8054 req, 8055 metadata=svc.parent.get_metadata( 8056 'SecretStoreHealths.List', req), 8057 timeout=t) 8058 except Exception as e: 8059 if self.parent.shouldRetry(tries, e, deadline): 8060 tries += 1 8061 time.sleep( 8062 self.parent.exponentialBackoff(tries, deadline)) 8063 continue 8064 raise plumbing.convert_error_to_porcelain(e) from e 8065 tries = 0 8066 for plumbing_item in plumbing_response.secret_store_healths: 8067 yield plumbing.convert_secret_store_health_to_porcelain( 8068 plumbing_item) 8069 if plumbing_response.meta.next_cursor == '': 8070 break 8071 req.meta.cursor = plumbing_response.meta.next_cursor 8072 8073 return generator(self, req) 8074 8075 def healthcheck(self, secret_store_id, timeout=None): 8076 ''' 8077 Healthcheck triggers a remote healthcheck request for a secret store. It may take minutes 8078 to propagate across a large network of Nodes. The call will return immediately, and the 8079 updated health of the Secret Store can be retrieved via List. 8080 ''' 8081 deadline = None if timeout is None else time.time() + timeout 8082 req = SecretStoreHealthcheckRequest() 8083 8084 req.secret_store_id = (secret_store_id) 8085 tries = 0 8086 plumbing_response = None 8087 while True: 8088 t = None if deadline is None else deadline - time.time() 8089 try: 8090 plumbing_response = self.stub.Healthcheck( 8091 req, 8092 metadata=self.parent.get_metadata( 8093 'SecretStoreHealths.Healthcheck', req), 8094 timeout=t) 8095 except Exception as e: 8096 if self.parent.shouldRetry(tries, e, deadline): 8097 tries += 1 8098 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8099 continue 8100 raise plumbing.convert_error_to_porcelain(e) from e 8101 break 8102 8103 resp = models.SecretStoreHealthcheckResponse() 8104 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8105 plumbing_response.rate_limit) 8106 return resp
SecretStoreHealths exposes health states for secret stores.
See strongdm.models.SecretStoreHealth.
def
list(self, filter, *args, timeout=None)
8034 def list(self, filter, *args, timeout=None): 8035 ''' 8036 List reports the health status of node to secret store pairs. 8037 ''' 8038 deadline = None if timeout is None else time.time() + timeout 8039 req = SecretStoreHealthListRequest() 8040 req.meta.CopyFrom(ListRequestMetadata()) 8041 if self.parent.page_limit > 0: 8042 req.meta.limit = self.parent.page_limit 8043 if self.parent.snapshot_datetime is not None: 8044 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8045 8046 req.filter = plumbing.quote_filter_args(filter, *args) 8047 8048 def generator(svc, req): 8049 tries = 0 8050 while True: 8051 t = None if deadline is None else deadline - time.time() 8052 try: 8053 plumbing_response = svc.stub.List( 8054 req, 8055 metadata=svc.parent.get_metadata( 8056 'SecretStoreHealths.List', req), 8057 timeout=t) 8058 except Exception as e: 8059 if self.parent.shouldRetry(tries, e, deadline): 8060 tries += 1 8061 time.sleep( 8062 self.parent.exponentialBackoff(tries, deadline)) 8063 continue 8064 raise plumbing.convert_error_to_porcelain(e) from e 8065 tries = 0 8066 for plumbing_item in plumbing_response.secret_store_healths: 8067 yield plumbing.convert_secret_store_health_to_porcelain( 8068 plumbing_item) 8069 if plumbing_response.meta.next_cursor == '': 8070 break 8071 req.meta.cursor = plumbing_response.meta.next_cursor 8072 8073 return generator(self, req)
List reports the health status of node to secret store pairs.
def
healthcheck(self, secret_store_id, timeout=None)
8075 def healthcheck(self, secret_store_id, timeout=None): 8076 ''' 8077 Healthcheck triggers a remote healthcheck request for a secret store. It may take minutes 8078 to propagate across a large network of Nodes. The call will return immediately, and the 8079 updated health of the Secret Store can be retrieved via List. 8080 ''' 8081 deadline = None if timeout is None else time.time() + timeout 8082 req = SecretStoreHealthcheckRequest() 8083 8084 req.secret_store_id = (secret_store_id) 8085 tries = 0 8086 plumbing_response = None 8087 while True: 8088 t = None if deadline is None else deadline - time.time() 8089 try: 8090 plumbing_response = self.stub.Healthcheck( 8091 req, 8092 metadata=self.parent.get_metadata( 8093 'SecretStoreHealths.Healthcheck', req), 8094 timeout=t) 8095 except Exception as e: 8096 if self.parent.shouldRetry(tries, e, deadline): 8097 tries += 1 8098 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8099 continue 8100 raise plumbing.convert_error_to_porcelain(e) from e 8101 break 8102 8103 resp = models.SecretStoreHealthcheckResponse() 8104 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8105 plumbing_response.rate_limit) 8106 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:
8109class SecretStoresHistory: 8110 ''' 8111 SecretStoresHistory records all changes to the state of a SecretStore. 8112 See `strongdm.models.SecretStoreHistory`. 8113 ''' 8114 def __init__(self, channel, client): 8115 self.parent = client 8116 self.stub = SecretStoresHistoryStub(channel) 8117 8118 def list(self, filter, *args, timeout=None): 8119 ''' 8120 List gets a list of SecretStoreHistory records matching a given set of criteria. 8121 ''' 8122 deadline = None if timeout is None else time.time() + timeout 8123 req = SecretStoreHistoryListRequest() 8124 req.meta.CopyFrom(ListRequestMetadata()) 8125 if self.parent.page_limit > 0: 8126 req.meta.limit = self.parent.page_limit 8127 if self.parent.snapshot_datetime is not None: 8128 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8129 8130 req.filter = plumbing.quote_filter_args(filter, *args) 8131 8132 def generator(svc, req): 8133 tries = 0 8134 while True: 8135 t = None if deadline is None else deadline - time.time() 8136 try: 8137 plumbing_response = svc.stub.List( 8138 req, 8139 metadata=svc.parent.get_metadata( 8140 'SecretStoresHistory.List', req), 8141 timeout=t) 8142 except Exception as e: 8143 if self.parent.shouldRetry(tries, e, deadline): 8144 tries += 1 8145 time.sleep( 8146 self.parent.exponentialBackoff(tries, deadline)) 8147 continue 8148 raise plumbing.convert_error_to_porcelain(e) from e 8149 tries = 0 8150 for plumbing_item in plumbing_response.history: 8151 yield plumbing.convert_secret_store_history_to_porcelain( 8152 plumbing_item) 8153 if plumbing_response.meta.next_cursor == '': 8154 break 8155 req.meta.cursor = plumbing_response.meta.next_cursor 8156 8157 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)
8118 def list(self, filter, *args, timeout=None): 8119 ''' 8120 List gets a list of SecretStoreHistory records matching a given set of criteria. 8121 ''' 8122 deadline = None if timeout is None else time.time() + timeout 8123 req = SecretStoreHistoryListRequest() 8124 req.meta.CopyFrom(ListRequestMetadata()) 8125 if self.parent.page_limit > 0: 8126 req.meta.limit = self.parent.page_limit 8127 if self.parent.snapshot_datetime is not None: 8128 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8129 8130 req.filter = plumbing.quote_filter_args(filter, *args) 8131 8132 def generator(svc, req): 8133 tries = 0 8134 while True: 8135 t = None if deadline is None else deadline - time.time() 8136 try: 8137 plumbing_response = svc.stub.List( 8138 req, 8139 metadata=svc.parent.get_metadata( 8140 'SecretStoresHistory.List', req), 8141 timeout=t) 8142 except Exception as e: 8143 if self.parent.shouldRetry(tries, e, deadline): 8144 tries += 1 8145 time.sleep( 8146 self.parent.exponentialBackoff(tries, deadline)) 8147 continue 8148 raise plumbing.convert_error_to_porcelain(e) from e 8149 tries = 0 8150 for plumbing_item in plumbing_response.history: 8151 yield plumbing.convert_secret_store_history_to_porcelain( 8152 plumbing_item) 8153 if plumbing_response.meta.next_cursor == '': 8154 break 8155 req.meta.cursor = plumbing_response.meta.next_cursor 8156 8157 return generator(self, req)
List gets a list of SecretStoreHistory records matching a given set of criteria.
class
WorkflowApprovers:
8160class WorkflowApprovers: 8161 ''' 8162 WorkflowApprovers is an account or a role with the ability to approve requests bound to a workflow. 8163 See `strongdm.models.WorkflowApprover`. 8164 ''' 8165 def __init__(self, channel, client): 8166 self.parent = client 8167 self.stub = WorkflowApproversStub(channel) 8168 8169 def create(self, workflow_approver, timeout=None): 8170 ''' 8171 Create creates a new workflow approver 8172 ''' 8173 deadline = None if timeout is None else time.time() + timeout 8174 req = WorkflowApproversCreateRequest() 8175 8176 if workflow_approver is not None: 8177 req.workflow_approver.CopyFrom( 8178 plumbing.convert_workflow_approver_to_plumbing( 8179 workflow_approver)) 8180 tries = 0 8181 plumbing_response = None 8182 while True: 8183 t = None if deadline is None else deadline - time.time() 8184 try: 8185 plumbing_response = self.stub.Create( 8186 req, 8187 metadata=self.parent.get_metadata( 8188 'WorkflowApprovers.Create', req), 8189 timeout=t) 8190 except Exception as e: 8191 if self.parent.shouldRetry(tries, e, deadline): 8192 tries += 1 8193 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8194 continue 8195 raise plumbing.convert_error_to_porcelain(e) from e 8196 break 8197 8198 resp = models.WorkflowApproversCreateResponse() 8199 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8200 plumbing_response.rate_limit) 8201 resp.workflow_approver = plumbing.convert_workflow_approver_to_porcelain( 8202 plumbing_response.workflow_approver) 8203 return resp 8204 8205 def get(self, id, timeout=None): 8206 ''' 8207 Get reads one workflow approver by ID. 8208 ''' 8209 deadline = None if timeout is None else time.time() + timeout 8210 req = WorkflowApproverGetRequest() 8211 if self.parent.snapshot_datetime is not None: 8212 req.meta.CopyFrom(GetRequestMetadata()) 8213 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8214 8215 req.id = (id) 8216 tries = 0 8217 plumbing_response = None 8218 while True: 8219 t = None if deadline is None else deadline - time.time() 8220 try: 8221 plumbing_response = self.stub.Get( 8222 req, 8223 metadata=self.parent.get_metadata('WorkflowApprovers.Get', 8224 req), 8225 timeout=t) 8226 except Exception as e: 8227 if self.parent.shouldRetry(tries, e, deadline): 8228 tries += 1 8229 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8230 continue 8231 raise plumbing.convert_error_to_porcelain(e) from e 8232 break 8233 8234 resp = models.WorkflowApproverGetResponse() 8235 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 8236 plumbing_response.meta) 8237 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8238 plumbing_response.rate_limit) 8239 resp.workflow_approver = plumbing.convert_workflow_approver_to_porcelain( 8240 plumbing_response.workflow_approver) 8241 return resp 8242 8243 def delete(self, id, timeout=None): 8244 ''' 8245 Delete deletes a workflow approver 8246 ''' 8247 deadline = None if timeout is None else time.time() + timeout 8248 req = WorkflowApproversDeleteRequest() 8249 8250 req.id = (id) 8251 tries = 0 8252 plumbing_response = None 8253 while True: 8254 t = None if deadline is None else deadline - time.time() 8255 try: 8256 plumbing_response = self.stub.Delete( 8257 req, 8258 metadata=self.parent.get_metadata( 8259 'WorkflowApprovers.Delete', req), 8260 timeout=t) 8261 except Exception as e: 8262 if self.parent.shouldRetry(tries, e, deadline): 8263 tries += 1 8264 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8265 continue 8266 raise plumbing.convert_error_to_porcelain(e) from e 8267 break 8268 8269 resp = models.WorkflowApproversDeleteResponse() 8270 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8271 plumbing_response.rate_limit) 8272 return resp 8273 8274 def list(self, filter, *args, timeout=None): 8275 ''' 8276 Lists existing workflow approvers. 8277 ''' 8278 deadline = None if timeout is None else time.time() + timeout 8279 req = WorkflowApproversListRequest() 8280 req.meta.CopyFrom(ListRequestMetadata()) 8281 if self.parent.page_limit > 0: 8282 req.meta.limit = self.parent.page_limit 8283 if self.parent.snapshot_datetime is not None: 8284 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8285 8286 req.filter = plumbing.quote_filter_args(filter, *args) 8287 8288 def generator(svc, req): 8289 tries = 0 8290 while True: 8291 t = None if deadline is None else deadline - time.time() 8292 try: 8293 plumbing_response = svc.stub.List( 8294 req, 8295 metadata=svc.parent.get_metadata( 8296 'WorkflowApprovers.List', req), 8297 timeout=t) 8298 except Exception as e: 8299 if self.parent.shouldRetry(tries, e, deadline): 8300 tries += 1 8301 time.sleep( 8302 self.parent.exponentialBackoff(tries, deadline)) 8303 continue 8304 raise plumbing.convert_error_to_porcelain(e) from e 8305 tries = 0 8306 for plumbing_item in plumbing_response.workflow_approvers: 8307 yield plumbing.convert_workflow_approver_to_porcelain( 8308 plumbing_item) 8309 if plumbing_response.meta.next_cursor == '': 8310 break 8311 req.meta.cursor = plumbing_response.meta.next_cursor 8312 8313 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)
8169 def create(self, workflow_approver, timeout=None): 8170 ''' 8171 Create creates a new workflow approver 8172 ''' 8173 deadline = None if timeout is None else time.time() + timeout 8174 req = WorkflowApproversCreateRequest() 8175 8176 if workflow_approver is not None: 8177 req.workflow_approver.CopyFrom( 8178 plumbing.convert_workflow_approver_to_plumbing( 8179 workflow_approver)) 8180 tries = 0 8181 plumbing_response = None 8182 while True: 8183 t = None if deadline is None else deadline - time.time() 8184 try: 8185 plumbing_response = self.stub.Create( 8186 req, 8187 metadata=self.parent.get_metadata( 8188 'WorkflowApprovers.Create', req), 8189 timeout=t) 8190 except Exception as e: 8191 if self.parent.shouldRetry(tries, e, deadline): 8192 tries += 1 8193 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8194 continue 8195 raise plumbing.convert_error_to_porcelain(e) from e 8196 break 8197 8198 resp = models.WorkflowApproversCreateResponse() 8199 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8200 plumbing_response.rate_limit) 8201 resp.workflow_approver = plumbing.convert_workflow_approver_to_porcelain( 8202 plumbing_response.workflow_approver) 8203 return resp
Create creates a new workflow approver
def
get(self, id, timeout=None)
8205 def get(self, id, timeout=None): 8206 ''' 8207 Get reads one workflow approver by ID. 8208 ''' 8209 deadline = None if timeout is None else time.time() + timeout 8210 req = WorkflowApproverGetRequest() 8211 if self.parent.snapshot_datetime is not None: 8212 req.meta.CopyFrom(GetRequestMetadata()) 8213 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8214 8215 req.id = (id) 8216 tries = 0 8217 plumbing_response = None 8218 while True: 8219 t = None if deadline is None else deadline - time.time() 8220 try: 8221 plumbing_response = self.stub.Get( 8222 req, 8223 metadata=self.parent.get_metadata('WorkflowApprovers.Get', 8224 req), 8225 timeout=t) 8226 except Exception as e: 8227 if self.parent.shouldRetry(tries, e, deadline): 8228 tries += 1 8229 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8230 continue 8231 raise plumbing.convert_error_to_porcelain(e) from e 8232 break 8233 8234 resp = models.WorkflowApproverGetResponse() 8235 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 8236 plumbing_response.meta) 8237 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8238 plumbing_response.rate_limit) 8239 resp.workflow_approver = plumbing.convert_workflow_approver_to_porcelain( 8240 plumbing_response.workflow_approver) 8241 return resp
Get reads one workflow approver by ID.
def
delete(self, id, timeout=None)
8243 def delete(self, id, timeout=None): 8244 ''' 8245 Delete deletes a workflow approver 8246 ''' 8247 deadline = None if timeout is None else time.time() + timeout 8248 req = WorkflowApproversDeleteRequest() 8249 8250 req.id = (id) 8251 tries = 0 8252 plumbing_response = None 8253 while True: 8254 t = None if deadline is None else deadline - time.time() 8255 try: 8256 plumbing_response = self.stub.Delete( 8257 req, 8258 metadata=self.parent.get_metadata( 8259 'WorkflowApprovers.Delete', req), 8260 timeout=t) 8261 except Exception as e: 8262 if self.parent.shouldRetry(tries, e, deadline): 8263 tries += 1 8264 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8265 continue 8266 raise plumbing.convert_error_to_porcelain(e) from e 8267 break 8268 8269 resp = models.WorkflowApproversDeleteResponse() 8270 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8271 plumbing_response.rate_limit) 8272 return resp
Delete deletes a workflow approver
def
list(self, filter, *args, timeout=None)
8274 def list(self, filter, *args, timeout=None): 8275 ''' 8276 Lists existing workflow approvers. 8277 ''' 8278 deadline = None if timeout is None else time.time() + timeout 8279 req = WorkflowApproversListRequest() 8280 req.meta.CopyFrom(ListRequestMetadata()) 8281 if self.parent.page_limit > 0: 8282 req.meta.limit = self.parent.page_limit 8283 if self.parent.snapshot_datetime is not None: 8284 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8285 8286 req.filter = plumbing.quote_filter_args(filter, *args) 8287 8288 def generator(svc, req): 8289 tries = 0 8290 while True: 8291 t = None if deadline is None else deadline - time.time() 8292 try: 8293 plumbing_response = svc.stub.List( 8294 req, 8295 metadata=svc.parent.get_metadata( 8296 'WorkflowApprovers.List', req), 8297 timeout=t) 8298 except Exception as e: 8299 if self.parent.shouldRetry(tries, e, deadline): 8300 tries += 1 8301 time.sleep( 8302 self.parent.exponentialBackoff(tries, deadline)) 8303 continue 8304 raise plumbing.convert_error_to_porcelain(e) from e 8305 tries = 0 8306 for plumbing_item in plumbing_response.workflow_approvers: 8307 yield plumbing.convert_workflow_approver_to_porcelain( 8308 plumbing_item) 8309 if plumbing_response.meta.next_cursor == '': 8310 break 8311 req.meta.cursor = plumbing_response.meta.next_cursor 8312 8313 return generator(self, req)
Lists existing workflow approvers.
class
SnapshotWorkflowApprovers:
8316class SnapshotWorkflowApprovers: 8317 ''' 8318 SnapshotWorkflowApprovers exposes the read only methods of the WorkflowApprovers 8319 service for historical queries. 8320 ''' 8321 def __init__(self, workflow_approvers): 8322 self.workflow_approvers = workflow_approvers 8323 8324 def get(self, id, timeout=None): 8325 ''' 8326 Get reads one workflow approver by ID. 8327 ''' 8328 return self.workflow_approvers.get(id, timeout=timeout) 8329 8330 def list(self, filter, *args, timeout=None): 8331 ''' 8332 Lists existing workflow approvers. 8333 ''' 8334 return self.workflow_approvers.list(filter, *args, timeout=timeout)
SnapshotWorkflowApprovers exposes the read only methods of the WorkflowApprovers service for historical queries.
class
WorkflowApproversHistory:
8337class WorkflowApproversHistory: 8338 ''' 8339 WorkflowApproversHistory provides records of all changes to the state of a WorkflowApprover. 8340 See `strongdm.models.WorkflowApproverHistory`. 8341 ''' 8342 def __init__(self, channel, client): 8343 self.parent = client 8344 self.stub = WorkflowApproversHistoryStub(channel) 8345 8346 def list(self, filter, *args, timeout=None): 8347 ''' 8348 List gets a list of WorkflowApproversHistory records matching a given set of criteria. 8349 ''' 8350 deadline = None if timeout is None else time.time() + timeout 8351 req = WorkflowApproversHistoryListRequest() 8352 req.meta.CopyFrom(ListRequestMetadata()) 8353 if self.parent.page_limit > 0: 8354 req.meta.limit = self.parent.page_limit 8355 if self.parent.snapshot_datetime is not None: 8356 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8357 8358 req.filter = plumbing.quote_filter_args(filter, *args) 8359 8360 def generator(svc, req): 8361 tries = 0 8362 while True: 8363 t = None if deadline is None else deadline - time.time() 8364 try: 8365 plumbing_response = svc.stub.List( 8366 req, 8367 metadata=svc.parent.get_metadata( 8368 'WorkflowApproversHistory.List', req), 8369 timeout=t) 8370 except Exception as e: 8371 if self.parent.shouldRetry(tries, e, deadline): 8372 tries += 1 8373 time.sleep( 8374 self.parent.exponentialBackoff(tries, deadline)) 8375 continue 8376 raise plumbing.convert_error_to_porcelain(e) from e 8377 tries = 0 8378 for plumbing_item in plumbing_response.history: 8379 yield plumbing.convert_workflow_approver_history_to_porcelain( 8380 plumbing_item) 8381 if plumbing_response.meta.next_cursor == '': 8382 break 8383 req.meta.cursor = plumbing_response.meta.next_cursor 8384 8385 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)
8346 def list(self, filter, *args, timeout=None): 8347 ''' 8348 List gets a list of WorkflowApproversHistory records matching a given set of criteria. 8349 ''' 8350 deadline = None if timeout is None else time.time() + timeout 8351 req = WorkflowApproversHistoryListRequest() 8352 req.meta.CopyFrom(ListRequestMetadata()) 8353 if self.parent.page_limit > 0: 8354 req.meta.limit = self.parent.page_limit 8355 if self.parent.snapshot_datetime is not None: 8356 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8357 8358 req.filter = plumbing.quote_filter_args(filter, *args) 8359 8360 def generator(svc, req): 8361 tries = 0 8362 while True: 8363 t = None if deadline is None else deadline - time.time() 8364 try: 8365 plumbing_response = svc.stub.List( 8366 req, 8367 metadata=svc.parent.get_metadata( 8368 'WorkflowApproversHistory.List', req), 8369 timeout=t) 8370 except Exception as e: 8371 if self.parent.shouldRetry(tries, e, deadline): 8372 tries += 1 8373 time.sleep( 8374 self.parent.exponentialBackoff(tries, deadline)) 8375 continue 8376 raise plumbing.convert_error_to_porcelain(e) from e 8377 tries = 0 8378 for plumbing_item in plumbing_response.history: 8379 yield plumbing.convert_workflow_approver_history_to_porcelain( 8380 plumbing_item) 8381 if plumbing_response.meta.next_cursor == '': 8382 break 8383 req.meta.cursor = plumbing_response.meta.next_cursor 8384 8385 return generator(self, req)
List gets a list of WorkflowApproversHistory records matching a given set of criteria.
class
WorkflowRoles:
8388class WorkflowRoles: 8389 ''' 8390 WorkflowRole links a role to a workflow. The linked roles indicate which roles a user must be a part of 8391 to request access to a resource via the workflow. 8392 See `strongdm.models.WorkflowRole`. 8393 ''' 8394 def __init__(self, channel, client): 8395 self.parent = client 8396 self.stub = WorkflowRolesStub(channel) 8397 8398 def create(self, workflow_role, timeout=None): 8399 ''' 8400 Create creates a new workflow role 8401 ''' 8402 deadline = None if timeout is None else time.time() + timeout 8403 req = WorkflowRolesCreateRequest() 8404 8405 if workflow_role is not None: 8406 req.workflow_role.CopyFrom( 8407 plumbing.convert_workflow_role_to_plumbing(workflow_role)) 8408 tries = 0 8409 plumbing_response = None 8410 while True: 8411 t = None if deadline is None else deadline - time.time() 8412 try: 8413 plumbing_response = self.stub.Create( 8414 req, 8415 metadata=self.parent.get_metadata('WorkflowRoles.Create', 8416 req), 8417 timeout=t) 8418 except Exception as e: 8419 if self.parent.shouldRetry(tries, e, deadline): 8420 tries += 1 8421 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8422 continue 8423 raise plumbing.convert_error_to_porcelain(e) from e 8424 break 8425 8426 resp = models.WorkflowRolesCreateResponse() 8427 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8428 plumbing_response.rate_limit) 8429 resp.workflow_role = plumbing.convert_workflow_role_to_porcelain( 8430 plumbing_response.workflow_role) 8431 return resp 8432 8433 def get(self, id, timeout=None): 8434 ''' 8435 Get reads one workflow role by ID. 8436 ''' 8437 deadline = None if timeout is None else time.time() + timeout 8438 req = WorkflowRoleGetRequest() 8439 if self.parent.snapshot_datetime is not None: 8440 req.meta.CopyFrom(GetRequestMetadata()) 8441 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8442 8443 req.id = (id) 8444 tries = 0 8445 plumbing_response = None 8446 while True: 8447 t = None if deadline is None else deadline - time.time() 8448 try: 8449 plumbing_response = self.stub.Get( 8450 req, 8451 metadata=self.parent.get_metadata('WorkflowRoles.Get', 8452 req), 8453 timeout=t) 8454 except Exception as e: 8455 if self.parent.shouldRetry(tries, e, deadline): 8456 tries += 1 8457 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8458 continue 8459 raise plumbing.convert_error_to_porcelain(e) from e 8460 break 8461 8462 resp = models.WorkflowRoleGetResponse() 8463 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 8464 plumbing_response.meta) 8465 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8466 plumbing_response.rate_limit) 8467 resp.workflow_role = plumbing.convert_workflow_role_to_porcelain( 8468 plumbing_response.workflow_role) 8469 return resp 8470 8471 def delete(self, id, timeout=None): 8472 ''' 8473 Delete deletes a workflow role 8474 ''' 8475 deadline = None if timeout is None else time.time() + timeout 8476 req = WorkflowRolesDeleteRequest() 8477 8478 req.id = (id) 8479 tries = 0 8480 plumbing_response = None 8481 while True: 8482 t = None if deadline is None else deadline - time.time() 8483 try: 8484 plumbing_response = self.stub.Delete( 8485 req, 8486 metadata=self.parent.get_metadata('WorkflowRoles.Delete', 8487 req), 8488 timeout=t) 8489 except Exception as e: 8490 if self.parent.shouldRetry(tries, e, deadline): 8491 tries += 1 8492 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8493 continue 8494 raise plumbing.convert_error_to_porcelain(e) from e 8495 break 8496 8497 resp = models.WorkflowRolesDeleteResponse() 8498 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8499 plumbing_response.rate_limit) 8500 return resp 8501 8502 def list(self, filter, *args, timeout=None): 8503 ''' 8504 Lists existing workflow roles. 8505 ''' 8506 deadline = None if timeout is None else time.time() + timeout 8507 req = WorkflowRolesListRequest() 8508 req.meta.CopyFrom(ListRequestMetadata()) 8509 if self.parent.page_limit > 0: 8510 req.meta.limit = self.parent.page_limit 8511 if self.parent.snapshot_datetime is not None: 8512 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8513 8514 req.filter = plumbing.quote_filter_args(filter, *args) 8515 8516 def generator(svc, req): 8517 tries = 0 8518 while True: 8519 t = None if deadline is None else deadline - time.time() 8520 try: 8521 plumbing_response = svc.stub.List( 8522 req, 8523 metadata=svc.parent.get_metadata( 8524 'WorkflowRoles.List', req), 8525 timeout=t) 8526 except Exception as e: 8527 if self.parent.shouldRetry(tries, e, deadline): 8528 tries += 1 8529 time.sleep( 8530 self.parent.exponentialBackoff(tries, deadline)) 8531 continue 8532 raise plumbing.convert_error_to_porcelain(e) from e 8533 tries = 0 8534 for plumbing_item in plumbing_response.workflow_role: 8535 yield plumbing.convert_workflow_role_to_porcelain( 8536 plumbing_item) 8537 if plumbing_response.meta.next_cursor == '': 8538 break 8539 req.meta.cursor = plumbing_response.meta.next_cursor 8540 8541 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)
8398 def create(self, workflow_role, timeout=None): 8399 ''' 8400 Create creates a new workflow role 8401 ''' 8402 deadline = None if timeout is None else time.time() + timeout 8403 req = WorkflowRolesCreateRequest() 8404 8405 if workflow_role is not None: 8406 req.workflow_role.CopyFrom( 8407 plumbing.convert_workflow_role_to_plumbing(workflow_role)) 8408 tries = 0 8409 plumbing_response = None 8410 while True: 8411 t = None if deadline is None else deadline - time.time() 8412 try: 8413 plumbing_response = self.stub.Create( 8414 req, 8415 metadata=self.parent.get_metadata('WorkflowRoles.Create', 8416 req), 8417 timeout=t) 8418 except Exception as e: 8419 if self.parent.shouldRetry(tries, e, deadline): 8420 tries += 1 8421 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8422 continue 8423 raise plumbing.convert_error_to_porcelain(e) from e 8424 break 8425 8426 resp = models.WorkflowRolesCreateResponse() 8427 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8428 plumbing_response.rate_limit) 8429 resp.workflow_role = plumbing.convert_workflow_role_to_porcelain( 8430 plumbing_response.workflow_role) 8431 return resp
Create creates a new workflow role
def
get(self, id, timeout=None)
8433 def get(self, id, timeout=None): 8434 ''' 8435 Get reads one workflow role by ID. 8436 ''' 8437 deadline = None if timeout is None else time.time() + timeout 8438 req = WorkflowRoleGetRequest() 8439 if self.parent.snapshot_datetime is not None: 8440 req.meta.CopyFrom(GetRequestMetadata()) 8441 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8442 8443 req.id = (id) 8444 tries = 0 8445 plumbing_response = None 8446 while True: 8447 t = None if deadline is None else deadline - time.time() 8448 try: 8449 plumbing_response = self.stub.Get( 8450 req, 8451 metadata=self.parent.get_metadata('WorkflowRoles.Get', 8452 req), 8453 timeout=t) 8454 except Exception as e: 8455 if self.parent.shouldRetry(tries, e, deadline): 8456 tries += 1 8457 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8458 continue 8459 raise plumbing.convert_error_to_porcelain(e) from e 8460 break 8461 8462 resp = models.WorkflowRoleGetResponse() 8463 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 8464 plumbing_response.meta) 8465 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8466 plumbing_response.rate_limit) 8467 resp.workflow_role = plumbing.convert_workflow_role_to_porcelain( 8468 plumbing_response.workflow_role) 8469 return resp
Get reads one workflow role by ID.
def
delete(self, id, timeout=None)
8471 def delete(self, id, timeout=None): 8472 ''' 8473 Delete deletes a workflow role 8474 ''' 8475 deadline = None if timeout is None else time.time() + timeout 8476 req = WorkflowRolesDeleteRequest() 8477 8478 req.id = (id) 8479 tries = 0 8480 plumbing_response = None 8481 while True: 8482 t = None if deadline is None else deadline - time.time() 8483 try: 8484 plumbing_response = self.stub.Delete( 8485 req, 8486 metadata=self.parent.get_metadata('WorkflowRoles.Delete', 8487 req), 8488 timeout=t) 8489 except Exception as e: 8490 if self.parent.shouldRetry(tries, e, deadline): 8491 tries += 1 8492 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8493 continue 8494 raise plumbing.convert_error_to_porcelain(e) from e 8495 break 8496 8497 resp = models.WorkflowRolesDeleteResponse() 8498 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8499 plumbing_response.rate_limit) 8500 return resp
Delete deletes a workflow role
def
list(self, filter, *args, timeout=None)
8502 def list(self, filter, *args, timeout=None): 8503 ''' 8504 Lists existing workflow roles. 8505 ''' 8506 deadline = None if timeout is None else time.time() + timeout 8507 req = WorkflowRolesListRequest() 8508 req.meta.CopyFrom(ListRequestMetadata()) 8509 if self.parent.page_limit > 0: 8510 req.meta.limit = self.parent.page_limit 8511 if self.parent.snapshot_datetime is not None: 8512 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8513 8514 req.filter = plumbing.quote_filter_args(filter, *args) 8515 8516 def generator(svc, req): 8517 tries = 0 8518 while True: 8519 t = None if deadline is None else deadline - time.time() 8520 try: 8521 plumbing_response = svc.stub.List( 8522 req, 8523 metadata=svc.parent.get_metadata( 8524 'WorkflowRoles.List', req), 8525 timeout=t) 8526 except Exception as e: 8527 if self.parent.shouldRetry(tries, e, deadline): 8528 tries += 1 8529 time.sleep( 8530 self.parent.exponentialBackoff(tries, deadline)) 8531 continue 8532 raise plumbing.convert_error_to_porcelain(e) from e 8533 tries = 0 8534 for plumbing_item in plumbing_response.workflow_role: 8535 yield plumbing.convert_workflow_role_to_porcelain( 8536 plumbing_item) 8537 if plumbing_response.meta.next_cursor == '': 8538 break 8539 req.meta.cursor = plumbing_response.meta.next_cursor 8540 8541 return generator(self, req)
Lists existing workflow roles.
class
SnapshotWorkflowRoles:
8544class SnapshotWorkflowRoles: 8545 ''' 8546 SnapshotWorkflowRoles exposes the read only methods of the WorkflowRoles 8547 service for historical queries. 8548 ''' 8549 def __init__(self, workflow_roles): 8550 self.workflow_roles = workflow_roles 8551 8552 def get(self, id, timeout=None): 8553 ''' 8554 Get reads one workflow role by ID. 8555 ''' 8556 return self.workflow_roles.get(id, timeout=timeout) 8557 8558 def list(self, filter, *args, timeout=None): 8559 ''' 8560 Lists existing workflow roles. 8561 ''' 8562 return self.workflow_roles.list(filter, *args, timeout=timeout)
SnapshotWorkflowRoles exposes the read only methods of the WorkflowRoles service for historical queries.
class
WorkflowRolesHistory:
8565class WorkflowRolesHistory: 8566 ''' 8567 WorkflowRolesHistory provides records of all changes to the state of a WorkflowRole 8568 See `strongdm.models.WorkflowRoleHistory`. 8569 ''' 8570 def __init__(self, channel, client): 8571 self.parent = client 8572 self.stub = WorkflowRolesHistoryStub(channel) 8573 8574 def list(self, filter, *args, timeout=None): 8575 ''' 8576 List gets a list of WorkflowRolesHistory records matching a given set of criteria. 8577 ''' 8578 deadline = None if timeout is None else time.time() + timeout 8579 req = WorkflowRolesHistoryListRequest() 8580 req.meta.CopyFrom(ListRequestMetadata()) 8581 if self.parent.page_limit > 0: 8582 req.meta.limit = self.parent.page_limit 8583 if self.parent.snapshot_datetime is not None: 8584 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8585 8586 req.filter = plumbing.quote_filter_args(filter, *args) 8587 8588 def generator(svc, req): 8589 tries = 0 8590 while True: 8591 t = None if deadline is None else deadline - time.time() 8592 try: 8593 plumbing_response = svc.stub.List( 8594 req, 8595 metadata=svc.parent.get_metadata( 8596 'WorkflowRolesHistory.List', req), 8597 timeout=t) 8598 except Exception as e: 8599 if self.parent.shouldRetry(tries, e, deadline): 8600 tries += 1 8601 time.sleep( 8602 self.parent.exponentialBackoff(tries, deadline)) 8603 continue 8604 raise plumbing.convert_error_to_porcelain(e) from e 8605 tries = 0 8606 for plumbing_item in plumbing_response.history: 8607 yield plumbing.convert_workflow_role_history_to_porcelain( 8608 plumbing_item) 8609 if plumbing_response.meta.next_cursor == '': 8610 break 8611 req.meta.cursor = plumbing_response.meta.next_cursor 8612 8613 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)
8574 def list(self, filter, *args, timeout=None): 8575 ''' 8576 List gets a list of WorkflowRolesHistory records matching a given set of criteria. 8577 ''' 8578 deadline = None if timeout is None else time.time() + timeout 8579 req = WorkflowRolesHistoryListRequest() 8580 req.meta.CopyFrom(ListRequestMetadata()) 8581 if self.parent.page_limit > 0: 8582 req.meta.limit = self.parent.page_limit 8583 if self.parent.snapshot_datetime is not None: 8584 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8585 8586 req.filter = plumbing.quote_filter_args(filter, *args) 8587 8588 def generator(svc, req): 8589 tries = 0 8590 while True: 8591 t = None if deadline is None else deadline - time.time() 8592 try: 8593 plumbing_response = svc.stub.List( 8594 req, 8595 metadata=svc.parent.get_metadata( 8596 'WorkflowRolesHistory.List', req), 8597 timeout=t) 8598 except Exception as e: 8599 if self.parent.shouldRetry(tries, e, deadline): 8600 tries += 1 8601 time.sleep( 8602 self.parent.exponentialBackoff(tries, deadline)) 8603 continue 8604 raise plumbing.convert_error_to_porcelain(e) from e 8605 tries = 0 8606 for plumbing_item in plumbing_response.history: 8607 yield plumbing.convert_workflow_role_history_to_porcelain( 8608 plumbing_item) 8609 if plumbing_response.meta.next_cursor == '': 8610 break 8611 req.meta.cursor = plumbing_response.meta.next_cursor 8612 8613 return generator(self, req)
List gets a list of WorkflowRolesHistory records matching a given set of criteria.
class
Workflows:
8616class Workflows: 8617 ''' 8618 Workflows are the collection of rules that define the resources to which access can be requested, 8619 the users that can request that access, and the mechanism for approving those requests which can either 8620 be automatic approval or a set of users authorized to approve the requests. 8621 See `strongdm.models.Workflow`. 8622 ''' 8623 def __init__(self, channel, client): 8624 self.parent = client 8625 self.stub = WorkflowsStub(channel) 8626 8627 def create(self, workflow, timeout=None): 8628 ''' 8629 Create creates a new workflow and requires a name for the workflow. 8630 ''' 8631 deadline = None if timeout is None else time.time() + timeout 8632 req = WorkflowCreateRequest() 8633 8634 if workflow is not None: 8635 req.workflow.CopyFrom( 8636 plumbing.convert_workflow_to_plumbing(workflow)) 8637 tries = 0 8638 plumbing_response = None 8639 while True: 8640 t = None if deadline is None else deadline - time.time() 8641 try: 8642 plumbing_response = self.stub.Create( 8643 req, 8644 metadata=self.parent.get_metadata('Workflows.Create', req), 8645 timeout=t) 8646 except Exception as e: 8647 if self.parent.shouldRetry(tries, e, deadline): 8648 tries += 1 8649 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8650 continue 8651 raise plumbing.convert_error_to_porcelain(e) from e 8652 break 8653 8654 resp = models.WorkflowCreateResponse() 8655 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8656 plumbing_response.rate_limit) 8657 resp.workflow = plumbing.convert_workflow_to_porcelain( 8658 plumbing_response.workflow) 8659 return resp 8660 8661 def get(self, id, timeout=None): 8662 ''' 8663 Get reads one workflow by ID. 8664 ''' 8665 deadline = None if timeout is None else time.time() + timeout 8666 req = WorkflowGetRequest() 8667 if self.parent.snapshot_datetime is not None: 8668 req.meta.CopyFrom(GetRequestMetadata()) 8669 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8670 8671 req.id = (id) 8672 tries = 0 8673 plumbing_response = None 8674 while True: 8675 t = None if deadline is None else deadline - time.time() 8676 try: 8677 plumbing_response = self.stub.Get( 8678 req, 8679 metadata=self.parent.get_metadata('Workflows.Get', req), 8680 timeout=t) 8681 except Exception as e: 8682 if self.parent.shouldRetry(tries, e, deadline): 8683 tries += 1 8684 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8685 continue 8686 raise plumbing.convert_error_to_porcelain(e) from e 8687 break 8688 8689 resp = models.WorkflowGetResponse() 8690 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 8691 plumbing_response.meta) 8692 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8693 plumbing_response.rate_limit) 8694 resp.workflow = plumbing.convert_workflow_to_porcelain( 8695 plumbing_response.workflow) 8696 return resp 8697 8698 def delete(self, id, timeout=None): 8699 ''' 8700 Delete deletes an existing workflow. 8701 ''' 8702 deadline = None if timeout is None else time.time() + timeout 8703 req = WorkflowDeleteRequest() 8704 8705 req.id = (id) 8706 tries = 0 8707 plumbing_response = None 8708 while True: 8709 t = None if deadline is None else deadline - time.time() 8710 try: 8711 plumbing_response = self.stub.Delete( 8712 req, 8713 metadata=self.parent.get_metadata('Workflows.Delete', req), 8714 timeout=t) 8715 except Exception as e: 8716 if self.parent.shouldRetry(tries, e, deadline): 8717 tries += 1 8718 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8719 continue 8720 raise plumbing.convert_error_to_porcelain(e) from e 8721 break 8722 8723 resp = models.WorkflowDeleteResponse() 8724 resp.id = (plumbing_response.id) 8725 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8726 plumbing_response.rate_limit) 8727 return resp 8728 8729 def update(self, workflow, timeout=None): 8730 ''' 8731 Update updates an existing workflow. 8732 ''' 8733 deadline = None if timeout is None else time.time() + timeout 8734 req = WorkflowUpdateRequest() 8735 8736 if workflow is not None: 8737 req.workflow.CopyFrom( 8738 plumbing.convert_workflow_to_plumbing(workflow)) 8739 tries = 0 8740 plumbing_response = None 8741 while True: 8742 t = None if deadline is None else deadline - time.time() 8743 try: 8744 plumbing_response = self.stub.Update( 8745 req, 8746 metadata=self.parent.get_metadata('Workflows.Update', req), 8747 timeout=t) 8748 except Exception as e: 8749 if self.parent.shouldRetry(tries, e, deadline): 8750 tries += 1 8751 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8752 continue 8753 raise plumbing.convert_error_to_porcelain(e) from e 8754 break 8755 8756 resp = models.WorkflowUpdateResponse() 8757 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8758 plumbing_response.rate_limit) 8759 resp.workflow = plumbing.convert_workflow_to_porcelain( 8760 plumbing_response.workflow) 8761 return resp 8762 8763 def list(self, filter, *args, timeout=None): 8764 ''' 8765 Lists existing workflows. 8766 ''' 8767 deadline = None if timeout is None else time.time() + timeout 8768 req = WorkflowListRequest() 8769 req.meta.CopyFrom(ListRequestMetadata()) 8770 if self.parent.page_limit > 0: 8771 req.meta.limit = self.parent.page_limit 8772 if self.parent.snapshot_datetime is not None: 8773 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8774 8775 req.filter = plumbing.quote_filter_args(filter, *args) 8776 8777 def generator(svc, req): 8778 tries = 0 8779 while True: 8780 t = None if deadline is None else deadline - time.time() 8781 try: 8782 plumbing_response = svc.stub.List( 8783 req, 8784 metadata=svc.parent.get_metadata( 8785 'Workflows.List', req), 8786 timeout=t) 8787 except Exception as e: 8788 if self.parent.shouldRetry(tries, e, deadline): 8789 tries += 1 8790 time.sleep( 8791 self.parent.exponentialBackoff(tries, deadline)) 8792 continue 8793 raise plumbing.convert_error_to_porcelain(e) from e 8794 tries = 0 8795 for plumbing_item in plumbing_response.workflows: 8796 yield plumbing.convert_workflow_to_porcelain(plumbing_item) 8797 if plumbing_response.meta.next_cursor == '': 8798 break 8799 req.meta.cursor = plumbing_response.meta.next_cursor 8800 8801 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)
8627 def create(self, workflow, timeout=None): 8628 ''' 8629 Create creates a new workflow and requires a name for the workflow. 8630 ''' 8631 deadline = None if timeout is None else time.time() + timeout 8632 req = WorkflowCreateRequest() 8633 8634 if workflow is not None: 8635 req.workflow.CopyFrom( 8636 plumbing.convert_workflow_to_plumbing(workflow)) 8637 tries = 0 8638 plumbing_response = None 8639 while True: 8640 t = None if deadline is None else deadline - time.time() 8641 try: 8642 plumbing_response = self.stub.Create( 8643 req, 8644 metadata=self.parent.get_metadata('Workflows.Create', req), 8645 timeout=t) 8646 except Exception as e: 8647 if self.parent.shouldRetry(tries, e, deadline): 8648 tries += 1 8649 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8650 continue 8651 raise plumbing.convert_error_to_porcelain(e) from e 8652 break 8653 8654 resp = models.WorkflowCreateResponse() 8655 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8656 plumbing_response.rate_limit) 8657 resp.workflow = plumbing.convert_workflow_to_porcelain( 8658 plumbing_response.workflow) 8659 return resp
Create creates a new workflow and requires a name for the workflow.
def
get(self, id, timeout=None)
8661 def get(self, id, timeout=None): 8662 ''' 8663 Get reads one workflow by ID. 8664 ''' 8665 deadline = None if timeout is None else time.time() + timeout 8666 req = WorkflowGetRequest() 8667 if self.parent.snapshot_datetime is not None: 8668 req.meta.CopyFrom(GetRequestMetadata()) 8669 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8670 8671 req.id = (id) 8672 tries = 0 8673 plumbing_response = None 8674 while True: 8675 t = None if deadline is None else deadline - time.time() 8676 try: 8677 plumbing_response = self.stub.Get( 8678 req, 8679 metadata=self.parent.get_metadata('Workflows.Get', req), 8680 timeout=t) 8681 except Exception as e: 8682 if self.parent.shouldRetry(tries, e, deadline): 8683 tries += 1 8684 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8685 continue 8686 raise plumbing.convert_error_to_porcelain(e) from e 8687 break 8688 8689 resp = models.WorkflowGetResponse() 8690 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 8691 plumbing_response.meta) 8692 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8693 plumbing_response.rate_limit) 8694 resp.workflow = plumbing.convert_workflow_to_porcelain( 8695 plumbing_response.workflow) 8696 return resp
Get reads one workflow by ID.
def
delete(self, id, timeout=None)
8698 def delete(self, id, timeout=None): 8699 ''' 8700 Delete deletes an existing workflow. 8701 ''' 8702 deadline = None if timeout is None else time.time() + timeout 8703 req = WorkflowDeleteRequest() 8704 8705 req.id = (id) 8706 tries = 0 8707 plumbing_response = None 8708 while True: 8709 t = None if deadline is None else deadline - time.time() 8710 try: 8711 plumbing_response = self.stub.Delete( 8712 req, 8713 metadata=self.parent.get_metadata('Workflows.Delete', req), 8714 timeout=t) 8715 except Exception as e: 8716 if self.parent.shouldRetry(tries, e, deadline): 8717 tries += 1 8718 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8719 continue 8720 raise plumbing.convert_error_to_porcelain(e) from e 8721 break 8722 8723 resp = models.WorkflowDeleteResponse() 8724 resp.id = (plumbing_response.id) 8725 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8726 plumbing_response.rate_limit) 8727 return resp
Delete deletes an existing workflow.
def
update(self, workflow, timeout=None)
8729 def update(self, workflow, timeout=None): 8730 ''' 8731 Update updates an existing workflow. 8732 ''' 8733 deadline = None if timeout is None else time.time() + timeout 8734 req = WorkflowUpdateRequest() 8735 8736 if workflow is not None: 8737 req.workflow.CopyFrom( 8738 plumbing.convert_workflow_to_plumbing(workflow)) 8739 tries = 0 8740 plumbing_response = None 8741 while True: 8742 t = None if deadline is None else deadline - time.time() 8743 try: 8744 plumbing_response = self.stub.Update( 8745 req, 8746 metadata=self.parent.get_metadata('Workflows.Update', req), 8747 timeout=t) 8748 except Exception as e: 8749 if self.parent.shouldRetry(tries, e, deadline): 8750 tries += 1 8751 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8752 continue 8753 raise plumbing.convert_error_to_porcelain(e) from e 8754 break 8755 8756 resp = models.WorkflowUpdateResponse() 8757 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8758 plumbing_response.rate_limit) 8759 resp.workflow = plumbing.convert_workflow_to_porcelain( 8760 plumbing_response.workflow) 8761 return resp
Update updates an existing workflow.
def
list(self, filter, *args, timeout=None)
8763 def list(self, filter, *args, timeout=None): 8764 ''' 8765 Lists existing workflows. 8766 ''' 8767 deadline = None if timeout is None else time.time() + timeout 8768 req = WorkflowListRequest() 8769 req.meta.CopyFrom(ListRequestMetadata()) 8770 if self.parent.page_limit > 0: 8771 req.meta.limit = self.parent.page_limit 8772 if self.parent.snapshot_datetime is not None: 8773 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8774 8775 req.filter = plumbing.quote_filter_args(filter, *args) 8776 8777 def generator(svc, req): 8778 tries = 0 8779 while True: 8780 t = None if deadline is None else deadline - time.time() 8781 try: 8782 plumbing_response = svc.stub.List( 8783 req, 8784 metadata=svc.parent.get_metadata( 8785 'Workflows.List', req), 8786 timeout=t) 8787 except Exception as e: 8788 if self.parent.shouldRetry(tries, e, deadline): 8789 tries += 1 8790 time.sleep( 8791 self.parent.exponentialBackoff(tries, deadline)) 8792 continue 8793 raise plumbing.convert_error_to_porcelain(e) from e 8794 tries = 0 8795 for plumbing_item in plumbing_response.workflows: 8796 yield plumbing.convert_workflow_to_porcelain(plumbing_item) 8797 if plumbing_response.meta.next_cursor == '': 8798 break 8799 req.meta.cursor = plumbing_response.meta.next_cursor 8800 8801 return generator(self, req)
Lists existing workflows.
class
SnapshotWorkflows:
8804class SnapshotWorkflows: 8805 ''' 8806 SnapshotWorkflows exposes the read only methods of the Workflows 8807 service for historical queries. 8808 ''' 8809 def __init__(self, workflows): 8810 self.workflows = workflows 8811 8812 def get(self, id, timeout=None): 8813 ''' 8814 Get reads one workflow by ID. 8815 ''' 8816 return self.workflows.get(id, timeout=timeout) 8817 8818 def list(self, filter, *args, timeout=None): 8819 ''' 8820 Lists existing workflows. 8821 ''' 8822 return self.workflows.list(filter, *args, timeout=timeout)
SnapshotWorkflows exposes the read only methods of the Workflows service for historical queries.
class
WorkflowsHistory:
8825class WorkflowsHistory: 8826 ''' 8827 WorkflowsHistory provides records of all changes to the state of a Workflow. 8828 See `strongdm.models.WorkflowHistory`. 8829 ''' 8830 def __init__(self, channel, client): 8831 self.parent = client 8832 self.stub = WorkflowsHistoryStub(channel) 8833 8834 def list(self, filter, *args, timeout=None): 8835 ''' 8836 List gets a list of WorkflowHistory records matching a given set of criteria. 8837 ''' 8838 deadline = None if timeout is None else time.time() + timeout 8839 req = WorkflowHistoryListRequest() 8840 req.meta.CopyFrom(ListRequestMetadata()) 8841 if self.parent.page_limit > 0: 8842 req.meta.limit = self.parent.page_limit 8843 if self.parent.snapshot_datetime is not None: 8844 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8845 8846 req.filter = plumbing.quote_filter_args(filter, *args) 8847 8848 def generator(svc, req): 8849 tries = 0 8850 while True: 8851 t = None if deadline is None else deadline - time.time() 8852 try: 8853 plumbing_response = svc.stub.List( 8854 req, 8855 metadata=svc.parent.get_metadata( 8856 'WorkflowsHistory.List', req), 8857 timeout=t) 8858 except Exception as e: 8859 if self.parent.shouldRetry(tries, e, deadline): 8860 tries += 1 8861 time.sleep( 8862 self.parent.exponentialBackoff(tries, deadline)) 8863 continue 8864 raise plumbing.convert_error_to_porcelain(e) from e 8865 tries = 0 8866 for plumbing_item in plumbing_response.history: 8867 yield plumbing.convert_workflow_history_to_porcelain( 8868 plumbing_item) 8869 if plumbing_response.meta.next_cursor == '': 8870 break 8871 req.meta.cursor = plumbing_response.meta.next_cursor 8872 8873 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)
8834 def list(self, filter, *args, timeout=None): 8835 ''' 8836 List gets a list of WorkflowHistory records matching a given set of criteria. 8837 ''' 8838 deadline = None if timeout is None else time.time() + timeout 8839 req = WorkflowHistoryListRequest() 8840 req.meta.CopyFrom(ListRequestMetadata()) 8841 if self.parent.page_limit > 0: 8842 req.meta.limit = self.parent.page_limit 8843 if self.parent.snapshot_datetime is not None: 8844 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8845 8846 req.filter = plumbing.quote_filter_args(filter, *args) 8847 8848 def generator(svc, req): 8849 tries = 0 8850 while True: 8851 t = None if deadline is None else deadline - time.time() 8852 try: 8853 plumbing_response = svc.stub.List( 8854 req, 8855 metadata=svc.parent.get_metadata( 8856 'WorkflowsHistory.List', req), 8857 timeout=t) 8858 except Exception as e: 8859 if self.parent.shouldRetry(tries, e, deadline): 8860 tries += 1 8861 time.sleep( 8862 self.parent.exponentialBackoff(tries, deadline)) 8863 continue 8864 raise plumbing.convert_error_to_porcelain(e) from e 8865 tries = 0 8866 for plumbing_item in plumbing_response.history: 8867 yield plumbing.convert_workflow_history_to_porcelain( 8868 plumbing_item) 8869 if plumbing_response.meta.next_cursor == '': 8870 break 8871 req.meta.cursor = plumbing_response.meta.next_cursor 8872 8873 return generator(self, req)
List gets a list of WorkflowHistory records matching a given set of criteria.