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 .authorization_policies_pb2 import * 74from .authorization_policies_pb2_grpc import * 75from .control_panel_pb2 import * 76from .control_panel_pb2_grpc import * 77from .discovery_connectors_pb2 import * 78from .discovery_connectors_pb2_grpc import * 79from .granted_account_entitlements_pb2 import * 80from .granted_account_entitlements_pb2_grpc import * 81from .granted_resource_entitlements_pb2 import * 82from .granted_resource_entitlements_pb2_grpc import * 83from .granted_role_entitlements_pb2 import * 84from .granted_role_entitlements_pb2_grpc import * 85from .roles_pb2 import * 86from .roles_pb2_grpc import * 87from .groups_pb2 import * 88from .groups_pb2_grpc import * 89from .groups_history_pb2 import * 90from .groups_history_pb2_grpc import * 91from .groups_roles_pb2 import * 92from .groups_roles_pb2_grpc import * 93from .groups_roles_history_pb2 import * 94from .groups_roles_history_pb2_grpc import * 95from .health_checks_pb2 import * 96from .health_checks_pb2_grpc import * 97from .identity_aliases_pb2 import * 98from .identity_aliases_pb2_grpc import * 99from .identity_aliases_history_pb2 import * 100from .identity_aliases_history_pb2_grpc import * 101from .identity_sets_pb2 import * 102from .identity_sets_pb2_grpc import * 103from .identity_sets_history_pb2 import * 104from .identity_sets_history_pb2_grpc import * 105from .managed_secrets_pb2 import * 106from .managed_secrets_pb2_grpc import * 107from .nodes_pb2 import * 108from .nodes_pb2_grpc import * 109from .nodes_history_pb2 import * 110from .nodes_history_pb2_grpc import * 111from .organization_history_pb2 import * 112from .organization_history_pb2_grpc import * 113from .peering_group_nodes_pb2 import * 114from .peering_group_nodes_pb2_grpc import * 115from .peering_group_peers_pb2 import * 116from .peering_group_peers_pb2_grpc import * 117from .peering_group_resources_pb2 import * 118from .peering_group_resources_pb2_grpc import * 119from .peering_groups_pb2 import * 120from .peering_groups_pb2_grpc import * 121from .policies_pb2 import * 122from .policies_pb2_grpc import * 123from .policies_history_pb2 import * 124from .policies_history_pb2_grpc import * 125from .proxy_cluster_keys_pb2 import * 126from .proxy_cluster_keys_pb2_grpc import * 127from .queries_pb2 import * 128from .queries_pb2_grpc import * 129from .remote_identities_pb2 import * 130from .remote_identities_pb2_grpc import * 131from .remote_identities_history_pb2 import * 132from .remote_identities_history_pb2_grpc import * 133from .remote_identity_groups_pb2 import * 134from .remote_identity_groups_pb2_grpc import * 135from .remote_identity_groups_history_pb2 import * 136from .remote_identity_groups_history_pb2_grpc import * 137from .replays_pb2 import * 138from .replays_pb2_grpc import * 139from .resources_pb2 import * 140from .resources_pb2_grpc import * 141from .resources_history_pb2 import * 142from .resources_history_pb2_grpc import * 143from .resourcetypes_pb2 import * 144from .resourcetypes_pb2_grpc import * 145from .role_resources_pb2 import * 146from .role_resources_pb2_grpc import * 147from .role_resources_history_pb2 import * 148from .role_resources_history_pb2_grpc import * 149from .roles_history_pb2 import * 150from .roles_history_pb2_grpc import * 151from .secret_engine_policy_pb2 import * 152from .secret_engine_policy_pb2_grpc import * 153from .secret_engine_types_pb2 import * 154from .secret_engine_types_pb2_grpc import * 155from .secret_store_types_pb2 import * 156from .secret_store_types_pb2_grpc import * 157from .secret_stores_pb2 import * 158from .secret_stores_pb2_grpc import * 159from .secret_engines_pb2 import * 160from .secret_engines_pb2_grpc import * 161from .secret_store_healths_pb2 import * 162from .secret_store_healths_pb2_grpc import * 163from .secret_stores_history_pb2 import * 164from .secret_stores_history_pb2_grpc import * 165from .workflow_approvers_pb2 import * 166from .workflow_approvers_pb2_grpc import * 167from .workflow_approvers_history_pb2 import * 168from .workflow_approvers_history_pb2_grpc import * 169from .workflow_roles_pb2 import * 170from .workflow_roles_pb2_grpc import * 171from .workflow_roles_history_pb2 import * 172from .workflow_roles_history_pb2_grpc import * 173from .workflows_pb2 import * 174from .workflows_pb2_grpc import * 175from .workflows_history_pb2 import * 176from .workflows_history_pb2_grpc import * 177import warnings 178import functools 179import time 180 181 182def deprecated(func): 183 """This is a decorator which can be used to mark functions 184 as deprecated. It will result in a warning being emitted 185 when the function is used.""" 186 @functools.wraps(func) 187 def new_func(*args, **kwargs): 188 warnings.warn("Call to deprecated function {}.".format(func.__name__), 189 category=DeprecationWarning, 190 stacklevel=2) 191 return func(*args, **kwargs) 192 193 return new_func 194 195 196class AccessRequests: 197 ''' 198 AccessRequests are requests for access to a resource that may match a Workflow. 199 See `strongdm.models.AccessRequest`. 200 ''' 201 def __init__(self, channel, client): 202 self.parent = client 203 self.stub = AccessRequestsStub(channel) 204 205 def list(self, filter, *args, timeout=None): 206 ''' 207 Lists existing access requests. 208 ''' 209 deadline = None if timeout is None else time.time() + timeout 210 req = AccessRequestListRequest() 211 req.meta.CopyFrom(ListRequestMetadata()) 212 if self.parent.page_limit > 0: 213 req.meta.limit = self.parent.page_limit 214 if self.parent.snapshot_datetime is not None: 215 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 216 217 req.filter = plumbing.quote_filter_args(filter, *args) 218 219 def generator(svc, req): 220 tries = 0 221 while True: 222 t = None if deadline is None else deadline - time.time() 223 try: 224 plumbing_response = svc.stub.List( 225 req, 226 metadata=svc.parent.get_metadata( 227 'AccessRequests.List', req), 228 timeout=t) 229 except Exception as e: 230 if self.parent.shouldRetry(tries, e, deadline): 231 tries += 1 232 time.sleep( 233 self.parent.exponentialBackoff(tries, deadline)) 234 continue 235 raise plumbing.convert_error_to_porcelain(e) from e 236 tries = 0 237 for plumbing_item in plumbing_response.access_requests: 238 yield plumbing.convert_access_request_to_porcelain( 239 plumbing_item) 240 if plumbing_response.meta.next_cursor == '': 241 break 242 req.meta.cursor = plumbing_response.meta.next_cursor 243 244 return generator(self, req) 245 246 247class SnapshotAccessRequests: 248 ''' 249 SnapshotAccessRequests exposes the read only methods of the AccessRequests 250 service for historical queries. 251 ''' 252 def __init__(self, access_requests): 253 self.access_requests = access_requests 254 255 def list(self, filter, *args, timeout=None): 256 ''' 257 Lists existing access requests. 258 ''' 259 return self.access_requests.list(filter, *args, timeout=timeout) 260 261 262class AccessRequestEventsHistory: 263 ''' 264 AccessRequestEventsHistory provides records of all changes to the state of an AccessRequest. 265 See `strongdm.models.AccessRequestEventHistory`. 266 ''' 267 def __init__(self, channel, client): 268 self.parent = client 269 self.stub = AccessRequestEventsHistoryStub(channel) 270 271 def list(self, filter, *args, timeout=None): 272 ''' 273 List gets a list of AccessRequestEventHistory records matching a given set of criteria. 274 ''' 275 deadline = None if timeout is None else time.time() + timeout 276 req = AccessRequestEventHistoryListRequest() 277 req.meta.CopyFrom(ListRequestMetadata()) 278 if self.parent.page_limit > 0: 279 req.meta.limit = self.parent.page_limit 280 if self.parent.snapshot_datetime is not None: 281 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 282 283 req.filter = plumbing.quote_filter_args(filter, *args) 284 285 def generator(svc, req): 286 tries = 0 287 while True: 288 t = None if deadline is None else deadline - time.time() 289 try: 290 plumbing_response = svc.stub.List( 291 req, 292 metadata=svc.parent.get_metadata( 293 'AccessRequestEventsHistory.List', req), 294 timeout=t) 295 except Exception as e: 296 if self.parent.shouldRetry(tries, e, deadline): 297 tries += 1 298 time.sleep( 299 self.parent.exponentialBackoff(tries, deadline)) 300 continue 301 raise plumbing.convert_error_to_porcelain(e) from e 302 tries = 0 303 for plumbing_item in plumbing_response.history: 304 yield plumbing.convert_access_request_event_history_to_porcelain( 305 plumbing_item) 306 if plumbing_response.meta.next_cursor == '': 307 break 308 req.meta.cursor = plumbing_response.meta.next_cursor 309 310 return generator(self, req) 311 312 313class AccessRequestsHistory: 314 ''' 315 AccessRequestsHistory provides records of all changes to the state of an AccessRequest. 316 See `strongdm.models.AccessRequestHistory`. 317 ''' 318 def __init__(self, channel, client): 319 self.parent = client 320 self.stub = AccessRequestsHistoryStub(channel) 321 322 def list(self, filter, *args, timeout=None): 323 ''' 324 List gets a list of AccessRequestHistory records matching a given set of criteria. 325 ''' 326 deadline = None if timeout is None else time.time() + timeout 327 req = AccessRequestHistoryListRequest() 328 req.meta.CopyFrom(ListRequestMetadata()) 329 if self.parent.page_limit > 0: 330 req.meta.limit = self.parent.page_limit 331 if self.parent.snapshot_datetime is not None: 332 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 333 334 req.filter = plumbing.quote_filter_args(filter, *args) 335 336 def generator(svc, req): 337 tries = 0 338 while True: 339 t = None if deadline is None else deadline - time.time() 340 try: 341 plumbing_response = svc.stub.List( 342 req, 343 metadata=svc.parent.get_metadata( 344 'AccessRequestsHistory.List', req), 345 timeout=t) 346 except Exception as e: 347 if self.parent.shouldRetry(tries, e, deadline): 348 tries += 1 349 time.sleep( 350 self.parent.exponentialBackoff(tries, deadline)) 351 continue 352 raise plumbing.convert_error_to_porcelain(e) from e 353 tries = 0 354 for plumbing_item in plumbing_response.history: 355 yield plumbing.convert_access_request_history_to_porcelain( 356 plumbing_item) 357 if plumbing_response.meta.next_cursor == '': 358 break 359 req.meta.cursor = plumbing_response.meta.next_cursor 360 361 return generator(self, req) 362 363 364class AccountAttachments: 365 ''' 366 AccountAttachments assign an account to a role. 367 See `strongdm.models.AccountAttachment`. 368 ''' 369 def __init__(self, channel, client): 370 self.parent = client 371 self.stub = AccountAttachmentsStub(channel) 372 373 def create(self, account_attachment, timeout=None): 374 ''' 375 Create registers a new AccountAttachment. 376 ''' 377 deadline = None if timeout is None else time.time() + timeout 378 req = AccountAttachmentCreateRequest() 379 380 if account_attachment is not None: 381 req.account_attachment.CopyFrom( 382 plumbing.convert_account_attachment_to_plumbing( 383 account_attachment)) 384 tries = 0 385 plumbing_response = None 386 while True: 387 t = None if deadline is None else deadline - time.time() 388 try: 389 plumbing_response = self.stub.Create( 390 req, 391 metadata=self.parent.get_metadata( 392 'AccountAttachments.Create', req), 393 timeout=t) 394 except Exception as e: 395 if self.parent.shouldRetry(tries, e, deadline): 396 tries += 1 397 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 398 continue 399 raise plumbing.convert_error_to_porcelain(e) from e 400 break 401 402 resp = models.AccountAttachmentCreateResponse() 403 resp.account_attachment = plumbing.convert_account_attachment_to_porcelain( 404 plumbing_response.account_attachment) 405 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 406 plumbing_response.meta) 407 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 408 plumbing_response.rate_limit) 409 return resp 410 411 def get(self, id, timeout=None): 412 ''' 413 Get reads one AccountAttachment by ID. 414 ''' 415 deadline = None if timeout is None else time.time() + timeout 416 req = AccountAttachmentGetRequest() 417 if self.parent.snapshot_datetime is not None: 418 req.meta.CopyFrom(GetRequestMetadata()) 419 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 420 421 req.id = (id) 422 tries = 0 423 plumbing_response = None 424 while True: 425 t = None if deadline is None else deadline - time.time() 426 try: 427 plumbing_response = self.stub.Get( 428 req, 429 metadata=self.parent.get_metadata('AccountAttachments.Get', 430 req), 431 timeout=t) 432 except Exception as e: 433 if self.parent.shouldRetry(tries, e, deadline): 434 tries += 1 435 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 436 continue 437 raise plumbing.convert_error_to_porcelain(e) from e 438 break 439 440 resp = models.AccountAttachmentGetResponse() 441 resp.account_attachment = plumbing.convert_account_attachment_to_porcelain( 442 plumbing_response.account_attachment) 443 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 444 plumbing_response.meta) 445 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 446 plumbing_response.rate_limit) 447 return resp 448 449 def delete(self, id, timeout=None): 450 ''' 451 Delete removes a AccountAttachment by ID. 452 ''' 453 deadline = None if timeout is None else time.time() + timeout 454 req = AccountAttachmentDeleteRequest() 455 456 req.id = (id) 457 tries = 0 458 plumbing_response = None 459 while True: 460 t = None if deadline is None else deadline - time.time() 461 try: 462 plumbing_response = self.stub.Delete( 463 req, 464 metadata=self.parent.get_metadata( 465 'AccountAttachments.Delete', req), 466 timeout=t) 467 except Exception as e: 468 if self.parent.shouldRetry(tries, e, deadline): 469 tries += 1 470 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 471 continue 472 raise plumbing.convert_error_to_porcelain(e) from e 473 break 474 475 resp = models.AccountAttachmentDeleteResponse() 476 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 477 plumbing_response.meta) 478 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 479 plumbing_response.rate_limit) 480 return resp 481 482 def list(self, filter, *args, timeout=None): 483 ''' 484 List gets a list of AccountAttachments matching a given set of criteria. 485 ''' 486 deadline = None if timeout is None else time.time() + timeout 487 req = AccountAttachmentListRequest() 488 req.meta.CopyFrom(ListRequestMetadata()) 489 if self.parent.page_limit > 0: 490 req.meta.limit = self.parent.page_limit 491 if self.parent.snapshot_datetime is not None: 492 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 493 494 req.filter = plumbing.quote_filter_args(filter, *args) 495 496 def generator(svc, req): 497 tries = 0 498 while True: 499 t = None if deadline is None else deadline - time.time() 500 try: 501 plumbing_response = svc.stub.List( 502 req, 503 metadata=svc.parent.get_metadata( 504 'AccountAttachments.List', req), 505 timeout=t) 506 except Exception as e: 507 if self.parent.shouldRetry(tries, e, deadline): 508 tries += 1 509 time.sleep( 510 self.parent.exponentialBackoff(tries, deadline)) 511 continue 512 raise plumbing.convert_error_to_porcelain(e) from e 513 tries = 0 514 for plumbing_item in plumbing_response.account_attachments: 515 yield plumbing.convert_account_attachment_to_porcelain( 516 plumbing_item) 517 if plumbing_response.meta.next_cursor == '': 518 break 519 req.meta.cursor = plumbing_response.meta.next_cursor 520 521 return generator(self, req) 522 523 524class SnapshotAccountAttachments: 525 ''' 526 SnapshotAccountAttachments exposes the read only methods of the AccountAttachments 527 service for historical queries. 528 ''' 529 def __init__(self, account_attachments): 530 self.account_attachments = account_attachments 531 532 def get(self, id, timeout=None): 533 ''' 534 Get reads one AccountAttachment by ID. 535 ''' 536 return self.account_attachments.get(id, timeout=timeout) 537 538 def list(self, filter, *args, timeout=None): 539 ''' 540 List gets a list of AccountAttachments matching a given set of criteria. 541 ''' 542 return self.account_attachments.list(filter, *args, timeout=timeout) 543 544 545class AccountAttachmentsHistory: 546 ''' 547 AccountAttachmentsHistory records all changes to the state of an AccountAttachment. 548 See `strongdm.models.AccountAttachmentHistory`. 549 ''' 550 def __init__(self, channel, client): 551 self.parent = client 552 self.stub = AccountAttachmentsHistoryStub(channel) 553 554 def list(self, filter, *args, timeout=None): 555 ''' 556 List gets a list of AccountAttachmentHistory records matching a given set of criteria. 557 ''' 558 deadline = None if timeout is None else time.time() + timeout 559 req = AccountAttachmentHistoryListRequest() 560 req.meta.CopyFrom(ListRequestMetadata()) 561 if self.parent.page_limit > 0: 562 req.meta.limit = self.parent.page_limit 563 if self.parent.snapshot_datetime is not None: 564 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 565 566 req.filter = plumbing.quote_filter_args(filter, *args) 567 568 def generator(svc, req): 569 tries = 0 570 while True: 571 t = None if deadline is None else deadline - time.time() 572 try: 573 plumbing_response = svc.stub.List( 574 req, 575 metadata=svc.parent.get_metadata( 576 'AccountAttachmentsHistory.List', req), 577 timeout=t) 578 except Exception as e: 579 if self.parent.shouldRetry(tries, e, deadline): 580 tries += 1 581 time.sleep( 582 self.parent.exponentialBackoff(tries, deadline)) 583 continue 584 raise plumbing.convert_error_to_porcelain(e) from e 585 tries = 0 586 for plumbing_item in plumbing_response.history: 587 yield plumbing.convert_account_attachment_history_to_porcelain( 588 plumbing_item) 589 if plumbing_response.meta.next_cursor == '': 590 break 591 req.meta.cursor = plumbing_response.meta.next_cursor 592 593 return generator(self, req) 594 595 596class AccountGrants: 597 ''' 598 AccountGrants assign a resource directly to an account, giving the account the permission to connect to that resource. 599 See `strongdm.models.AccountGrant`. 600 ''' 601 def __init__(self, channel, client): 602 self.parent = client 603 self.stub = AccountGrantsStub(channel) 604 605 def create(self, account_grant, timeout=None): 606 ''' 607 Create registers a new AccountGrant. 608 ''' 609 deadline = None if timeout is None else time.time() + timeout 610 req = AccountGrantCreateRequest() 611 612 if account_grant is not None: 613 req.account_grant.CopyFrom( 614 plumbing.convert_account_grant_to_plumbing(account_grant)) 615 tries = 0 616 plumbing_response = None 617 while True: 618 t = None if deadline is None else deadline - time.time() 619 try: 620 plumbing_response = self.stub.Create( 621 req, 622 metadata=self.parent.get_metadata('AccountGrants.Create', 623 req), 624 timeout=t) 625 except Exception as e: 626 if self.parent.shouldRetry(tries, e, deadline): 627 tries += 1 628 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 629 continue 630 raise plumbing.convert_error_to_porcelain(e) from e 631 break 632 633 resp = models.AccountGrantCreateResponse() 634 resp.account_grant = plumbing.convert_account_grant_to_porcelain( 635 plumbing_response.account_grant) 636 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 637 plumbing_response.meta) 638 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 639 plumbing_response.rate_limit) 640 return resp 641 642 def get(self, id, timeout=None): 643 ''' 644 Get reads one AccountGrant by ID. 645 ''' 646 deadline = None if timeout is None else time.time() + timeout 647 req = AccountGrantGetRequest() 648 if self.parent.snapshot_datetime is not None: 649 req.meta.CopyFrom(GetRequestMetadata()) 650 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 651 652 req.id = (id) 653 tries = 0 654 plumbing_response = None 655 while True: 656 t = None if deadline is None else deadline - time.time() 657 try: 658 plumbing_response = self.stub.Get( 659 req, 660 metadata=self.parent.get_metadata('AccountGrants.Get', 661 req), 662 timeout=t) 663 except Exception as e: 664 if self.parent.shouldRetry(tries, e, deadline): 665 tries += 1 666 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 667 continue 668 raise plumbing.convert_error_to_porcelain(e) from e 669 break 670 671 resp = models.AccountGrantGetResponse() 672 resp.account_grant = plumbing.convert_account_grant_to_porcelain( 673 plumbing_response.account_grant) 674 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 675 plumbing_response.meta) 676 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 677 plumbing_response.rate_limit) 678 return resp 679 680 def delete(self, id, timeout=None): 681 ''' 682 Delete removes a AccountGrant by ID. 683 ''' 684 deadline = None if timeout is None else time.time() + timeout 685 req = AccountGrantDeleteRequest() 686 687 req.id = (id) 688 tries = 0 689 plumbing_response = None 690 while True: 691 t = None if deadline is None else deadline - time.time() 692 try: 693 plumbing_response = self.stub.Delete( 694 req, 695 metadata=self.parent.get_metadata('AccountGrants.Delete', 696 req), 697 timeout=t) 698 except Exception as e: 699 if self.parent.shouldRetry(tries, e, deadline): 700 tries += 1 701 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 702 continue 703 raise plumbing.convert_error_to_porcelain(e) from e 704 break 705 706 resp = models.AccountGrantDeleteResponse() 707 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 708 plumbing_response.meta) 709 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 710 plumbing_response.rate_limit) 711 return resp 712 713 def list(self, filter, *args, timeout=None): 714 ''' 715 List gets a list of AccountGrants matching a given set of criteria. 716 ''' 717 deadline = None if timeout is None else time.time() + timeout 718 req = AccountGrantListRequest() 719 req.meta.CopyFrom(ListRequestMetadata()) 720 if self.parent.page_limit > 0: 721 req.meta.limit = self.parent.page_limit 722 if self.parent.snapshot_datetime is not None: 723 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 724 725 req.filter = plumbing.quote_filter_args(filter, *args) 726 727 def generator(svc, req): 728 tries = 0 729 while True: 730 t = None if deadline is None else deadline - time.time() 731 try: 732 plumbing_response = svc.stub.List( 733 req, 734 metadata=svc.parent.get_metadata( 735 'AccountGrants.List', req), 736 timeout=t) 737 except Exception as e: 738 if self.parent.shouldRetry(tries, e, deadline): 739 tries += 1 740 time.sleep( 741 self.parent.exponentialBackoff(tries, deadline)) 742 continue 743 raise plumbing.convert_error_to_porcelain(e) from e 744 tries = 0 745 for plumbing_item in plumbing_response.account_grants: 746 yield plumbing.convert_account_grant_to_porcelain( 747 plumbing_item) 748 if plumbing_response.meta.next_cursor == '': 749 break 750 req.meta.cursor = plumbing_response.meta.next_cursor 751 752 return generator(self, req) 753 754 755class SnapshotAccountGrants: 756 ''' 757 SnapshotAccountGrants exposes the read only methods of the AccountGrants 758 service for historical queries. 759 ''' 760 def __init__(self, account_grants): 761 self.account_grants = account_grants 762 763 def get(self, id, timeout=None): 764 ''' 765 Get reads one AccountGrant by ID. 766 ''' 767 return self.account_grants.get(id, timeout=timeout) 768 769 def list(self, filter, *args, timeout=None): 770 ''' 771 List gets a list of AccountGrants matching a given set of criteria. 772 ''' 773 return self.account_grants.list(filter, *args, timeout=timeout) 774 775 776class AccountGrantsHistory: 777 ''' 778 AccountGrantsHistory records all changes to the state of an AccountGrant. 779 See `strongdm.models.AccountGrantHistory`. 780 ''' 781 def __init__(self, channel, client): 782 self.parent = client 783 self.stub = AccountGrantsHistoryStub(channel) 784 785 def list(self, filter, *args, timeout=None): 786 ''' 787 List gets a list of AccountGrantHistory records matching a given set of criteria. 788 ''' 789 deadline = None if timeout is None else time.time() + timeout 790 req = AccountGrantHistoryListRequest() 791 req.meta.CopyFrom(ListRequestMetadata()) 792 if self.parent.page_limit > 0: 793 req.meta.limit = self.parent.page_limit 794 if self.parent.snapshot_datetime is not None: 795 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 796 797 req.filter = plumbing.quote_filter_args(filter, *args) 798 799 def generator(svc, req): 800 tries = 0 801 while True: 802 t = None if deadline is None else deadline - time.time() 803 try: 804 plumbing_response = svc.stub.List( 805 req, 806 metadata=svc.parent.get_metadata( 807 'AccountGrantsHistory.List', req), 808 timeout=t) 809 except Exception as e: 810 if self.parent.shouldRetry(tries, e, deadline): 811 tries += 1 812 time.sleep( 813 self.parent.exponentialBackoff(tries, deadline)) 814 continue 815 raise plumbing.convert_error_to_porcelain(e) from e 816 tries = 0 817 for plumbing_item in plumbing_response.history: 818 yield plumbing.convert_account_grant_history_to_porcelain( 819 plumbing_item) 820 if plumbing_response.meta.next_cursor == '': 821 break 822 req.meta.cursor = plumbing_response.meta.next_cursor 823 824 return generator(self, req) 825 826 827class AccountPermissions: 828 ''' 829 AccountPermissions records the granular permissions accounts have, allowing them to execute 830 relevant commands via StrongDM's APIs. 831 See `strongdm.models.AccountPermission`. 832 ''' 833 def __init__(self, channel, client): 834 self.parent = client 835 self.stub = AccountPermissionsStub(channel) 836 837 def list(self, filter, *args, timeout=None): 838 ''' 839 List gets a list of Permission records matching a given set of criteria. 840 ''' 841 deadline = None if timeout is None else time.time() + timeout 842 req = AccountPermissionListRequest() 843 req.meta.CopyFrom(ListRequestMetadata()) 844 if self.parent.page_limit > 0: 845 req.meta.limit = self.parent.page_limit 846 if self.parent.snapshot_datetime is not None: 847 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 848 849 req.filter = plumbing.quote_filter_args(filter, *args) 850 851 def generator(svc, req): 852 tries = 0 853 while True: 854 t = None if deadline is None else deadline - time.time() 855 try: 856 plumbing_response = svc.stub.List( 857 req, 858 metadata=svc.parent.get_metadata( 859 'AccountPermissions.List', req), 860 timeout=t) 861 except Exception as e: 862 if self.parent.shouldRetry(tries, e, deadline): 863 tries += 1 864 time.sleep( 865 self.parent.exponentialBackoff(tries, deadline)) 866 continue 867 raise plumbing.convert_error_to_porcelain(e) from e 868 tries = 0 869 for plumbing_item in plumbing_response.permissions: 870 yield plumbing.convert_account_permission_to_porcelain( 871 plumbing_item) 872 if plumbing_response.meta.next_cursor == '': 873 break 874 req.meta.cursor = plumbing_response.meta.next_cursor 875 876 return generator(self, req) 877 878 879class SnapshotAccountPermissions: 880 ''' 881 SnapshotAccountPermissions exposes the read only methods of the AccountPermissions 882 service for historical queries. 883 ''' 884 def __init__(self, account_permissions): 885 self.account_permissions = account_permissions 886 887 def list(self, filter, *args, timeout=None): 888 ''' 889 List gets a list of Permission records matching a given set of criteria. 890 ''' 891 return self.account_permissions.list(filter, *args, timeout=timeout) 892 893 894class AccountResources: 895 ''' 896 AccountResources enumerates the resources to which accounts have access. 897 The AccountResources service is read-only. 898 See `strongdm.models.AccountResource`. 899 ''' 900 def __init__(self, channel, client): 901 self.parent = client 902 self.stub = AccountResourcesStub(channel) 903 904 def list(self, filter, *args, timeout=None): 905 ''' 906 List gets a list of AccountResource records matching a given set of criteria. 907 ''' 908 deadline = None if timeout is None else time.time() + timeout 909 req = AccountResourceListRequest() 910 req.meta.CopyFrom(ListRequestMetadata()) 911 if self.parent.page_limit > 0: 912 req.meta.limit = self.parent.page_limit 913 if self.parent.snapshot_datetime is not None: 914 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 915 916 req.filter = plumbing.quote_filter_args(filter, *args) 917 918 def generator(svc, req): 919 tries = 0 920 while True: 921 t = None if deadline is None else deadline - time.time() 922 try: 923 plumbing_response = svc.stub.List( 924 req, 925 metadata=svc.parent.get_metadata( 926 'AccountResources.List', req), 927 timeout=t) 928 except Exception as e: 929 if self.parent.shouldRetry(tries, e, deadline): 930 tries += 1 931 time.sleep( 932 self.parent.exponentialBackoff(tries, deadline)) 933 continue 934 raise plumbing.convert_error_to_porcelain(e) from e 935 tries = 0 936 for plumbing_item in plumbing_response.account_resources: 937 yield plumbing.convert_account_resource_to_porcelain( 938 plumbing_item) 939 if plumbing_response.meta.next_cursor == '': 940 break 941 req.meta.cursor = plumbing_response.meta.next_cursor 942 943 return generator(self, req) 944 945 946class SnapshotAccountResources: 947 ''' 948 SnapshotAccountResources exposes the read only methods of the AccountResources 949 service for historical queries. 950 ''' 951 def __init__(self, account_resources): 952 self.account_resources = account_resources 953 954 def list(self, filter, *args, timeout=None): 955 ''' 956 List gets a list of AccountResource records matching a given set of criteria. 957 ''' 958 return self.account_resources.list(filter, *args, timeout=timeout) 959 960 961class AccountResourcesHistory: 962 ''' 963 AccountResourcesHistory records all changes to the state of a AccountResource. 964 See `strongdm.models.AccountResourceHistory`. 965 ''' 966 def __init__(self, channel, client): 967 self.parent = client 968 self.stub = AccountResourcesHistoryStub(channel) 969 970 def list(self, filter, *args, timeout=None): 971 ''' 972 List gets a list of AccountResourceHistory records matching a given set of criteria. 973 ''' 974 deadline = None if timeout is None else time.time() + timeout 975 req = AccountResourceHistoryListRequest() 976 req.meta.CopyFrom(ListRequestMetadata()) 977 if self.parent.page_limit > 0: 978 req.meta.limit = self.parent.page_limit 979 if self.parent.snapshot_datetime is not None: 980 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 981 982 req.filter = plumbing.quote_filter_args(filter, *args) 983 984 def generator(svc, req): 985 tries = 0 986 while True: 987 t = None if deadline is None else deadline - time.time() 988 try: 989 plumbing_response = svc.stub.List( 990 req, 991 metadata=svc.parent.get_metadata( 992 'AccountResourcesHistory.List', req), 993 timeout=t) 994 except Exception as e: 995 if self.parent.shouldRetry(tries, e, deadline): 996 tries += 1 997 time.sleep( 998 self.parent.exponentialBackoff(tries, deadline)) 999 continue 1000 raise plumbing.convert_error_to_porcelain(e) from e 1001 tries = 0 1002 for plumbing_item in plumbing_response.history: 1003 yield plumbing.convert_account_resource_history_to_porcelain( 1004 plumbing_item) 1005 if plumbing_response.meta.next_cursor == '': 1006 break 1007 req.meta.cursor = plumbing_response.meta.next_cursor 1008 1009 return generator(self, req) 1010 1011 1012class Accounts: 1013 ''' 1014 Accounts are users that have access to strongDM. There are two types of accounts: 1015 1. **Users:** humans who are authenticated through username and password or SSO. 1016 2. **Service Accounts:** machines that are authenticated using a service token. 1017 3. **Tokens** are access keys with permissions that can be used for authentication. 1018 See: 1019 `strongdm.models.Service` 1020 `strongdm.models.Token` 1021 `strongdm.models.User` 1022 ''' 1023 def __init__(self, channel, client): 1024 self.parent = client 1025 self.stub = AccountsStub(channel) 1026 1027 def create(self, account, timeout=None): 1028 ''' 1029 Create registers a new Account. 1030 ''' 1031 deadline = None if timeout is None else time.time() + timeout 1032 req = AccountCreateRequest() 1033 1034 if account is not None: 1035 req.account.CopyFrom(plumbing.convert_account_to_plumbing(account)) 1036 tries = 0 1037 plumbing_response = None 1038 while True: 1039 t = None if deadline is None else deadline - time.time() 1040 try: 1041 plumbing_response = self.stub.Create( 1042 req, 1043 metadata=self.parent.get_metadata('Accounts.Create', req), 1044 timeout=t) 1045 except Exception as e: 1046 if self.parent.shouldRetry(tries, e, deadline): 1047 tries += 1 1048 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1049 continue 1050 raise plumbing.convert_error_to_porcelain(e) from e 1051 break 1052 1053 resp = models.AccountCreateResponse() 1054 resp.access_key = (plumbing_response.access_key) 1055 resp.account = plumbing.convert_account_to_porcelain( 1056 plumbing_response.account) 1057 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 1058 plumbing_response.meta) 1059 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1060 plumbing_response.rate_limit) 1061 resp.secret_key = (plumbing_response.secret_key) 1062 resp.token = (plumbing_response.token) 1063 return resp 1064 1065 def get(self, id, timeout=None): 1066 ''' 1067 Get reads one Account by ID. 1068 ''' 1069 deadline = None if timeout is None else time.time() + timeout 1070 req = AccountGetRequest() 1071 if self.parent.snapshot_datetime is not None: 1072 req.meta.CopyFrom(GetRequestMetadata()) 1073 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1074 1075 req.id = (id) 1076 tries = 0 1077 plumbing_response = None 1078 while True: 1079 t = None if deadline is None else deadline - time.time() 1080 try: 1081 plumbing_response = self.stub.Get( 1082 req, 1083 metadata=self.parent.get_metadata('Accounts.Get', req), 1084 timeout=t) 1085 except Exception as e: 1086 if self.parent.shouldRetry(tries, e, deadline): 1087 tries += 1 1088 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1089 continue 1090 raise plumbing.convert_error_to_porcelain(e) from e 1091 break 1092 1093 resp = models.AccountGetResponse() 1094 resp.account = plumbing.convert_account_to_porcelain( 1095 plumbing_response.account) 1096 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1097 plumbing_response.meta) 1098 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1099 plumbing_response.rate_limit) 1100 return resp 1101 1102 def update(self, account, timeout=None): 1103 ''' 1104 Update replaces all the fields of an Account by ID. 1105 ''' 1106 deadline = None if timeout is None else time.time() + timeout 1107 req = AccountUpdateRequest() 1108 1109 if account is not None: 1110 req.account.CopyFrom(plumbing.convert_account_to_plumbing(account)) 1111 tries = 0 1112 plumbing_response = None 1113 while True: 1114 t = None if deadline is None else deadline - time.time() 1115 try: 1116 plumbing_response = self.stub.Update( 1117 req, 1118 metadata=self.parent.get_metadata('Accounts.Update', req), 1119 timeout=t) 1120 except Exception as e: 1121 if self.parent.shouldRetry(tries, e, deadline): 1122 tries += 1 1123 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1124 continue 1125 raise plumbing.convert_error_to_porcelain(e) from e 1126 break 1127 1128 resp = models.AccountUpdateResponse() 1129 resp.account = plumbing.convert_account_to_porcelain( 1130 plumbing_response.account) 1131 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 1132 plumbing_response.meta) 1133 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1134 plumbing_response.rate_limit) 1135 return resp 1136 1137 def delete(self, id, timeout=None): 1138 ''' 1139 Delete removes an Account by ID. 1140 ''' 1141 deadline = None if timeout is None else time.time() + timeout 1142 req = AccountDeleteRequest() 1143 1144 req.id = (id) 1145 tries = 0 1146 plumbing_response = None 1147 while True: 1148 t = None if deadline is None else deadline - time.time() 1149 try: 1150 plumbing_response = self.stub.Delete( 1151 req, 1152 metadata=self.parent.get_metadata('Accounts.Delete', req), 1153 timeout=t) 1154 except Exception as e: 1155 if self.parent.shouldRetry(tries, e, deadline): 1156 tries += 1 1157 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1158 continue 1159 raise plumbing.convert_error_to_porcelain(e) from e 1160 break 1161 1162 resp = models.AccountDeleteResponse() 1163 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 1164 plumbing_response.meta) 1165 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1166 plumbing_response.rate_limit) 1167 return resp 1168 1169 def list(self, filter, *args, timeout=None): 1170 ''' 1171 List gets a list of Accounts matching a given set of criteria. 1172 ''' 1173 deadline = None if timeout is None else time.time() + timeout 1174 req = AccountListRequest() 1175 req.meta.CopyFrom(ListRequestMetadata()) 1176 if self.parent.page_limit > 0: 1177 req.meta.limit = self.parent.page_limit 1178 if self.parent.snapshot_datetime is not None: 1179 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1180 1181 req.filter = plumbing.quote_filter_args(filter, *args) 1182 1183 def generator(svc, req): 1184 tries = 0 1185 while True: 1186 t = None if deadline is None else deadline - time.time() 1187 try: 1188 plumbing_response = svc.stub.List( 1189 req, 1190 metadata=svc.parent.get_metadata('Accounts.List', req), 1191 timeout=t) 1192 except Exception as e: 1193 if self.parent.shouldRetry(tries, e, deadline): 1194 tries += 1 1195 time.sleep( 1196 self.parent.exponentialBackoff(tries, deadline)) 1197 continue 1198 raise plumbing.convert_error_to_porcelain(e) from e 1199 tries = 0 1200 for plumbing_item in plumbing_response.accounts: 1201 yield plumbing.convert_account_to_porcelain(plumbing_item) 1202 if plumbing_response.meta.next_cursor == '': 1203 break 1204 req.meta.cursor = plumbing_response.meta.next_cursor 1205 1206 return generator(self, req) 1207 1208 1209class SnapshotAccounts: 1210 ''' 1211 SnapshotAccounts exposes the read only methods of the Accounts 1212 service for historical queries. 1213 ''' 1214 def __init__(self, accounts): 1215 self.accounts = accounts 1216 1217 def get(self, id, timeout=None): 1218 ''' 1219 Get reads one Account by ID. 1220 ''' 1221 return self.accounts.get(id, timeout=timeout) 1222 1223 def list(self, filter, *args, timeout=None): 1224 ''' 1225 List gets a list of Accounts matching a given set of criteria. 1226 ''' 1227 return self.accounts.list(filter, *args, timeout=timeout) 1228 1229 1230class AccountsGroups: 1231 ''' 1232 An AccountGroup links an account and a group. 1233 See `strongdm.models.AccountGroup`. 1234 ''' 1235 def __init__(self, channel, client): 1236 self.parent = client 1237 self.stub = AccountsGroupsStub(channel) 1238 1239 def create(self, account_group, timeout=None): 1240 ''' 1241 Create create a new AccountGroup. 1242 ''' 1243 deadline = None if timeout is None else time.time() + timeout 1244 req = AccountGroupCreateRequest() 1245 1246 if account_group is not None: 1247 req.account_group.CopyFrom( 1248 plumbing.convert_account_group_to_plumbing(account_group)) 1249 tries = 0 1250 plumbing_response = None 1251 while True: 1252 t = None if deadline is None else deadline - time.time() 1253 try: 1254 plumbing_response = self.stub.Create( 1255 req, 1256 metadata=self.parent.get_metadata('AccountsGroups.Create', 1257 req), 1258 timeout=t) 1259 except Exception as e: 1260 if self.parent.shouldRetry(tries, e, deadline): 1261 tries += 1 1262 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1263 continue 1264 raise plumbing.convert_error_to_porcelain(e) from e 1265 break 1266 1267 resp = models.AccountGroupCreateResponse() 1268 resp.account_group = plumbing.convert_account_group_to_porcelain( 1269 plumbing_response.account_group) 1270 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1271 plumbing_response.rate_limit) 1272 return resp 1273 1274 def get(self, id, timeout=None): 1275 ''' 1276 Get reads one AccountGroup by ID. 1277 ''' 1278 deadline = None if timeout is None else time.time() + timeout 1279 req = AccountGroupGetRequest() 1280 if self.parent.snapshot_datetime is not None: 1281 req.meta.CopyFrom(GetRequestMetadata()) 1282 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1283 1284 req.id = (id) 1285 tries = 0 1286 plumbing_response = None 1287 while True: 1288 t = None if deadline is None else deadline - time.time() 1289 try: 1290 plumbing_response = self.stub.Get( 1291 req, 1292 metadata=self.parent.get_metadata('AccountsGroups.Get', 1293 req), 1294 timeout=t) 1295 except Exception as e: 1296 if self.parent.shouldRetry(tries, e, deadline): 1297 tries += 1 1298 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1299 continue 1300 raise plumbing.convert_error_to_porcelain(e) from e 1301 break 1302 1303 resp = models.AccountGroupGetResponse() 1304 resp.account_group = plumbing.convert_account_group_to_porcelain( 1305 plumbing_response.account_group) 1306 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1307 plumbing_response.meta) 1308 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1309 plumbing_response.rate_limit) 1310 return resp 1311 1312 def delete(self, id, timeout=None): 1313 ''' 1314 Delete removes an AccountGroup by ID. 1315 ''' 1316 deadline = None if timeout is None else time.time() + timeout 1317 req = AccountGroupDeleteRequest() 1318 1319 req.id = (id) 1320 tries = 0 1321 plumbing_response = None 1322 while True: 1323 t = None if deadline is None else deadline - time.time() 1324 try: 1325 plumbing_response = self.stub.Delete( 1326 req, 1327 metadata=self.parent.get_metadata('AccountsGroups.Delete', 1328 req), 1329 timeout=t) 1330 except Exception as e: 1331 if self.parent.shouldRetry(tries, e, deadline): 1332 tries += 1 1333 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1334 continue 1335 raise plumbing.convert_error_to_porcelain(e) from e 1336 break 1337 1338 resp = models.AccountGroupDeleteResponse() 1339 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 1340 plumbing_response.meta) 1341 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1342 plumbing_response.rate_limit) 1343 return resp 1344 1345 def list(self, filter, *args, timeout=None): 1346 ''' 1347 List gets a list of AccountGroups matching a given set of criteria. 1348 ''' 1349 deadline = None if timeout is None else time.time() + timeout 1350 req = AccountGroupListRequest() 1351 req.meta.CopyFrom(ListRequestMetadata()) 1352 if self.parent.page_limit > 0: 1353 req.meta.limit = self.parent.page_limit 1354 if self.parent.snapshot_datetime is not None: 1355 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1356 1357 req.filter = plumbing.quote_filter_args(filter, *args) 1358 1359 def generator(svc, req): 1360 tries = 0 1361 while True: 1362 t = None if deadline is None else deadline - time.time() 1363 try: 1364 plumbing_response = svc.stub.List( 1365 req, 1366 metadata=svc.parent.get_metadata( 1367 'AccountsGroups.List', req), 1368 timeout=t) 1369 except Exception as e: 1370 if self.parent.shouldRetry(tries, e, deadline): 1371 tries += 1 1372 time.sleep( 1373 self.parent.exponentialBackoff(tries, deadline)) 1374 continue 1375 raise plumbing.convert_error_to_porcelain(e) from e 1376 tries = 0 1377 for plumbing_item in plumbing_response.account_groups: 1378 yield plumbing.convert_account_group_to_porcelain( 1379 plumbing_item) 1380 if plumbing_response.meta.next_cursor == '': 1381 break 1382 req.meta.cursor = plumbing_response.meta.next_cursor 1383 1384 return generator(self, req) 1385 1386 1387class SnapshotAccountsGroups: 1388 ''' 1389 SnapshotAccountsGroups exposes the read only methods of the AccountsGroups 1390 service for historical queries. 1391 ''' 1392 def __init__(self, accounts_groups): 1393 self.accounts_groups = accounts_groups 1394 1395 def get(self, id, timeout=None): 1396 ''' 1397 Get reads one AccountGroup by ID. 1398 ''' 1399 return self.accounts_groups.get(id, timeout=timeout) 1400 1401 def list(self, filter, *args, timeout=None): 1402 ''' 1403 List gets a list of AccountGroups matching a given set of criteria. 1404 ''' 1405 return self.accounts_groups.list(filter, *args, timeout=timeout) 1406 1407 1408class AccountsGroupsHistory: 1409 ''' 1410 AccountsGroupsHistory records all changes to the state of an AccountGroup. 1411 See `strongdm.models.AccountGroupHistory`. 1412 ''' 1413 def __init__(self, channel, client): 1414 self.parent = client 1415 self.stub = AccountsGroupsHistoryStub(channel) 1416 1417 def list(self, filter, *args, timeout=None): 1418 ''' 1419 List gets a list of AccountGroupHistory records matching a given set of criteria. 1420 ''' 1421 deadline = None if timeout is None else time.time() + timeout 1422 req = AccountGroupHistoryListRequest() 1423 req.meta.CopyFrom(ListRequestMetadata()) 1424 if self.parent.page_limit > 0: 1425 req.meta.limit = self.parent.page_limit 1426 if self.parent.snapshot_datetime is not None: 1427 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1428 1429 req.filter = plumbing.quote_filter_args(filter, *args) 1430 1431 def generator(svc, req): 1432 tries = 0 1433 while True: 1434 t = None if deadline is None else deadline - time.time() 1435 try: 1436 plumbing_response = svc.stub.List( 1437 req, 1438 metadata=svc.parent.get_metadata( 1439 'AccountsGroupsHistory.List', req), 1440 timeout=t) 1441 except Exception as e: 1442 if self.parent.shouldRetry(tries, e, deadline): 1443 tries += 1 1444 time.sleep( 1445 self.parent.exponentialBackoff(tries, deadline)) 1446 continue 1447 raise plumbing.convert_error_to_porcelain(e) from e 1448 tries = 0 1449 for plumbing_item in plumbing_response.history: 1450 yield plumbing.convert_account_group_history_to_porcelain( 1451 plumbing_item) 1452 if plumbing_response.meta.next_cursor == '': 1453 break 1454 req.meta.cursor = plumbing_response.meta.next_cursor 1455 1456 return generator(self, req) 1457 1458 1459class AccountsHistory: 1460 ''' 1461 AccountsHistory records all changes to the state of an Account. 1462 See `strongdm.models.AccountHistory`. 1463 ''' 1464 def __init__(self, channel, client): 1465 self.parent = client 1466 self.stub = AccountsHistoryStub(channel) 1467 1468 def list(self, filter, *args, timeout=None): 1469 ''' 1470 List gets a list of AccountHistory records matching a given set of criteria. 1471 ''' 1472 deadline = None if timeout is None else time.time() + timeout 1473 req = AccountHistoryListRequest() 1474 req.meta.CopyFrom(ListRequestMetadata()) 1475 if self.parent.page_limit > 0: 1476 req.meta.limit = self.parent.page_limit 1477 if self.parent.snapshot_datetime is not None: 1478 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1479 1480 req.filter = plumbing.quote_filter_args(filter, *args) 1481 1482 def generator(svc, req): 1483 tries = 0 1484 while True: 1485 t = None if deadline is None else deadline - time.time() 1486 try: 1487 plumbing_response = svc.stub.List( 1488 req, 1489 metadata=svc.parent.get_metadata( 1490 'AccountsHistory.List', req), 1491 timeout=t) 1492 except Exception as e: 1493 if self.parent.shouldRetry(tries, e, deadline): 1494 tries += 1 1495 time.sleep( 1496 self.parent.exponentialBackoff(tries, deadline)) 1497 continue 1498 raise plumbing.convert_error_to_porcelain(e) from e 1499 tries = 0 1500 for plumbing_item in plumbing_response.history: 1501 yield plumbing.convert_account_history_to_porcelain( 1502 plumbing_item) 1503 if plumbing_response.meta.next_cursor == '': 1504 break 1505 req.meta.cursor = plumbing_response.meta.next_cursor 1506 1507 return generator(self, req) 1508 1509 1510class Activities: 1511 ''' 1512 An Activity is a record of an action taken against a strongDM deployment, e.g. 1513 a user creation, resource deletion, sso configuration change, etc. The Activities 1514 service is read-only. 1515 See `strongdm.models.Activity`. 1516 ''' 1517 def __init__(self, channel, client): 1518 self.parent = client 1519 self.stub = ActivitiesStub(channel) 1520 1521 def get(self, id, timeout=None): 1522 ''' 1523 Get reads one Activity by ID. 1524 ''' 1525 deadline = None if timeout is None else time.time() + timeout 1526 req = ActivityGetRequest() 1527 if self.parent.snapshot_datetime is not None: 1528 req.meta.CopyFrom(GetRequestMetadata()) 1529 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1530 1531 req.id = (id) 1532 tries = 0 1533 plumbing_response = None 1534 while True: 1535 t = None if deadline is None else deadline - time.time() 1536 try: 1537 plumbing_response = self.stub.Get( 1538 req, 1539 metadata=self.parent.get_metadata('Activities.Get', req), 1540 timeout=t) 1541 except Exception as e: 1542 if self.parent.shouldRetry(tries, e, deadline): 1543 tries += 1 1544 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1545 continue 1546 raise plumbing.convert_error_to_porcelain(e) from e 1547 break 1548 1549 resp = models.ActivityGetResponse() 1550 resp.activity = plumbing.convert_activity_to_porcelain( 1551 plumbing_response.activity) 1552 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1553 plumbing_response.meta) 1554 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1555 plumbing_response.rate_limit) 1556 return resp 1557 1558 def list(self, filter, *args, timeout=None): 1559 ''' 1560 List gets a list of Activities matching a given set of criteria. 1561 The 'before' and 'after' filters can be used to control the time 1562 range of the output activities. If not provided, one week of back 1563 of activities will be returned. 1564 ''' 1565 deadline = None if timeout is None else time.time() + timeout 1566 req = ActivityListRequest() 1567 req.meta.CopyFrom(ListRequestMetadata()) 1568 if self.parent.page_limit > 0: 1569 req.meta.limit = self.parent.page_limit 1570 if self.parent.snapshot_datetime is not None: 1571 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1572 1573 req.filter = plumbing.quote_filter_args(filter, *args) 1574 1575 def generator(svc, req): 1576 tries = 0 1577 while True: 1578 t = None if deadline is None else deadline - time.time() 1579 try: 1580 plumbing_response = svc.stub.List( 1581 req, 1582 metadata=svc.parent.get_metadata( 1583 'Activities.List', req), 1584 timeout=t) 1585 except Exception as e: 1586 if self.parent.shouldRetry(tries, e, deadline): 1587 tries += 1 1588 time.sleep( 1589 self.parent.exponentialBackoff(tries, deadline)) 1590 continue 1591 raise plumbing.convert_error_to_porcelain(e) from e 1592 tries = 0 1593 for plumbing_item in plumbing_response.activities: 1594 yield plumbing.convert_activity_to_porcelain(plumbing_item) 1595 if plumbing_response.meta.next_cursor == '': 1596 break 1597 req.meta.cursor = plumbing_response.meta.next_cursor 1598 1599 return generator(self, req) 1600 1601 1602class ApprovalWorkflowApprovers: 1603 ''' 1604 ApprovalWorkflowApprovers link approval workflow approvers to an ApprovalWorkflowStep 1605 See `strongdm.models.ApprovalWorkflowApprover`. 1606 ''' 1607 def __init__(self, channel, client): 1608 self.parent = client 1609 self.stub = ApprovalWorkflowApproversStub(channel) 1610 1611 def create(self, approval_workflow_approver, timeout=None): 1612 ''' 1613 Deprecated: Create creates a new approval workflow approver. 1614 ''' 1615 deadline = None if timeout is None else time.time() + timeout 1616 req = ApprovalWorkflowApproverCreateRequest() 1617 1618 if approval_workflow_approver is not None: 1619 req.approval_workflow_approver.CopyFrom( 1620 plumbing.convert_approval_workflow_approver_to_plumbing( 1621 approval_workflow_approver)) 1622 tries = 0 1623 plumbing_response = None 1624 while True: 1625 t = None if deadline is None else deadline - time.time() 1626 try: 1627 plumbing_response = self.stub.Create( 1628 req, 1629 metadata=self.parent.get_metadata( 1630 'ApprovalWorkflowApprovers.Create', req), 1631 timeout=t) 1632 except Exception as e: 1633 if self.parent.shouldRetry(tries, e, deadline): 1634 tries += 1 1635 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1636 continue 1637 raise plumbing.convert_error_to_porcelain(e) from e 1638 break 1639 1640 resp = models.ApprovalWorkflowApproverCreateResponse() 1641 resp.approval_workflow_approver = plumbing.convert_approval_workflow_approver_to_porcelain( 1642 plumbing_response.approval_workflow_approver) 1643 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1644 plumbing_response.rate_limit) 1645 return resp 1646 1647 def get(self, id, timeout=None): 1648 ''' 1649 Deprecated: Get reads one approval workflow approver by ID. 1650 ''' 1651 deadline = None if timeout is None else time.time() + timeout 1652 req = ApprovalWorkflowApproverGetRequest() 1653 if self.parent.snapshot_datetime is not None: 1654 req.meta.CopyFrom(GetRequestMetadata()) 1655 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1656 1657 req.id = (id) 1658 tries = 0 1659 plumbing_response = None 1660 while True: 1661 t = None if deadline is None else deadline - time.time() 1662 try: 1663 plumbing_response = self.stub.Get( 1664 req, 1665 metadata=self.parent.get_metadata( 1666 'ApprovalWorkflowApprovers.Get', req), 1667 timeout=t) 1668 except Exception as e: 1669 if self.parent.shouldRetry(tries, e, deadline): 1670 tries += 1 1671 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1672 continue 1673 raise plumbing.convert_error_to_porcelain(e) from e 1674 break 1675 1676 resp = models.ApprovalWorkflowApproverGetResponse() 1677 resp.approval_workflow_approver = plumbing.convert_approval_workflow_approver_to_porcelain( 1678 plumbing_response.approval_workflow_approver) 1679 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1680 plumbing_response.meta) 1681 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1682 plumbing_response.rate_limit) 1683 return resp 1684 1685 def delete(self, id, timeout=None): 1686 ''' 1687 Deprecated: Delete deletes an existing approval workflow approver. 1688 ''' 1689 deadline = None if timeout is None else time.time() + timeout 1690 req = ApprovalWorkflowApproverDeleteRequest() 1691 1692 req.id = (id) 1693 tries = 0 1694 plumbing_response = None 1695 while True: 1696 t = None if deadline is None else deadline - time.time() 1697 try: 1698 plumbing_response = self.stub.Delete( 1699 req, 1700 metadata=self.parent.get_metadata( 1701 'ApprovalWorkflowApprovers.Delete', req), 1702 timeout=t) 1703 except Exception as e: 1704 if self.parent.shouldRetry(tries, e, deadline): 1705 tries += 1 1706 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1707 continue 1708 raise plumbing.convert_error_to_porcelain(e) from e 1709 break 1710 1711 resp = models.ApprovalWorkflowApproverDeleteResponse() 1712 resp.id = (plumbing_response.id) 1713 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1714 plumbing_response.rate_limit) 1715 return resp 1716 1717 def list(self, filter, *args, timeout=None): 1718 ''' 1719 Deprecated: Lists existing approval workflow approvers. 1720 ''' 1721 deadline = None if timeout is None else time.time() + timeout 1722 req = ApprovalWorkflowApproverListRequest() 1723 req.meta.CopyFrom(ListRequestMetadata()) 1724 if self.parent.page_limit > 0: 1725 req.meta.limit = self.parent.page_limit 1726 if self.parent.snapshot_datetime is not None: 1727 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1728 1729 req.filter = plumbing.quote_filter_args(filter, *args) 1730 1731 def generator(svc, req): 1732 tries = 0 1733 while True: 1734 t = None if deadline is None else deadline - time.time() 1735 try: 1736 plumbing_response = svc.stub.List( 1737 req, 1738 metadata=svc.parent.get_metadata( 1739 'ApprovalWorkflowApprovers.List', req), 1740 timeout=t) 1741 except Exception as e: 1742 if self.parent.shouldRetry(tries, e, deadline): 1743 tries += 1 1744 time.sleep( 1745 self.parent.exponentialBackoff(tries, deadline)) 1746 continue 1747 raise plumbing.convert_error_to_porcelain(e) from e 1748 tries = 0 1749 for plumbing_item in plumbing_response.approval_workflow_approvers: 1750 yield plumbing.convert_approval_workflow_approver_to_porcelain( 1751 plumbing_item) 1752 if plumbing_response.meta.next_cursor == '': 1753 break 1754 req.meta.cursor = plumbing_response.meta.next_cursor 1755 1756 return generator(self, req) 1757 1758 1759class SnapshotApprovalWorkflowApprovers: 1760 ''' 1761 SnapshotApprovalWorkflowApprovers exposes the read only methods of the ApprovalWorkflowApprovers 1762 service for historical queries. 1763 ''' 1764 def __init__(self, approval_workflow_approvers): 1765 self.approval_workflow_approvers = approval_workflow_approvers 1766 1767 def get(self, id, timeout=None): 1768 ''' 1769 Deprecated: Get reads one approval workflow approver by ID. 1770 ''' 1771 return self.approval_workflow_approvers.get(id, timeout=timeout) 1772 1773 def list(self, filter, *args, timeout=None): 1774 ''' 1775 Deprecated: Lists existing approval workflow approvers. 1776 ''' 1777 return self.approval_workflow_approvers.list(filter, 1778 *args, 1779 timeout=timeout) 1780 1781 1782class ApprovalWorkflowApproversHistory: 1783 ''' 1784 ApprovalWorkflowApproversHistory records all changes to the state of an ApprovalWorkflowApprover. 1785 See `strongdm.models.ApprovalWorkflowApproverHistory`. 1786 ''' 1787 def __init__(self, channel, client): 1788 self.parent = client 1789 self.stub = ApprovalWorkflowApproversHistoryStub(channel) 1790 1791 def list(self, filter, *args, timeout=None): 1792 ''' 1793 List gets a list of ApprovalWorkflowApproverHistory records matching a given set of criteria. 1794 ''' 1795 deadline = None if timeout is None else time.time() + timeout 1796 req = ApprovalWorkflowApproverHistoryListRequest() 1797 req.meta.CopyFrom(ListRequestMetadata()) 1798 if self.parent.page_limit > 0: 1799 req.meta.limit = self.parent.page_limit 1800 if self.parent.snapshot_datetime is not None: 1801 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1802 1803 req.filter = plumbing.quote_filter_args(filter, *args) 1804 1805 def generator(svc, req): 1806 tries = 0 1807 while True: 1808 t = None if deadline is None else deadline - time.time() 1809 try: 1810 plumbing_response = svc.stub.List( 1811 req, 1812 metadata=svc.parent.get_metadata( 1813 'ApprovalWorkflowApproversHistory.List', req), 1814 timeout=t) 1815 except Exception as e: 1816 if self.parent.shouldRetry(tries, e, deadline): 1817 tries += 1 1818 time.sleep( 1819 self.parent.exponentialBackoff(tries, deadline)) 1820 continue 1821 raise plumbing.convert_error_to_porcelain(e) from e 1822 tries = 0 1823 for plumbing_item in plumbing_response.history: 1824 yield plumbing.convert_approval_workflow_approver_history_to_porcelain( 1825 plumbing_item) 1826 if plumbing_response.meta.next_cursor == '': 1827 break 1828 req.meta.cursor = plumbing_response.meta.next_cursor 1829 1830 return generator(self, req) 1831 1832 1833class ApprovalWorkflowSteps: 1834 ''' 1835 ApprovalWorkflowSteps link approval workflow steps to an ApprovalWorkflow 1836 See `strongdm.models.ApprovalWorkflowStep`. 1837 ''' 1838 def __init__(self, channel, client): 1839 self.parent = client 1840 self.stub = ApprovalWorkflowStepsStub(channel) 1841 1842 def create(self, approval_workflow_step, timeout=None): 1843 ''' 1844 Deprecated: Create creates a new approval workflow step. 1845 ''' 1846 deadline = None if timeout is None else time.time() + timeout 1847 req = ApprovalWorkflowStepCreateRequest() 1848 1849 if approval_workflow_step is not None: 1850 req.approval_workflow_step.CopyFrom( 1851 plumbing.convert_approval_workflow_step_to_plumbing( 1852 approval_workflow_step)) 1853 tries = 0 1854 plumbing_response = None 1855 while True: 1856 t = None if deadline is None else deadline - time.time() 1857 try: 1858 plumbing_response = self.stub.Create( 1859 req, 1860 metadata=self.parent.get_metadata( 1861 'ApprovalWorkflowSteps.Create', req), 1862 timeout=t) 1863 except Exception as e: 1864 if self.parent.shouldRetry(tries, e, deadline): 1865 tries += 1 1866 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1867 continue 1868 raise plumbing.convert_error_to_porcelain(e) from e 1869 break 1870 1871 resp = models.ApprovalWorkflowStepCreateResponse() 1872 resp.approval_workflow_step = plumbing.convert_approval_workflow_step_to_porcelain( 1873 plumbing_response.approval_workflow_step) 1874 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1875 plumbing_response.rate_limit) 1876 return resp 1877 1878 def get(self, id, timeout=None): 1879 ''' 1880 Deprecated: Get reads one approval workflow step by ID. 1881 ''' 1882 deadline = None if timeout is None else time.time() + timeout 1883 req = ApprovalWorkflowStepGetRequest() 1884 if self.parent.snapshot_datetime is not None: 1885 req.meta.CopyFrom(GetRequestMetadata()) 1886 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1887 1888 req.id = (id) 1889 tries = 0 1890 plumbing_response = None 1891 while True: 1892 t = None if deadline is None else deadline - time.time() 1893 try: 1894 plumbing_response = self.stub.Get( 1895 req, 1896 metadata=self.parent.get_metadata( 1897 'ApprovalWorkflowSteps.Get', req), 1898 timeout=t) 1899 except Exception as e: 1900 if self.parent.shouldRetry(tries, e, deadline): 1901 tries += 1 1902 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1903 continue 1904 raise plumbing.convert_error_to_porcelain(e) from e 1905 break 1906 1907 resp = models.ApprovalWorkflowStepGetResponse() 1908 resp.approval_workflow_step = plumbing.convert_approval_workflow_step_to_porcelain( 1909 plumbing_response.approval_workflow_step) 1910 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1911 plumbing_response.meta) 1912 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1913 plumbing_response.rate_limit) 1914 return resp 1915 1916 def delete(self, id, timeout=None): 1917 ''' 1918 Deprecated: Delete deletes an existing approval workflow step. 1919 ''' 1920 deadline = None if timeout is None else time.time() + timeout 1921 req = ApprovalWorkflowStepDeleteRequest() 1922 1923 req.id = (id) 1924 tries = 0 1925 plumbing_response = None 1926 while True: 1927 t = None if deadline is None else deadline - time.time() 1928 try: 1929 plumbing_response = self.stub.Delete( 1930 req, 1931 metadata=self.parent.get_metadata( 1932 'ApprovalWorkflowSteps.Delete', req), 1933 timeout=t) 1934 except Exception as e: 1935 if self.parent.shouldRetry(tries, e, deadline): 1936 tries += 1 1937 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1938 continue 1939 raise plumbing.convert_error_to_porcelain(e) from e 1940 break 1941 1942 resp = models.ApprovalWorkflowStepDeleteResponse() 1943 resp.id = (plumbing_response.id) 1944 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1945 plumbing_response.rate_limit) 1946 return resp 1947 1948 def list(self, filter, *args, timeout=None): 1949 ''' 1950 Deprecated: Lists existing approval workflow steps. 1951 ''' 1952 deadline = None if timeout is None else time.time() + timeout 1953 req = ApprovalWorkflowStepListRequest() 1954 req.meta.CopyFrom(ListRequestMetadata()) 1955 if self.parent.page_limit > 0: 1956 req.meta.limit = self.parent.page_limit 1957 if self.parent.snapshot_datetime is not None: 1958 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1959 1960 req.filter = plumbing.quote_filter_args(filter, *args) 1961 1962 def generator(svc, req): 1963 tries = 0 1964 while True: 1965 t = None if deadline is None else deadline - time.time() 1966 try: 1967 plumbing_response = svc.stub.List( 1968 req, 1969 metadata=svc.parent.get_metadata( 1970 'ApprovalWorkflowSteps.List', req), 1971 timeout=t) 1972 except Exception as e: 1973 if self.parent.shouldRetry(tries, e, deadline): 1974 tries += 1 1975 time.sleep( 1976 self.parent.exponentialBackoff(tries, deadline)) 1977 continue 1978 raise plumbing.convert_error_to_porcelain(e) from e 1979 tries = 0 1980 for plumbing_item in plumbing_response.approval_workflow_steps: 1981 yield plumbing.convert_approval_workflow_step_to_porcelain( 1982 plumbing_item) 1983 if plumbing_response.meta.next_cursor == '': 1984 break 1985 req.meta.cursor = plumbing_response.meta.next_cursor 1986 1987 return generator(self, req) 1988 1989 1990class SnapshotApprovalWorkflowSteps: 1991 ''' 1992 SnapshotApprovalWorkflowSteps exposes the read only methods of the ApprovalWorkflowSteps 1993 service for historical queries. 1994 ''' 1995 def __init__(self, approval_workflow_steps): 1996 self.approval_workflow_steps = approval_workflow_steps 1997 1998 def get(self, id, timeout=None): 1999 ''' 2000 Deprecated: Get reads one approval workflow step by ID. 2001 ''' 2002 return self.approval_workflow_steps.get(id, timeout=timeout) 2003 2004 def list(self, filter, *args, timeout=None): 2005 ''' 2006 Deprecated: Lists existing approval workflow steps. 2007 ''' 2008 return self.approval_workflow_steps.list(filter, 2009 *args, 2010 timeout=timeout) 2011 2012 2013class ApprovalWorkflowStepsHistory: 2014 ''' 2015 ApprovalWorkflowStepsHistory records all changes to the state of an ApprovalWorkflowStep. 2016 See `strongdm.models.ApprovalWorkflowStepHistory`. 2017 ''' 2018 def __init__(self, channel, client): 2019 self.parent = client 2020 self.stub = ApprovalWorkflowStepsHistoryStub(channel) 2021 2022 def list(self, filter, *args, timeout=None): 2023 ''' 2024 List gets a list of ApprovalWorkflowStepHistory records matching a given set of criteria. 2025 ''' 2026 deadline = None if timeout is None else time.time() + timeout 2027 req = ApprovalWorkflowStepHistoryListRequest() 2028 req.meta.CopyFrom(ListRequestMetadata()) 2029 if self.parent.page_limit > 0: 2030 req.meta.limit = self.parent.page_limit 2031 if self.parent.snapshot_datetime is not None: 2032 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2033 2034 req.filter = plumbing.quote_filter_args(filter, *args) 2035 2036 def generator(svc, req): 2037 tries = 0 2038 while True: 2039 t = None if deadline is None else deadline - time.time() 2040 try: 2041 plumbing_response = svc.stub.List( 2042 req, 2043 metadata=svc.parent.get_metadata( 2044 'ApprovalWorkflowStepsHistory.List', req), 2045 timeout=t) 2046 except Exception as e: 2047 if self.parent.shouldRetry(tries, e, deadline): 2048 tries += 1 2049 time.sleep( 2050 self.parent.exponentialBackoff(tries, deadline)) 2051 continue 2052 raise plumbing.convert_error_to_porcelain(e) from e 2053 tries = 0 2054 for plumbing_item in plumbing_response.history: 2055 yield plumbing.convert_approval_workflow_step_history_to_porcelain( 2056 plumbing_item) 2057 if plumbing_response.meta.next_cursor == '': 2058 break 2059 req.meta.cursor = plumbing_response.meta.next_cursor 2060 2061 return generator(self, req) 2062 2063 2064class ApprovalWorkflows: 2065 ''' 2066 ApprovalWorkflows are the mechanism by which requests for access can be viewed by authorized 2067 approvers and be approved or denied. 2068 See `strongdm.models.ApprovalWorkflow`. 2069 ''' 2070 def __init__(self, channel, client): 2071 self.parent = client 2072 self.stub = ApprovalWorkflowsStub(channel) 2073 2074 def create(self, approval_workflow, timeout=None): 2075 ''' 2076 Create creates a new approval workflow and requires a name and approval mode for the approval workflow. 2077 ''' 2078 deadline = None if timeout is None else time.time() + timeout 2079 req = ApprovalWorkflowCreateRequest() 2080 2081 if approval_workflow is not None: 2082 req.approval_workflow.CopyFrom( 2083 plumbing.convert_approval_workflow_to_plumbing( 2084 approval_workflow)) 2085 tries = 0 2086 plumbing_response = None 2087 while True: 2088 t = None if deadline is None else deadline - time.time() 2089 try: 2090 plumbing_response = self.stub.Create( 2091 req, 2092 metadata=self.parent.get_metadata( 2093 'ApprovalWorkflows.Create', req), 2094 timeout=t) 2095 except Exception as e: 2096 if self.parent.shouldRetry(tries, e, deadline): 2097 tries += 1 2098 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2099 continue 2100 raise plumbing.convert_error_to_porcelain(e) from e 2101 break 2102 2103 resp = models.ApprovalWorkflowCreateResponse() 2104 resp.approval_workflow = plumbing.convert_approval_workflow_to_porcelain( 2105 plumbing_response.approval_workflow) 2106 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2107 plumbing_response.rate_limit) 2108 return resp 2109 2110 def get(self, id, timeout=None): 2111 ''' 2112 Get reads one approval workflow by ID. 2113 ''' 2114 deadline = None if timeout is None else time.time() + timeout 2115 req = ApprovalWorkflowGetRequest() 2116 if self.parent.snapshot_datetime is not None: 2117 req.meta.CopyFrom(GetRequestMetadata()) 2118 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2119 2120 req.id = (id) 2121 tries = 0 2122 plumbing_response = None 2123 while True: 2124 t = None if deadline is None else deadline - time.time() 2125 try: 2126 plumbing_response = self.stub.Get( 2127 req, 2128 metadata=self.parent.get_metadata('ApprovalWorkflows.Get', 2129 req), 2130 timeout=t) 2131 except Exception as e: 2132 if self.parent.shouldRetry(tries, e, deadline): 2133 tries += 1 2134 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2135 continue 2136 raise plumbing.convert_error_to_porcelain(e) from e 2137 break 2138 2139 resp = models.ApprovalWorkflowGetResponse() 2140 resp.approval_workflow = plumbing.convert_approval_workflow_to_porcelain( 2141 plumbing_response.approval_workflow) 2142 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2143 plumbing_response.meta) 2144 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2145 plumbing_response.rate_limit) 2146 return resp 2147 2148 def delete(self, id, timeout=None): 2149 ''' 2150 Delete deletes an existing approval workflow. 2151 ''' 2152 deadline = None if timeout is None else time.time() + timeout 2153 req = ApprovalWorkflowDeleteRequest() 2154 2155 req.id = (id) 2156 tries = 0 2157 plumbing_response = None 2158 while True: 2159 t = None if deadline is None else deadline - time.time() 2160 try: 2161 plumbing_response = self.stub.Delete( 2162 req, 2163 metadata=self.parent.get_metadata( 2164 'ApprovalWorkflows.Delete', req), 2165 timeout=t) 2166 except Exception as e: 2167 if self.parent.shouldRetry(tries, e, deadline): 2168 tries += 1 2169 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2170 continue 2171 raise plumbing.convert_error_to_porcelain(e) from e 2172 break 2173 2174 resp = models.ApprovalWorkflowDeleteResponse() 2175 resp.id = (plumbing_response.id) 2176 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2177 plumbing_response.rate_limit) 2178 return resp 2179 2180 def update(self, approval_workflow, timeout=None): 2181 ''' 2182 Update updates an existing approval workflow. 2183 ''' 2184 deadline = None if timeout is None else time.time() + timeout 2185 req = ApprovalWorkflowUpdateRequest() 2186 2187 if approval_workflow is not None: 2188 req.approval_workflow.CopyFrom( 2189 plumbing.convert_approval_workflow_to_plumbing( 2190 approval_workflow)) 2191 tries = 0 2192 plumbing_response = None 2193 while True: 2194 t = None if deadline is None else deadline - time.time() 2195 try: 2196 plumbing_response = self.stub.Update( 2197 req, 2198 metadata=self.parent.get_metadata( 2199 'ApprovalWorkflows.Update', req), 2200 timeout=t) 2201 except Exception as e: 2202 if self.parent.shouldRetry(tries, e, deadline): 2203 tries += 1 2204 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2205 continue 2206 raise plumbing.convert_error_to_porcelain(e) from e 2207 break 2208 2209 resp = models.ApprovalWorkflowUpdateResponse() 2210 resp.approval_workflow = plumbing.convert_approval_workflow_to_porcelain( 2211 plumbing_response.approval_workflow) 2212 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2213 plumbing_response.rate_limit) 2214 return resp 2215 2216 def list(self, filter, *args, timeout=None): 2217 ''' 2218 Lists existing approval workflows. 2219 ''' 2220 deadline = None if timeout is None else time.time() + timeout 2221 req = ApprovalWorkflowListRequest() 2222 req.meta.CopyFrom(ListRequestMetadata()) 2223 if self.parent.page_limit > 0: 2224 req.meta.limit = self.parent.page_limit 2225 if self.parent.snapshot_datetime is not None: 2226 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2227 2228 req.filter = plumbing.quote_filter_args(filter, *args) 2229 2230 def generator(svc, req): 2231 tries = 0 2232 while True: 2233 t = None if deadline is None else deadline - time.time() 2234 try: 2235 plumbing_response = svc.stub.List( 2236 req, 2237 metadata=svc.parent.get_metadata( 2238 'ApprovalWorkflows.List', req), 2239 timeout=t) 2240 except Exception as e: 2241 if self.parent.shouldRetry(tries, e, deadline): 2242 tries += 1 2243 time.sleep( 2244 self.parent.exponentialBackoff(tries, deadline)) 2245 continue 2246 raise plumbing.convert_error_to_porcelain(e) from e 2247 tries = 0 2248 for plumbing_item in plumbing_response.approval_workflows: 2249 yield plumbing.convert_approval_workflow_to_porcelain( 2250 plumbing_item) 2251 if plumbing_response.meta.next_cursor == '': 2252 break 2253 req.meta.cursor = plumbing_response.meta.next_cursor 2254 2255 return generator(self, req) 2256 2257 2258class SnapshotApprovalWorkflows: 2259 ''' 2260 SnapshotApprovalWorkflows exposes the read only methods of the ApprovalWorkflows 2261 service for historical queries. 2262 ''' 2263 def __init__(self, approval_workflows): 2264 self.approval_workflows = approval_workflows 2265 2266 def get(self, id, timeout=None): 2267 ''' 2268 Get reads one approval workflow by ID. 2269 ''' 2270 return self.approval_workflows.get(id, timeout=timeout) 2271 2272 def list(self, filter, *args, timeout=None): 2273 ''' 2274 Lists existing approval workflows. 2275 ''' 2276 return self.approval_workflows.list(filter, *args, timeout=timeout) 2277 2278 2279class ApprovalWorkflowsHistory: 2280 ''' 2281 ApprovalWorkflowsHistory records all changes to the state of an ApprovalWorkflow. 2282 See `strongdm.models.ApprovalWorkflowHistory`. 2283 ''' 2284 def __init__(self, channel, client): 2285 self.parent = client 2286 self.stub = ApprovalWorkflowsHistoryStub(channel) 2287 2288 def list(self, filter, *args, timeout=None): 2289 ''' 2290 List gets a list of ApprovalWorkflowHistory records matching a given set of criteria. 2291 ''' 2292 deadline = None if timeout is None else time.time() + timeout 2293 req = ApprovalWorkflowHistoryListRequest() 2294 req.meta.CopyFrom(ListRequestMetadata()) 2295 if self.parent.page_limit > 0: 2296 req.meta.limit = self.parent.page_limit 2297 if self.parent.snapshot_datetime is not None: 2298 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2299 2300 req.filter = plumbing.quote_filter_args(filter, *args) 2301 2302 def generator(svc, req): 2303 tries = 0 2304 while True: 2305 t = None if deadline is None else deadline - time.time() 2306 try: 2307 plumbing_response = svc.stub.List( 2308 req, 2309 metadata=svc.parent.get_metadata( 2310 'ApprovalWorkflowsHistory.List', req), 2311 timeout=t) 2312 except Exception as e: 2313 if self.parent.shouldRetry(tries, e, deadline): 2314 tries += 1 2315 time.sleep( 2316 self.parent.exponentialBackoff(tries, deadline)) 2317 continue 2318 raise plumbing.convert_error_to_porcelain(e) from e 2319 tries = 0 2320 for plumbing_item in plumbing_response.history: 2321 yield plumbing.convert_approval_workflow_history_to_porcelain( 2322 plumbing_item) 2323 if plumbing_response.meta.next_cursor == '': 2324 break 2325 req.meta.cursor = plumbing_response.meta.next_cursor 2326 2327 return generator(self, req) 2328 2329 2330class ControlPanel: 2331 ''' 2332 ControlPanel contains all administrative controls. 2333 ''' 2334 def __init__(self, channel, client): 2335 self.parent = client 2336 self.stub = ControlPanelStub(channel) 2337 2338 def get_sshca_public_key(self, timeout=None): 2339 ''' 2340 GetSSHCAPublicKey retrieves the SSH CA public key. 2341 ''' 2342 deadline = None if timeout is None else time.time() + timeout 2343 req = ControlPanelGetSSHCAPublicKeyRequest() 2344 2345 tries = 0 2346 plumbing_response = None 2347 while True: 2348 t = None if deadline is None else deadline - time.time() 2349 try: 2350 plumbing_response = self.stub.GetSSHCAPublicKey( 2351 req, 2352 metadata=self.parent.get_metadata( 2353 'ControlPanel.GetSSHCAPublicKey', req), 2354 timeout=t) 2355 except Exception as e: 2356 if self.parent.shouldRetry(tries, e, deadline): 2357 tries += 1 2358 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2359 continue 2360 raise plumbing.convert_error_to_porcelain(e) from e 2361 break 2362 2363 resp = models.ControlPanelGetSSHCAPublicKeyResponse() 2364 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2365 plumbing_response.meta) 2366 resp.public_key = (plumbing_response.public_key) 2367 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2368 plumbing_response.rate_limit) 2369 return resp 2370 2371 def get_rdpca_public_key(self, timeout=None): 2372 ''' 2373 GetRDPCAPublicKey retrieves the RDP CA public key. 2374 ''' 2375 deadline = None if timeout is None else time.time() + timeout 2376 req = ControlPanelGetRDPCAPublicKeyRequest() 2377 2378 tries = 0 2379 plumbing_response = None 2380 while True: 2381 t = None if deadline is None else deadline - time.time() 2382 try: 2383 plumbing_response = self.stub.GetRDPCAPublicKey( 2384 req, 2385 metadata=self.parent.get_metadata( 2386 'ControlPanel.GetRDPCAPublicKey', req), 2387 timeout=t) 2388 except Exception as e: 2389 if self.parent.shouldRetry(tries, e, deadline): 2390 tries += 1 2391 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2392 continue 2393 raise plumbing.convert_error_to_porcelain(e) from e 2394 break 2395 2396 resp = models.ControlPanelGetRDPCAPublicKeyResponse() 2397 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2398 plumbing_response.meta) 2399 resp.public_key = (plumbing_response.public_key) 2400 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2401 plumbing_response.rate_limit) 2402 return resp 2403 2404 def get_org_url_info(self, timeout=None): 2405 ''' 2406 GetOrgURLInfo retrieves URL configuration for the organization. 2407 This includes the base URL, website subdomain, OIDC issuer URL, and SAML metadata URL. 2408 ''' 2409 deadline = None if timeout is None else time.time() + timeout 2410 req = ControlPanelGetOrgURLInfoRequest() 2411 2412 tries = 0 2413 plumbing_response = None 2414 while True: 2415 t = None if deadline is None else deadline - time.time() 2416 try: 2417 plumbing_response = self.stub.GetOrgURLInfo( 2418 req, 2419 metadata=self.parent.get_metadata( 2420 'ControlPanel.GetOrgURLInfo', req), 2421 timeout=t) 2422 except Exception as e: 2423 if self.parent.shouldRetry(tries, e, deadline): 2424 tries += 1 2425 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2426 continue 2427 raise plumbing.convert_error_to_porcelain(e) from e 2428 break 2429 2430 resp = models.ControlPanelGetOrgURLInfoResponse() 2431 resp.base_url = (plumbing_response.base_url) 2432 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2433 plumbing_response.meta) 2434 resp.oidc_issuer_url = (plumbing_response.oidc_issuer_url) 2435 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2436 plumbing_response.rate_limit) 2437 resp.saml_metadata_url = (plumbing_response.saml_metadata_url) 2438 resp.websites_subdomain = (plumbing_response.websites_subdomain) 2439 return resp 2440 2441 def verify_jwt(self, token, timeout=None): 2442 ''' 2443 VerifyJWT reports whether the given JWT token (x-sdm-token) is valid. 2444 ''' 2445 deadline = None if timeout is None else time.time() + timeout 2446 req = ControlPanelVerifyJWTRequest() 2447 2448 req.token = (token) 2449 tries = 0 2450 plumbing_response = None 2451 while True: 2452 t = None if deadline is None else deadline - time.time() 2453 try: 2454 plumbing_response = self.stub.VerifyJWT( 2455 req, 2456 metadata=self.parent.get_metadata('ControlPanel.VerifyJWT', 2457 req), 2458 timeout=t) 2459 except Exception as e: 2460 if self.parent.shouldRetry(tries, e, deadline): 2461 tries += 1 2462 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2463 continue 2464 raise plumbing.convert_error_to_porcelain(e) from e 2465 break 2466 2467 resp = models.ControlPanelVerifyJWTResponse() 2468 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2469 plumbing_response.meta) 2470 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2471 plumbing_response.rate_limit) 2472 resp.valid = (plumbing_response.valid) 2473 return resp 2474 2475 2476class DiscoveryConnectors: 2477 ''' 2478 A Discovery Connector is a configuration object for performing Resource 2479 Scans in remote systems such as AWS, GCP, Azure, and other systems. 2480 See: 2481 `strongdm.models.AWSConnector` 2482 `strongdm.models.AzureConnector` 2483 `strongdm.models.GCPConnector` 2484 ''' 2485 def __init__(self, channel, client): 2486 self.parent = client 2487 self.stub = DiscoveryConnectorsStub(channel) 2488 2489 def create(self, connector, timeout=None): 2490 ''' 2491 Create adds a new Connector. 2492 ''' 2493 deadline = None if timeout is None else time.time() + timeout 2494 req = ConnectorCreateRequest() 2495 2496 if connector is not None: 2497 req.connector.CopyFrom( 2498 plumbing.convert_connector_to_plumbing(connector)) 2499 tries = 0 2500 plumbing_response = None 2501 while True: 2502 t = None if deadline is None else deadline - time.time() 2503 try: 2504 plumbing_response = self.stub.Create( 2505 req, 2506 metadata=self.parent.get_metadata( 2507 'DiscoveryConnectors.Create', req), 2508 timeout=t) 2509 except Exception as e: 2510 if self.parent.shouldRetry(tries, e, deadline): 2511 tries += 1 2512 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2513 continue 2514 raise plumbing.convert_error_to_porcelain(e) from e 2515 break 2516 2517 resp = models.ConnectorCreateResponse() 2518 resp.connector = plumbing.convert_connector_to_porcelain( 2519 plumbing_response.connector) 2520 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2521 plumbing_response.rate_limit) 2522 return resp 2523 2524 def get(self, id, timeout=None): 2525 ''' 2526 Get reads one Connector by ID 2527 ''' 2528 deadline = None if timeout is None else time.time() + timeout 2529 req = ConnectorGetRequest() 2530 if self.parent.snapshot_datetime is not None: 2531 req.meta.CopyFrom(GetRequestMetadata()) 2532 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2533 2534 req.id = (id) 2535 tries = 0 2536 plumbing_response = None 2537 while True: 2538 t = None if deadline is None else deadline - time.time() 2539 try: 2540 plumbing_response = self.stub.Get( 2541 req, 2542 metadata=self.parent.get_metadata( 2543 'DiscoveryConnectors.Get', req), 2544 timeout=t) 2545 except Exception as e: 2546 if self.parent.shouldRetry(tries, e, deadline): 2547 tries += 1 2548 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2549 continue 2550 raise plumbing.convert_error_to_porcelain(e) from e 2551 break 2552 2553 resp = models.ConnectorGetResponse() 2554 resp.connector = plumbing.convert_connector_to_porcelain( 2555 plumbing_response.connector) 2556 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2557 plumbing_response.meta) 2558 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2559 plumbing_response.rate_limit) 2560 return resp 2561 2562 def update(self, connector, timeout=None): 2563 ''' 2564 Update replaces all the fields of a Connector by ID. 2565 ''' 2566 deadline = None if timeout is None else time.time() + timeout 2567 req = ConnectorUpdateRequest() 2568 2569 if connector is not None: 2570 req.connector.CopyFrom( 2571 plumbing.convert_connector_to_plumbing(connector)) 2572 tries = 0 2573 plumbing_response = None 2574 while True: 2575 t = None if deadline is None else deadline - time.time() 2576 try: 2577 plumbing_response = self.stub.Update( 2578 req, 2579 metadata=self.parent.get_metadata( 2580 'DiscoveryConnectors.Update', req), 2581 timeout=t) 2582 except Exception as e: 2583 if self.parent.shouldRetry(tries, e, deadline): 2584 tries += 1 2585 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2586 continue 2587 raise plumbing.convert_error_to_porcelain(e) from e 2588 break 2589 2590 resp = models.ConnectorUpdateResponse() 2591 resp.connector = plumbing.convert_connector_to_porcelain( 2592 plumbing_response.connector) 2593 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2594 plumbing_response.rate_limit) 2595 return resp 2596 2597 def delete(self, id, timeout=None): 2598 ''' 2599 Delete removes a Connector by ID. 2600 ''' 2601 deadline = None if timeout is None else time.time() + timeout 2602 req = ConnectorDeleteRequest() 2603 2604 req.id = (id) 2605 tries = 0 2606 plumbing_response = None 2607 while True: 2608 t = None if deadline is None else deadline - time.time() 2609 try: 2610 plumbing_response = self.stub.Delete( 2611 req, 2612 metadata=self.parent.get_metadata( 2613 'DiscoveryConnectors.Delete', req), 2614 timeout=t) 2615 except Exception as e: 2616 if self.parent.shouldRetry(tries, e, deadline): 2617 tries += 1 2618 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2619 continue 2620 raise plumbing.convert_error_to_porcelain(e) from e 2621 break 2622 2623 resp = models.ConnectorDeleteResponse() 2624 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 2625 plumbing_response.meta) 2626 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2627 plumbing_response.rate_limit) 2628 return resp 2629 2630 def list(self, filter, *args, timeout=None): 2631 ''' 2632 List gets a list of Connectors matching a given set of criteria. 2633 ''' 2634 deadline = None if timeout is None else time.time() + timeout 2635 req = ConnectorListRequest() 2636 req.meta.CopyFrom(ListRequestMetadata()) 2637 if self.parent.page_limit > 0: 2638 req.meta.limit = self.parent.page_limit 2639 if self.parent.snapshot_datetime is not None: 2640 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2641 2642 req.filter = plumbing.quote_filter_args(filter, *args) 2643 2644 def generator(svc, req): 2645 tries = 0 2646 while True: 2647 t = None if deadline is None else deadline - time.time() 2648 try: 2649 plumbing_response = svc.stub.List( 2650 req, 2651 metadata=svc.parent.get_metadata( 2652 'DiscoveryConnectors.List', req), 2653 timeout=t) 2654 except Exception as e: 2655 if self.parent.shouldRetry(tries, e, deadline): 2656 tries += 1 2657 time.sleep( 2658 self.parent.exponentialBackoff(tries, deadline)) 2659 continue 2660 raise plumbing.convert_error_to_porcelain(e) from e 2661 tries = 0 2662 for plumbing_item in plumbing_response.connectors: 2663 yield plumbing.convert_connector_to_porcelain( 2664 plumbing_item) 2665 if plumbing_response.meta.next_cursor == '': 2666 break 2667 req.meta.cursor = plumbing_response.meta.next_cursor 2668 2669 return generator(self, req) 2670 2671 2672class SnapshotDiscoveryConnectors: 2673 ''' 2674 SnapshotDiscoveryConnectors exposes the read only methods of the DiscoveryConnectors 2675 service for historical queries. 2676 ''' 2677 def __init__(self, discovery_connectors): 2678 self.discovery_connectors = discovery_connectors 2679 2680 def get(self, id, timeout=None): 2681 ''' 2682 Get reads one Connector by ID 2683 ''' 2684 return self.discovery_connectors.get(id, timeout=timeout) 2685 2686 def list(self, filter, *args, timeout=None): 2687 ''' 2688 List gets a list of Connectors matching a given set of criteria. 2689 ''' 2690 return self.discovery_connectors.list(filter, *args, timeout=timeout) 2691 2692 2693class GrantedAccountEntitlements: 2694 ''' 2695 GrantedAccountEntitlements enumerates the resources to which an account has been granted access. 2696 The GrantedAccountEntitlements service is read-only. 2697 See `strongdm.models.GrantedAccountEntitlement`. 2698 ''' 2699 def __init__(self, channel, client): 2700 self.parent = client 2701 self.stub = GrantedAccountEntitlementsStub(channel) 2702 2703 def list(self, account_id, filter, *args, timeout=None): 2704 ''' 2705 List gets a list of GrantedAccountEntitlement records matching a given set of criteria. 2706 ''' 2707 deadline = None if timeout is None else time.time() + timeout 2708 req = GrantedAccountEntitlementListRequest() 2709 req.meta.CopyFrom(ListRequestMetadata()) 2710 if self.parent.page_limit > 0: 2711 req.meta.limit = self.parent.page_limit 2712 if self.parent.snapshot_datetime is not None: 2713 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2714 2715 req.account_id = (account_id) 2716 req.filter = plumbing.quote_filter_args(filter, *args) 2717 2718 def generator(svc, req): 2719 tries = 0 2720 while True: 2721 t = None if deadline is None else deadline - time.time() 2722 try: 2723 plumbing_response = svc.stub.List( 2724 req, 2725 metadata=svc.parent.get_metadata( 2726 'GrantedAccountEntitlements.List', req), 2727 timeout=t) 2728 except Exception as e: 2729 if self.parent.shouldRetry(tries, e, deadline): 2730 tries += 1 2731 time.sleep( 2732 self.parent.exponentialBackoff(tries, deadline)) 2733 continue 2734 raise plumbing.convert_error_to_porcelain(e) from e 2735 tries = 0 2736 for plumbing_item in plumbing_response.granted_account_entitlements: 2737 yield plumbing.convert_granted_account_entitlement_to_porcelain( 2738 plumbing_item) 2739 if plumbing_response.meta.next_cursor == '': 2740 break 2741 req.meta.cursor = plumbing_response.meta.next_cursor 2742 2743 return generator(self, req) 2744 2745 2746class SnapshotGrantedAccountEntitlements: 2747 ''' 2748 SnapshotGrantedAccountEntitlements exposes the read only methods of the GrantedAccountEntitlements 2749 service for historical queries. 2750 ''' 2751 def __init__(self, granted_account_entitlements): 2752 self.granted_account_entitlements = granted_account_entitlements 2753 2754 def list(self, account_id, filter, *args, timeout=None): 2755 ''' 2756 List gets a list of GrantedAccountEntitlement records matching a given set of criteria. 2757 ''' 2758 return self.granted_account_entitlements.list(account_id, 2759 filter, 2760 *args, 2761 timeout=timeout) 2762 2763 2764class GrantedResourceEntitlements: 2765 ''' 2766 GrantedResourceEntitlements enumerates the accounts that have been granted access to a given resource. 2767 The GrantedResourceEntitlements service is read-only. 2768 See `strongdm.models.GrantedResourceEntitlement`. 2769 ''' 2770 def __init__(self, channel, client): 2771 self.parent = client 2772 self.stub = GrantedResourceEntitlementsStub(channel) 2773 2774 def list(self, resource_id, filter, *args, timeout=None): 2775 ''' 2776 List gets a list of GrantedResourceEntitlement records matching a given set of criteria. 2777 ''' 2778 deadline = None if timeout is None else time.time() + timeout 2779 req = GrantedResourceEntitlementListRequest() 2780 req.meta.CopyFrom(ListRequestMetadata()) 2781 if self.parent.page_limit > 0: 2782 req.meta.limit = self.parent.page_limit 2783 if self.parent.snapshot_datetime is not None: 2784 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2785 2786 req.resource_id = (resource_id) 2787 req.filter = plumbing.quote_filter_args(filter, *args) 2788 2789 def generator(svc, req): 2790 tries = 0 2791 while True: 2792 t = None if deadline is None else deadline - time.time() 2793 try: 2794 plumbing_response = svc.stub.List( 2795 req, 2796 metadata=svc.parent.get_metadata( 2797 'GrantedResourceEntitlements.List', req), 2798 timeout=t) 2799 except Exception as e: 2800 if self.parent.shouldRetry(tries, e, deadline): 2801 tries += 1 2802 time.sleep( 2803 self.parent.exponentialBackoff(tries, deadline)) 2804 continue 2805 raise plumbing.convert_error_to_porcelain(e) from e 2806 tries = 0 2807 for plumbing_item in plumbing_response.granted_resource_entitlements: 2808 yield plumbing.convert_granted_resource_entitlement_to_porcelain( 2809 plumbing_item) 2810 if plumbing_response.meta.next_cursor == '': 2811 break 2812 req.meta.cursor = plumbing_response.meta.next_cursor 2813 2814 return generator(self, req) 2815 2816 2817class SnapshotGrantedResourceEntitlements: 2818 ''' 2819 SnapshotGrantedResourceEntitlements exposes the read only methods of the GrantedResourceEntitlements 2820 service for historical queries. 2821 ''' 2822 def __init__(self, granted_resource_entitlements): 2823 self.granted_resource_entitlements = granted_resource_entitlements 2824 2825 def list(self, resource_id, filter, *args, timeout=None): 2826 ''' 2827 List gets a list of GrantedResourceEntitlement records matching a given set of criteria. 2828 ''' 2829 return self.granted_resource_entitlements.list(resource_id, 2830 filter, 2831 *args, 2832 timeout=timeout) 2833 2834 2835class GrantedRoleEntitlements: 2836 ''' 2837 GrantedRoleEntitlements enumerates the resources to which a role grants access. 2838 The GrantedRoleEntitlements service is read-only. 2839 See `strongdm.models.GrantedRoleEntitlement`. 2840 ''' 2841 def __init__(self, channel, client): 2842 self.parent = client 2843 self.stub = GrantedRoleEntitlementsStub(channel) 2844 2845 def list(self, role_id, filter, *args, timeout=None): 2846 ''' 2847 List gets a list of GrantedRoleEntitlement records matching a given set of criteria. 2848 ''' 2849 deadline = None if timeout is None else time.time() + timeout 2850 req = GrantedRoleEntitlementListRequest() 2851 req.meta.CopyFrom(ListRequestMetadata()) 2852 if self.parent.page_limit > 0: 2853 req.meta.limit = self.parent.page_limit 2854 if self.parent.snapshot_datetime is not None: 2855 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2856 2857 req.role_id = (role_id) 2858 req.filter = plumbing.quote_filter_args(filter, *args) 2859 2860 def generator(svc, req): 2861 tries = 0 2862 while True: 2863 t = None if deadline is None else deadline - time.time() 2864 try: 2865 plumbing_response = svc.stub.List( 2866 req, 2867 metadata=svc.parent.get_metadata( 2868 'GrantedRoleEntitlements.List', req), 2869 timeout=t) 2870 except Exception as e: 2871 if self.parent.shouldRetry(tries, e, deadline): 2872 tries += 1 2873 time.sleep( 2874 self.parent.exponentialBackoff(tries, deadline)) 2875 continue 2876 raise plumbing.convert_error_to_porcelain(e) from e 2877 tries = 0 2878 for plumbing_item in plumbing_response.granted_role_entitlements: 2879 yield plumbing.convert_granted_role_entitlement_to_porcelain( 2880 plumbing_item) 2881 if plumbing_response.meta.next_cursor == '': 2882 break 2883 req.meta.cursor = plumbing_response.meta.next_cursor 2884 2885 return generator(self, req) 2886 2887 2888class SnapshotGrantedRoleEntitlements: 2889 ''' 2890 SnapshotGrantedRoleEntitlements exposes the read only methods of the GrantedRoleEntitlements 2891 service for historical queries. 2892 ''' 2893 def __init__(self, granted_role_entitlements): 2894 self.granted_role_entitlements = granted_role_entitlements 2895 2896 def list(self, role_id, filter, *args, timeout=None): 2897 ''' 2898 List gets a list of GrantedRoleEntitlement records matching a given set of criteria. 2899 ''' 2900 return self.granted_role_entitlements.list(role_id, 2901 filter, 2902 *args, 2903 timeout=timeout) 2904 2905 2906class Roles: 2907 ''' 2908 A Role has a list of access rules which determine which Resources the members 2909 of the Role have access to. An Account can be a member of multiple Roles via 2910 AccountAttachments. 2911 See `strongdm.models.Role`. 2912 ''' 2913 def __init__(self, channel, client): 2914 self.parent = client 2915 self.stub = RolesStub(channel) 2916 2917 def create(self, role, timeout=None): 2918 ''' 2919 Create registers a new Role. 2920 ''' 2921 deadline = None if timeout is None else time.time() + timeout 2922 req = RoleCreateRequest() 2923 2924 if role is not None: 2925 req.role.CopyFrom(plumbing.convert_role_to_plumbing(role)) 2926 tries = 0 2927 plumbing_response = None 2928 while True: 2929 t = None if deadline is None else deadline - time.time() 2930 try: 2931 plumbing_response = self.stub.Create( 2932 req, 2933 metadata=self.parent.get_metadata('Roles.Create', req), 2934 timeout=t) 2935 except Exception as e: 2936 if self.parent.shouldRetry(tries, e, deadline): 2937 tries += 1 2938 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2939 continue 2940 raise plumbing.convert_error_to_porcelain(e) from e 2941 break 2942 2943 resp = models.RoleCreateResponse() 2944 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 2945 plumbing_response.meta) 2946 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2947 plumbing_response.rate_limit) 2948 resp.role = plumbing.convert_role_to_porcelain(plumbing_response.role) 2949 return resp 2950 2951 def get(self, id, timeout=None): 2952 ''' 2953 Get reads one Role by ID. 2954 ''' 2955 deadline = None if timeout is None else time.time() + timeout 2956 req = RoleGetRequest() 2957 if self.parent.snapshot_datetime is not None: 2958 req.meta.CopyFrom(GetRequestMetadata()) 2959 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2960 2961 req.id = (id) 2962 tries = 0 2963 plumbing_response = None 2964 while True: 2965 t = None if deadline is None else deadline - time.time() 2966 try: 2967 plumbing_response = self.stub.Get( 2968 req, 2969 metadata=self.parent.get_metadata('Roles.Get', req), 2970 timeout=t) 2971 except Exception as e: 2972 if self.parent.shouldRetry(tries, e, deadline): 2973 tries += 1 2974 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2975 continue 2976 raise plumbing.convert_error_to_porcelain(e) from e 2977 break 2978 2979 resp = models.RoleGetResponse() 2980 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2981 plumbing_response.meta) 2982 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2983 plumbing_response.rate_limit) 2984 resp.role = plumbing.convert_role_to_porcelain(plumbing_response.role) 2985 return resp 2986 2987 def update(self, role, timeout=None): 2988 ''' 2989 Update replaces all the fields of a Role by ID. 2990 ''' 2991 deadline = None if timeout is None else time.time() + timeout 2992 req = RoleUpdateRequest() 2993 2994 if role is not None: 2995 req.role.CopyFrom(plumbing.convert_role_to_plumbing(role)) 2996 tries = 0 2997 plumbing_response = None 2998 while True: 2999 t = None if deadline is None else deadline - time.time() 3000 try: 3001 plumbing_response = self.stub.Update( 3002 req, 3003 metadata=self.parent.get_metadata('Roles.Update', req), 3004 timeout=t) 3005 except Exception as e: 3006 if self.parent.shouldRetry(tries, e, deadline): 3007 tries += 1 3008 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3009 continue 3010 raise plumbing.convert_error_to_porcelain(e) from e 3011 break 3012 3013 resp = models.RoleUpdateResponse() 3014 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 3015 plumbing_response.meta) 3016 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3017 plumbing_response.rate_limit) 3018 resp.role = plumbing.convert_role_to_porcelain(plumbing_response.role) 3019 return resp 3020 3021 def delete(self, id, timeout=None): 3022 ''' 3023 Delete removes a Role by ID. 3024 ''' 3025 deadline = None if timeout is None else time.time() + timeout 3026 req = RoleDeleteRequest() 3027 3028 req.id = (id) 3029 tries = 0 3030 plumbing_response = None 3031 while True: 3032 t = None if deadline is None else deadline - time.time() 3033 try: 3034 plumbing_response = self.stub.Delete( 3035 req, 3036 metadata=self.parent.get_metadata('Roles.Delete', req), 3037 timeout=t) 3038 except Exception as e: 3039 if self.parent.shouldRetry(tries, e, deadline): 3040 tries += 1 3041 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3042 continue 3043 raise plumbing.convert_error_to_porcelain(e) from e 3044 break 3045 3046 resp = models.RoleDeleteResponse() 3047 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3048 plumbing_response.meta) 3049 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3050 plumbing_response.rate_limit) 3051 return resp 3052 3053 def list(self, filter, *args, timeout=None): 3054 ''' 3055 List gets a list of Roles matching a given set of criteria. 3056 ''' 3057 deadline = None if timeout is None else time.time() + timeout 3058 req = RoleListRequest() 3059 req.meta.CopyFrom(ListRequestMetadata()) 3060 if self.parent.page_limit > 0: 3061 req.meta.limit = self.parent.page_limit 3062 if self.parent.snapshot_datetime is not None: 3063 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3064 3065 req.filter = plumbing.quote_filter_args(filter, *args) 3066 3067 def generator(svc, req): 3068 tries = 0 3069 while True: 3070 t = None if deadline is None else deadline - time.time() 3071 try: 3072 plumbing_response = svc.stub.List( 3073 req, 3074 metadata=svc.parent.get_metadata('Roles.List', req), 3075 timeout=t) 3076 except Exception as e: 3077 if self.parent.shouldRetry(tries, e, deadline): 3078 tries += 1 3079 time.sleep( 3080 self.parent.exponentialBackoff(tries, deadline)) 3081 continue 3082 raise plumbing.convert_error_to_porcelain(e) from e 3083 tries = 0 3084 for plumbing_item in plumbing_response.roles: 3085 yield plumbing.convert_role_to_porcelain(plumbing_item) 3086 if plumbing_response.meta.next_cursor == '': 3087 break 3088 req.meta.cursor = plumbing_response.meta.next_cursor 3089 3090 return generator(self, req) 3091 3092 3093class SnapshotRoles: 3094 ''' 3095 SnapshotRoles exposes the read only methods of the Roles 3096 service for historical queries. 3097 ''' 3098 def __init__(self, roles): 3099 self.roles = roles 3100 3101 def get(self, id, timeout=None): 3102 ''' 3103 Get reads one Role by ID. 3104 ''' 3105 return self.roles.get(id, timeout=timeout) 3106 3107 def list(self, filter, *args, timeout=None): 3108 ''' 3109 List gets a list of Roles matching a given set of criteria. 3110 ''' 3111 return self.roles.list(filter, *args, timeout=timeout) 3112 3113 3114class Groups: 3115 ''' 3116 A Group is a set of principals. 3117 See `strongdm.models.Group`. 3118 ''' 3119 def __init__(self, channel, client): 3120 self.parent = client 3121 self.stub = GroupsStub(channel) 3122 3123 def create(self, group, timeout=None): 3124 ''' 3125 Create registers a new Group. 3126 ''' 3127 deadline = None if timeout is None else time.time() + timeout 3128 req = GroupCreateRequest() 3129 3130 if group is not None: 3131 req.group.CopyFrom(plumbing.convert_group_to_plumbing(group)) 3132 tries = 0 3133 plumbing_response = None 3134 while True: 3135 t = None if deadline is None else deadline - time.time() 3136 try: 3137 plumbing_response = self.stub.Create( 3138 req, 3139 metadata=self.parent.get_metadata('Groups.Create', req), 3140 timeout=t) 3141 except Exception as e: 3142 if self.parent.shouldRetry(tries, e, deadline): 3143 tries += 1 3144 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3145 continue 3146 raise plumbing.convert_error_to_porcelain(e) from e 3147 break 3148 3149 resp = models.GroupCreateResponse() 3150 resp.group = plumbing.convert_group_to_porcelain( 3151 plumbing_response.group) 3152 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3153 plumbing_response.rate_limit) 3154 return resp 3155 3156 def create_from_roles(self, role_ids, commit, timeout=None): 3157 deadline = None if timeout is None else time.time() + timeout 3158 req = GroupCreateFromRolesRequest() 3159 3160 req.role_ids.extend((role_ids)) 3161 req.commit = (commit) 3162 tries = 0 3163 plumbing_response = None 3164 while True: 3165 t = None if deadline is None else deadline - time.time() 3166 try: 3167 plumbing_response = self.stub.CreateFromRoles( 3168 req, 3169 metadata=self.parent.get_metadata('Groups.CreateFromRoles', 3170 req), 3171 timeout=t) 3172 except Exception as e: 3173 if self.parent.shouldRetry(tries, e, deadline): 3174 tries += 1 3175 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3176 continue 3177 raise plumbing.convert_error_to_porcelain(e) from e 3178 break 3179 3180 resp = models.GroupCreateFromRolesResponse() 3181 resp.group_from_role = plumbing.convert_repeated_group_from_role_to_porcelain( 3182 plumbing_response.group_from_role) 3183 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3184 plumbing_response.rate_limit) 3185 return resp 3186 3187 def get(self, id, timeout=None): 3188 ''' 3189 Get reads one Group by ID. 3190 ''' 3191 deadline = None if timeout is None else time.time() + timeout 3192 req = GroupGetRequest() 3193 if self.parent.snapshot_datetime is not None: 3194 req.meta.CopyFrom(GetRequestMetadata()) 3195 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3196 3197 req.id = (id) 3198 tries = 0 3199 plumbing_response = None 3200 while True: 3201 t = None if deadline is None else deadline - time.time() 3202 try: 3203 plumbing_response = self.stub.Get( 3204 req, 3205 metadata=self.parent.get_metadata('Groups.Get', req), 3206 timeout=t) 3207 except Exception as e: 3208 if self.parent.shouldRetry(tries, e, deadline): 3209 tries += 1 3210 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3211 continue 3212 raise plumbing.convert_error_to_porcelain(e) from e 3213 break 3214 3215 resp = models.GroupGetResponse() 3216 resp.group = plumbing.convert_group_to_porcelain( 3217 plumbing_response.group) 3218 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3219 plumbing_response.meta) 3220 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3221 plumbing_response.rate_limit) 3222 return resp 3223 3224 def update(self, group, timeout=None): 3225 ''' 3226 Update replaces all the fields of a Group by ID. 3227 ''' 3228 deadline = None if timeout is None else time.time() + timeout 3229 req = GroupUpdateRequest() 3230 3231 if group is not None: 3232 req.group.CopyFrom(plumbing.convert_group_to_plumbing(group)) 3233 tries = 0 3234 plumbing_response = None 3235 while True: 3236 t = None if deadline is None else deadline - time.time() 3237 try: 3238 plumbing_response = self.stub.Update( 3239 req, 3240 metadata=self.parent.get_metadata('Groups.Update', req), 3241 timeout=t) 3242 except Exception as e: 3243 if self.parent.shouldRetry(tries, e, deadline): 3244 tries += 1 3245 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3246 continue 3247 raise plumbing.convert_error_to_porcelain(e) from e 3248 break 3249 3250 resp = models.GroupUpdateResponse() 3251 resp.group = plumbing.convert_group_to_porcelain( 3252 plumbing_response.group) 3253 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3254 plumbing_response.rate_limit) 3255 return resp 3256 3257 def delete(self, id, timeout=None): 3258 ''' 3259 Delete removes a Group by ID. 3260 ''' 3261 deadline = None if timeout is None else time.time() + timeout 3262 req = GroupDeleteRequest() 3263 3264 req.id = (id) 3265 tries = 0 3266 plumbing_response = None 3267 while True: 3268 t = None if deadline is None else deadline - time.time() 3269 try: 3270 plumbing_response = self.stub.Delete( 3271 req, 3272 metadata=self.parent.get_metadata('Groups.Delete', req), 3273 timeout=t) 3274 except Exception as e: 3275 if self.parent.shouldRetry(tries, e, deadline): 3276 tries += 1 3277 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3278 continue 3279 raise plumbing.convert_error_to_porcelain(e) from e 3280 break 3281 3282 resp = models.GroupDeleteResponse() 3283 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3284 plumbing_response.meta) 3285 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3286 plumbing_response.rate_limit) 3287 return resp 3288 3289 def list(self, filter, *args, timeout=None): 3290 ''' 3291 List gets a list of Groups matching a given set of criteria. 3292 ''' 3293 deadline = None if timeout is None else time.time() + timeout 3294 req = GroupListRequest() 3295 req.meta.CopyFrom(ListRequestMetadata()) 3296 if self.parent.page_limit > 0: 3297 req.meta.limit = self.parent.page_limit 3298 if self.parent.snapshot_datetime is not None: 3299 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3300 3301 req.filter = plumbing.quote_filter_args(filter, *args) 3302 3303 def generator(svc, req): 3304 tries = 0 3305 while True: 3306 t = None if deadline is None else deadline - time.time() 3307 try: 3308 plumbing_response = svc.stub.List( 3309 req, 3310 metadata=svc.parent.get_metadata('Groups.List', req), 3311 timeout=t) 3312 except Exception as e: 3313 if self.parent.shouldRetry(tries, e, deadline): 3314 tries += 1 3315 time.sleep( 3316 self.parent.exponentialBackoff(tries, deadline)) 3317 continue 3318 raise plumbing.convert_error_to_porcelain(e) from e 3319 tries = 0 3320 for plumbing_item in plumbing_response.groups: 3321 yield plumbing.convert_group_to_porcelain(plumbing_item) 3322 if plumbing_response.meta.next_cursor == '': 3323 break 3324 req.meta.cursor = plumbing_response.meta.next_cursor 3325 3326 return generator(self, req) 3327 3328 3329class SnapshotGroups: 3330 ''' 3331 SnapshotGroups exposes the read only methods of the Groups 3332 service for historical queries. 3333 ''' 3334 def __init__(self, groups): 3335 self.groups = groups 3336 3337 def get(self, id, timeout=None): 3338 ''' 3339 Get reads one Group by ID. 3340 ''' 3341 return self.groups.get(id, timeout=timeout) 3342 3343 def list(self, filter, *args, timeout=None): 3344 ''' 3345 List gets a list of Groups matching a given set of criteria. 3346 ''' 3347 return self.groups.list(filter, *args, timeout=timeout) 3348 3349 3350class GroupsHistory: 3351 ''' 3352 GroupsHistory records all changes to the state of a Group. 3353 See `strongdm.models.GroupHistory`. 3354 ''' 3355 def __init__(self, channel, client): 3356 self.parent = client 3357 self.stub = GroupsHistoryStub(channel) 3358 3359 def list(self, filter, *args, timeout=None): 3360 ''' 3361 List gets a list of GroupHistory records matching a given set of criteria. 3362 ''' 3363 deadline = None if timeout is None else time.time() + timeout 3364 req = GroupHistoryListRequest() 3365 req.meta.CopyFrom(ListRequestMetadata()) 3366 if self.parent.page_limit > 0: 3367 req.meta.limit = self.parent.page_limit 3368 if self.parent.snapshot_datetime is not None: 3369 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3370 3371 req.filter = plumbing.quote_filter_args(filter, *args) 3372 3373 def generator(svc, req): 3374 tries = 0 3375 while True: 3376 t = None if deadline is None else deadline - time.time() 3377 try: 3378 plumbing_response = svc.stub.List( 3379 req, 3380 metadata=svc.parent.get_metadata( 3381 'GroupsHistory.List', req), 3382 timeout=t) 3383 except Exception as e: 3384 if self.parent.shouldRetry(tries, e, deadline): 3385 tries += 1 3386 time.sleep( 3387 self.parent.exponentialBackoff(tries, deadline)) 3388 continue 3389 raise plumbing.convert_error_to_porcelain(e) from e 3390 tries = 0 3391 for plumbing_item in plumbing_response.history: 3392 yield plumbing.convert_group_history_to_porcelain( 3393 plumbing_item) 3394 if plumbing_response.meta.next_cursor == '': 3395 break 3396 req.meta.cursor = plumbing_response.meta.next_cursor 3397 3398 return generator(self, req) 3399 3400 3401class GroupsRoles: 3402 ''' 3403 A GroupRole is an assignment of a Group to a Role. 3404 See `strongdm.models.GroupRole`. 3405 ''' 3406 def __init__(self, channel, client): 3407 self.parent = client 3408 self.stub = GroupsRolesStub(channel) 3409 3410 def create(self, group_role, timeout=None): 3411 ''' 3412 Create registers a new GroupRole. 3413 ''' 3414 deadline = None if timeout is None else time.time() + timeout 3415 req = GroupRoleCreateRequest() 3416 3417 if group_role is not None: 3418 req.group_role.CopyFrom( 3419 plumbing.convert_group_role_to_plumbing(group_role)) 3420 tries = 0 3421 plumbing_response = None 3422 while True: 3423 t = None if deadline is None else deadline - time.time() 3424 try: 3425 plumbing_response = self.stub.Create( 3426 req, 3427 metadata=self.parent.get_metadata('GroupsRoles.Create', 3428 req), 3429 timeout=t) 3430 except Exception as e: 3431 if self.parent.shouldRetry(tries, e, deadline): 3432 tries += 1 3433 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3434 continue 3435 raise plumbing.convert_error_to_porcelain(e) from e 3436 break 3437 3438 resp = models.GroupRoleCreateResponse() 3439 resp.group_role = plumbing.convert_group_role_to_porcelain( 3440 plumbing_response.group_role) 3441 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3442 plumbing_response.rate_limit) 3443 return resp 3444 3445 def get(self, id, timeout=None): 3446 ''' 3447 Get reads one GroupRole by ID. 3448 ''' 3449 deadline = None if timeout is None else time.time() + timeout 3450 req = GroupRoleGetRequest() 3451 if self.parent.snapshot_datetime is not None: 3452 req.meta.CopyFrom(GetRequestMetadata()) 3453 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3454 3455 req.id = (id) 3456 tries = 0 3457 plumbing_response = None 3458 while True: 3459 t = None if deadline is None else deadline - time.time() 3460 try: 3461 plumbing_response = self.stub.Get( 3462 req, 3463 metadata=self.parent.get_metadata('GroupsRoles.Get', req), 3464 timeout=t) 3465 except Exception as e: 3466 if self.parent.shouldRetry(tries, e, deadline): 3467 tries += 1 3468 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3469 continue 3470 raise plumbing.convert_error_to_porcelain(e) from e 3471 break 3472 3473 resp = models.GroupRoleGetResponse() 3474 resp.group_role = plumbing.convert_group_role_to_porcelain( 3475 plumbing_response.group_role) 3476 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3477 plumbing_response.meta) 3478 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3479 plumbing_response.rate_limit) 3480 return resp 3481 3482 def delete(self, id, timeout=None): 3483 ''' 3484 Delete removes a GroupRole by ID. 3485 ''' 3486 deadline = None if timeout is None else time.time() + timeout 3487 req = GroupRoleDeleteRequest() 3488 3489 req.id = (id) 3490 tries = 0 3491 plumbing_response = None 3492 while True: 3493 t = None if deadline is None else deadline - time.time() 3494 try: 3495 plumbing_response = self.stub.Delete( 3496 req, 3497 metadata=self.parent.get_metadata('GroupsRoles.Delete', 3498 req), 3499 timeout=t) 3500 except Exception as e: 3501 if self.parent.shouldRetry(tries, e, deadline): 3502 tries += 1 3503 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3504 continue 3505 raise plumbing.convert_error_to_porcelain(e) from e 3506 break 3507 3508 resp = models.GroupRoleDeleteResponse() 3509 resp.group_role = plumbing.convert_group_role_to_porcelain( 3510 plumbing_response.group_role) 3511 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3512 plumbing_response.meta) 3513 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3514 plumbing_response.rate_limit) 3515 return resp 3516 3517 def list(self, filter, *args, timeout=None): 3518 ''' 3519 List gets a list of GroupRoles matching a given set of criteria. 3520 ''' 3521 deadline = None if timeout is None else time.time() + timeout 3522 req = GroupRoleListRequest() 3523 req.meta.CopyFrom(ListRequestMetadata()) 3524 if self.parent.page_limit > 0: 3525 req.meta.limit = self.parent.page_limit 3526 if self.parent.snapshot_datetime is not None: 3527 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3528 3529 req.filter = plumbing.quote_filter_args(filter, *args) 3530 3531 def generator(svc, req): 3532 tries = 0 3533 while True: 3534 t = None if deadline is None else deadline - time.time() 3535 try: 3536 plumbing_response = svc.stub.List( 3537 req, 3538 metadata=svc.parent.get_metadata( 3539 'GroupsRoles.List', req), 3540 timeout=t) 3541 except Exception as e: 3542 if self.parent.shouldRetry(tries, e, deadline): 3543 tries += 1 3544 time.sleep( 3545 self.parent.exponentialBackoff(tries, deadline)) 3546 continue 3547 raise plumbing.convert_error_to_porcelain(e) from e 3548 tries = 0 3549 for plumbing_item in plumbing_response.groups_roles: 3550 yield plumbing.convert_group_role_to_porcelain( 3551 plumbing_item) 3552 if plumbing_response.meta.next_cursor == '': 3553 break 3554 req.meta.cursor = plumbing_response.meta.next_cursor 3555 3556 return generator(self, req) 3557 3558 3559class SnapshotGroupsRoles: 3560 ''' 3561 SnapshotGroupsRoles exposes the read only methods of the GroupsRoles 3562 service for historical queries. 3563 ''' 3564 def __init__(self, groups_roles): 3565 self.groups_roles = groups_roles 3566 3567 def get(self, id, timeout=None): 3568 ''' 3569 Get reads one GroupRole by ID. 3570 ''' 3571 return self.groups_roles.get(id, timeout=timeout) 3572 3573 def list(self, filter, *args, timeout=None): 3574 ''' 3575 List gets a list of GroupRoles matching a given set of criteria. 3576 ''' 3577 return self.groups_roles.list(filter, *args, timeout=timeout) 3578 3579 3580class GroupsRolesHistory: 3581 ''' 3582 GroupsRolesHistory records all changes to the state of a GroupRole. 3583 See `strongdm.models.GroupRoleHistory`. 3584 ''' 3585 def __init__(self, channel, client): 3586 self.parent = client 3587 self.stub = GroupsRolesHistoryStub(channel) 3588 3589 def list(self, filter, *args, timeout=None): 3590 ''' 3591 List gets a list of GroupRoleHistory records matching a given set of criteria. 3592 ''' 3593 deadline = None if timeout is None else time.time() + timeout 3594 req = GroupRoleHistoryListRequest() 3595 req.meta.CopyFrom(ListRequestMetadata()) 3596 if self.parent.page_limit > 0: 3597 req.meta.limit = self.parent.page_limit 3598 if self.parent.snapshot_datetime is not None: 3599 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3600 3601 req.filter = plumbing.quote_filter_args(filter, *args) 3602 3603 def generator(svc, req): 3604 tries = 0 3605 while True: 3606 t = None if deadline is None else deadline - time.time() 3607 try: 3608 plumbing_response = svc.stub.List( 3609 req, 3610 metadata=svc.parent.get_metadata( 3611 'GroupsRolesHistory.List', req), 3612 timeout=t) 3613 except Exception as e: 3614 if self.parent.shouldRetry(tries, e, deadline): 3615 tries += 1 3616 time.sleep( 3617 self.parent.exponentialBackoff(tries, deadline)) 3618 continue 3619 raise plumbing.convert_error_to_porcelain(e) from e 3620 tries = 0 3621 for plumbing_item in plumbing_response.history: 3622 yield plumbing.convert_group_role_history_to_porcelain( 3623 plumbing_item) 3624 if plumbing_response.meta.next_cursor == '': 3625 break 3626 req.meta.cursor = plumbing_response.meta.next_cursor 3627 3628 return generator(self, req) 3629 3630 3631class HealthChecks: 3632 ''' 3633 HealthChecks lists the last healthcheck between each node and resource. 3634 Note the unconventional capitalization here is to prevent having a collision with GRPC 3635 See `strongdm.models.Healthcheck`. 3636 ''' 3637 def __init__(self, channel, client): 3638 self.parent = client 3639 self.stub = HealthChecksStub(channel) 3640 3641 def list(self, filter, *args, timeout=None): 3642 ''' 3643 List gets a list of Healthchecks matching a given set of criteria. 3644 ''' 3645 deadline = None if timeout is None else time.time() + timeout 3646 req = HealthcheckListRequest() 3647 req.meta.CopyFrom(ListRequestMetadata()) 3648 if self.parent.page_limit > 0: 3649 req.meta.limit = self.parent.page_limit 3650 if self.parent.snapshot_datetime is not None: 3651 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3652 3653 req.filter = plumbing.quote_filter_args(filter, *args) 3654 3655 def generator(svc, req): 3656 tries = 0 3657 while True: 3658 t = None if deadline is None else deadline - time.time() 3659 try: 3660 plumbing_response = svc.stub.List( 3661 req, 3662 metadata=svc.parent.get_metadata( 3663 'HealthChecks.List', req), 3664 timeout=t) 3665 except Exception as e: 3666 if self.parent.shouldRetry(tries, e, deadline): 3667 tries += 1 3668 time.sleep( 3669 self.parent.exponentialBackoff(tries, deadline)) 3670 continue 3671 raise plumbing.convert_error_to_porcelain(e) from e 3672 tries = 0 3673 for plumbing_item in plumbing_response.healthchecks: 3674 yield plumbing.convert_healthcheck_to_porcelain( 3675 plumbing_item) 3676 if plumbing_response.meta.next_cursor == '': 3677 break 3678 req.meta.cursor = plumbing_response.meta.next_cursor 3679 3680 return generator(self, req) 3681 3682 3683class IdentityAliases: 3684 ''' 3685 IdentityAliases assign an alias to an account within an IdentitySet. 3686 The alias is used as the username when connecting to a identity supported resource. 3687 See `strongdm.models.IdentityAlias`. 3688 ''' 3689 def __init__(self, channel, client): 3690 self.parent = client 3691 self.stub = IdentityAliasesStub(channel) 3692 3693 def create(self, identity_alias, timeout=None): 3694 ''' 3695 Create registers a new IdentityAlias. 3696 ''' 3697 deadline = None if timeout is None else time.time() + timeout 3698 req = IdentityAliasCreateRequest() 3699 3700 if identity_alias is not None: 3701 req.identity_alias.CopyFrom( 3702 plumbing.convert_identity_alias_to_plumbing(identity_alias)) 3703 tries = 0 3704 plumbing_response = None 3705 while True: 3706 t = None if deadline is None else deadline - time.time() 3707 try: 3708 plumbing_response = self.stub.Create( 3709 req, 3710 metadata=self.parent.get_metadata('IdentityAliases.Create', 3711 req), 3712 timeout=t) 3713 except Exception as e: 3714 if self.parent.shouldRetry(tries, e, deadline): 3715 tries += 1 3716 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3717 continue 3718 raise plumbing.convert_error_to_porcelain(e) from e 3719 break 3720 3721 resp = models.IdentityAliasCreateResponse() 3722 resp.identity_alias = plumbing.convert_identity_alias_to_porcelain( 3723 plumbing_response.identity_alias) 3724 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 3725 plumbing_response.meta) 3726 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3727 plumbing_response.rate_limit) 3728 return resp 3729 3730 def get(self, id, timeout=None): 3731 ''' 3732 Get reads one IdentityAlias by ID. 3733 ''' 3734 deadline = None if timeout is None else time.time() + timeout 3735 req = IdentityAliasGetRequest() 3736 if self.parent.snapshot_datetime is not None: 3737 req.meta.CopyFrom(GetRequestMetadata()) 3738 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3739 3740 req.id = (id) 3741 tries = 0 3742 plumbing_response = None 3743 while True: 3744 t = None if deadline is None else deadline - time.time() 3745 try: 3746 plumbing_response = self.stub.Get( 3747 req, 3748 metadata=self.parent.get_metadata('IdentityAliases.Get', 3749 req), 3750 timeout=t) 3751 except Exception as e: 3752 if self.parent.shouldRetry(tries, e, deadline): 3753 tries += 1 3754 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3755 continue 3756 raise plumbing.convert_error_to_porcelain(e) from e 3757 break 3758 3759 resp = models.IdentityAliasGetResponse() 3760 resp.identity_alias = plumbing.convert_identity_alias_to_porcelain( 3761 plumbing_response.identity_alias) 3762 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3763 plumbing_response.meta) 3764 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3765 plumbing_response.rate_limit) 3766 return resp 3767 3768 def update(self, identity_alias, timeout=None): 3769 ''' 3770 Update replaces all the fields of a IdentityAlias by ID. 3771 ''' 3772 deadline = None if timeout is None else time.time() + timeout 3773 req = IdentityAliasUpdateRequest() 3774 3775 if identity_alias is not None: 3776 req.identity_alias.CopyFrom( 3777 plumbing.convert_identity_alias_to_plumbing(identity_alias)) 3778 tries = 0 3779 plumbing_response = None 3780 while True: 3781 t = None if deadline is None else deadline - time.time() 3782 try: 3783 plumbing_response = self.stub.Update( 3784 req, 3785 metadata=self.parent.get_metadata('IdentityAliases.Update', 3786 req), 3787 timeout=t) 3788 except Exception as e: 3789 if self.parent.shouldRetry(tries, e, deadline): 3790 tries += 1 3791 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3792 continue 3793 raise plumbing.convert_error_to_porcelain(e) from e 3794 break 3795 3796 resp = models.IdentityAliasUpdateResponse() 3797 resp.identity_alias = plumbing.convert_identity_alias_to_porcelain( 3798 plumbing_response.identity_alias) 3799 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 3800 plumbing_response.meta) 3801 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3802 plumbing_response.rate_limit) 3803 return resp 3804 3805 def delete(self, id, timeout=None): 3806 ''' 3807 Delete removes a IdentityAlias by ID. 3808 ''' 3809 deadline = None if timeout is None else time.time() + timeout 3810 req = IdentityAliasDeleteRequest() 3811 3812 req.id = (id) 3813 tries = 0 3814 plumbing_response = None 3815 while True: 3816 t = None if deadline is None else deadline - time.time() 3817 try: 3818 plumbing_response = self.stub.Delete( 3819 req, 3820 metadata=self.parent.get_metadata('IdentityAliases.Delete', 3821 req), 3822 timeout=t) 3823 except Exception as e: 3824 if self.parent.shouldRetry(tries, e, deadline): 3825 tries += 1 3826 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3827 continue 3828 raise plumbing.convert_error_to_porcelain(e) from e 3829 break 3830 3831 resp = models.IdentityAliasDeleteResponse() 3832 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3833 plumbing_response.meta) 3834 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3835 plumbing_response.rate_limit) 3836 return resp 3837 3838 def list(self, filter, *args, timeout=None): 3839 ''' 3840 List gets a list of IdentityAliases matching a given set of criteria. 3841 ''' 3842 deadline = None if timeout is None else time.time() + timeout 3843 req = IdentityAliasListRequest() 3844 req.meta.CopyFrom(ListRequestMetadata()) 3845 if self.parent.page_limit > 0: 3846 req.meta.limit = self.parent.page_limit 3847 if self.parent.snapshot_datetime is not None: 3848 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3849 3850 req.filter = plumbing.quote_filter_args(filter, *args) 3851 3852 def generator(svc, req): 3853 tries = 0 3854 while True: 3855 t = None if deadline is None else deadline - time.time() 3856 try: 3857 plumbing_response = svc.stub.List( 3858 req, 3859 metadata=svc.parent.get_metadata( 3860 'IdentityAliases.List', req), 3861 timeout=t) 3862 except Exception as e: 3863 if self.parent.shouldRetry(tries, e, deadline): 3864 tries += 1 3865 time.sleep( 3866 self.parent.exponentialBackoff(tries, deadline)) 3867 continue 3868 raise plumbing.convert_error_to_porcelain(e) from e 3869 tries = 0 3870 for plumbing_item in plumbing_response.identity_aliases: 3871 yield plumbing.convert_identity_alias_to_porcelain( 3872 plumbing_item) 3873 if plumbing_response.meta.next_cursor == '': 3874 break 3875 req.meta.cursor = plumbing_response.meta.next_cursor 3876 3877 return generator(self, req) 3878 3879 3880class SnapshotIdentityAliases: 3881 ''' 3882 SnapshotIdentityAliases exposes the read only methods of the IdentityAliases 3883 service for historical queries. 3884 ''' 3885 def __init__(self, identity_aliases): 3886 self.identity_aliases = identity_aliases 3887 3888 def get(self, id, timeout=None): 3889 ''' 3890 Get reads one IdentityAlias by ID. 3891 ''' 3892 return self.identity_aliases.get(id, timeout=timeout) 3893 3894 def list(self, filter, *args, timeout=None): 3895 ''' 3896 List gets a list of IdentityAliases matching a given set of criteria. 3897 ''' 3898 return self.identity_aliases.list(filter, *args, timeout=timeout) 3899 3900 3901class IdentityAliasesHistory: 3902 ''' 3903 IdentityAliasesHistory records all changes to the state of a IdentityAlias. 3904 See `strongdm.models.IdentityAliasHistory`. 3905 ''' 3906 def __init__(self, channel, client): 3907 self.parent = client 3908 self.stub = IdentityAliasesHistoryStub(channel) 3909 3910 def list(self, filter, *args, timeout=None): 3911 ''' 3912 List gets a list of IdentityAliasHistory records matching a given set of criteria. 3913 ''' 3914 deadline = None if timeout is None else time.time() + timeout 3915 req = IdentityAliasHistoryListRequest() 3916 req.meta.CopyFrom(ListRequestMetadata()) 3917 if self.parent.page_limit > 0: 3918 req.meta.limit = self.parent.page_limit 3919 if self.parent.snapshot_datetime is not None: 3920 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3921 3922 req.filter = plumbing.quote_filter_args(filter, *args) 3923 3924 def generator(svc, req): 3925 tries = 0 3926 while True: 3927 t = None if deadline is None else deadline - time.time() 3928 try: 3929 plumbing_response = svc.stub.List( 3930 req, 3931 metadata=svc.parent.get_metadata( 3932 'IdentityAliasesHistory.List', req), 3933 timeout=t) 3934 except Exception as e: 3935 if self.parent.shouldRetry(tries, e, deadline): 3936 tries += 1 3937 time.sleep( 3938 self.parent.exponentialBackoff(tries, deadline)) 3939 continue 3940 raise plumbing.convert_error_to_porcelain(e) from e 3941 tries = 0 3942 for plumbing_item in plumbing_response.history: 3943 yield plumbing.convert_identity_alias_history_to_porcelain( 3944 plumbing_item) 3945 if plumbing_response.meta.next_cursor == '': 3946 break 3947 req.meta.cursor = plumbing_response.meta.next_cursor 3948 3949 return generator(self, req) 3950 3951 3952class IdentitySets: 3953 ''' 3954 A IdentitySet is a named grouping of Identity Aliases for Accounts. 3955 An Account's relationship to a IdentitySet is defined via IdentityAlias objects. 3956 See `strongdm.models.IdentitySet`. 3957 ''' 3958 def __init__(self, channel, client): 3959 self.parent = client 3960 self.stub = IdentitySetsStub(channel) 3961 3962 def create(self, identity_set, timeout=None): 3963 ''' 3964 Create registers a new IdentitySet. 3965 ''' 3966 deadline = None if timeout is None else time.time() + timeout 3967 req = IdentitySetCreateRequest() 3968 3969 if identity_set is not None: 3970 req.identity_set.CopyFrom( 3971 plumbing.convert_identity_set_to_plumbing(identity_set)) 3972 tries = 0 3973 plumbing_response = None 3974 while True: 3975 t = None if deadline is None else deadline - time.time() 3976 try: 3977 plumbing_response = self.stub.Create( 3978 req, 3979 metadata=self.parent.get_metadata('IdentitySets.Create', 3980 req), 3981 timeout=t) 3982 except Exception as e: 3983 if self.parent.shouldRetry(tries, e, deadline): 3984 tries += 1 3985 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3986 continue 3987 raise plumbing.convert_error_to_porcelain(e) from e 3988 break 3989 3990 resp = models.IdentitySetCreateResponse() 3991 resp.identity_set = plumbing.convert_identity_set_to_porcelain( 3992 plumbing_response.identity_set) 3993 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 3994 plumbing_response.meta) 3995 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3996 plumbing_response.rate_limit) 3997 return resp 3998 3999 def get(self, id, timeout=None): 4000 ''' 4001 Get reads one IdentitySet by ID. 4002 ''' 4003 deadline = None if timeout is None else time.time() + timeout 4004 req = IdentitySetGetRequest() 4005 if self.parent.snapshot_datetime is not None: 4006 req.meta.CopyFrom(GetRequestMetadata()) 4007 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4008 4009 req.id = (id) 4010 tries = 0 4011 plumbing_response = None 4012 while True: 4013 t = None if deadline is None else deadline - time.time() 4014 try: 4015 plumbing_response = self.stub.Get( 4016 req, 4017 metadata=self.parent.get_metadata('IdentitySets.Get', req), 4018 timeout=t) 4019 except Exception as e: 4020 if self.parent.shouldRetry(tries, e, deadline): 4021 tries += 1 4022 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4023 continue 4024 raise plumbing.convert_error_to_porcelain(e) from e 4025 break 4026 4027 resp = models.IdentitySetGetResponse() 4028 resp.identity_set = plumbing.convert_identity_set_to_porcelain( 4029 plumbing_response.identity_set) 4030 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4031 plumbing_response.meta) 4032 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4033 plumbing_response.rate_limit) 4034 return resp 4035 4036 def update(self, identity_set, timeout=None): 4037 ''' 4038 Update replaces all the fields of a IdentitySet by ID. 4039 ''' 4040 deadline = None if timeout is None else time.time() + timeout 4041 req = IdentitySetUpdateRequest() 4042 4043 if identity_set is not None: 4044 req.identity_set.CopyFrom( 4045 plumbing.convert_identity_set_to_plumbing(identity_set)) 4046 tries = 0 4047 plumbing_response = None 4048 while True: 4049 t = None if deadline is None else deadline - time.time() 4050 try: 4051 plumbing_response = self.stub.Update( 4052 req, 4053 metadata=self.parent.get_metadata('IdentitySets.Update', 4054 req), 4055 timeout=t) 4056 except Exception as e: 4057 if self.parent.shouldRetry(tries, e, deadline): 4058 tries += 1 4059 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4060 continue 4061 raise plumbing.convert_error_to_porcelain(e) from e 4062 break 4063 4064 resp = models.IdentitySetUpdateResponse() 4065 resp.identity_set = plumbing.convert_identity_set_to_porcelain( 4066 plumbing_response.identity_set) 4067 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 4068 plumbing_response.meta) 4069 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4070 plumbing_response.rate_limit) 4071 return resp 4072 4073 def delete(self, id, timeout=None): 4074 ''' 4075 Delete removes a IdentitySet by ID. 4076 ''' 4077 deadline = None if timeout is None else time.time() + timeout 4078 req = IdentitySetDeleteRequest() 4079 4080 req.id = (id) 4081 tries = 0 4082 plumbing_response = None 4083 while True: 4084 t = None if deadline is None else deadline - time.time() 4085 try: 4086 plumbing_response = self.stub.Delete( 4087 req, 4088 metadata=self.parent.get_metadata('IdentitySets.Delete', 4089 req), 4090 timeout=t) 4091 except Exception as e: 4092 if self.parent.shouldRetry(tries, e, deadline): 4093 tries += 1 4094 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4095 continue 4096 raise plumbing.convert_error_to_porcelain(e) from e 4097 break 4098 4099 resp = models.IdentitySetDeleteResponse() 4100 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 4101 plumbing_response.meta) 4102 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4103 plumbing_response.rate_limit) 4104 return resp 4105 4106 def list(self, filter, *args, timeout=None): 4107 ''' 4108 List gets a list of IdentitySets matching a given set of criteria. 4109 ''' 4110 deadline = None if timeout is None else time.time() + timeout 4111 req = IdentitySetListRequest() 4112 req.meta.CopyFrom(ListRequestMetadata()) 4113 if self.parent.page_limit > 0: 4114 req.meta.limit = self.parent.page_limit 4115 if self.parent.snapshot_datetime is not None: 4116 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4117 4118 req.filter = plumbing.quote_filter_args(filter, *args) 4119 4120 def generator(svc, req): 4121 tries = 0 4122 while True: 4123 t = None if deadline is None else deadline - time.time() 4124 try: 4125 plumbing_response = svc.stub.List( 4126 req, 4127 metadata=svc.parent.get_metadata( 4128 'IdentitySets.List', req), 4129 timeout=t) 4130 except Exception as e: 4131 if self.parent.shouldRetry(tries, e, deadline): 4132 tries += 1 4133 time.sleep( 4134 self.parent.exponentialBackoff(tries, deadline)) 4135 continue 4136 raise plumbing.convert_error_to_porcelain(e) from e 4137 tries = 0 4138 for plumbing_item in plumbing_response.identity_sets: 4139 yield plumbing.convert_identity_set_to_porcelain( 4140 plumbing_item) 4141 if plumbing_response.meta.next_cursor == '': 4142 break 4143 req.meta.cursor = plumbing_response.meta.next_cursor 4144 4145 return generator(self, req) 4146 4147 4148class SnapshotIdentitySets: 4149 ''' 4150 SnapshotIdentitySets exposes the read only methods of the IdentitySets 4151 service for historical queries. 4152 ''' 4153 def __init__(self, identity_sets): 4154 self.identity_sets = identity_sets 4155 4156 def get(self, id, timeout=None): 4157 ''' 4158 Get reads one IdentitySet by ID. 4159 ''' 4160 return self.identity_sets.get(id, timeout=timeout) 4161 4162 def list(self, filter, *args, timeout=None): 4163 ''' 4164 List gets a list of IdentitySets matching a given set of criteria. 4165 ''' 4166 return self.identity_sets.list(filter, *args, timeout=timeout) 4167 4168 4169class IdentitySetsHistory: 4170 ''' 4171 IdentitySetsHistory records all changes to the state of a IdentitySet. 4172 See `strongdm.models.IdentitySetHistory`. 4173 ''' 4174 def __init__(self, channel, client): 4175 self.parent = client 4176 self.stub = IdentitySetsHistoryStub(channel) 4177 4178 def list(self, filter, *args, timeout=None): 4179 ''' 4180 List gets a list of IdentitySetHistory records matching a given set of criteria. 4181 ''' 4182 deadline = None if timeout is None else time.time() + timeout 4183 req = IdentitySetHistoryListRequest() 4184 req.meta.CopyFrom(ListRequestMetadata()) 4185 if self.parent.page_limit > 0: 4186 req.meta.limit = self.parent.page_limit 4187 if self.parent.snapshot_datetime is not None: 4188 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4189 4190 req.filter = plumbing.quote_filter_args(filter, *args) 4191 4192 def generator(svc, req): 4193 tries = 0 4194 while True: 4195 t = None if deadline is None else deadline - time.time() 4196 try: 4197 plumbing_response = svc.stub.List( 4198 req, 4199 metadata=svc.parent.get_metadata( 4200 'IdentitySetsHistory.List', req), 4201 timeout=t) 4202 except Exception as e: 4203 if self.parent.shouldRetry(tries, e, deadline): 4204 tries += 1 4205 time.sleep( 4206 self.parent.exponentialBackoff(tries, deadline)) 4207 continue 4208 raise plumbing.convert_error_to_porcelain(e) from e 4209 tries = 0 4210 for plumbing_item in plumbing_response.history: 4211 yield plumbing.convert_identity_set_history_to_porcelain( 4212 plumbing_item) 4213 if plumbing_response.meta.next_cursor == '': 4214 break 4215 req.meta.cursor = plumbing_response.meta.next_cursor 4216 4217 return generator(self, req) 4218 4219 4220class ManagedSecrets: 4221 ''' 4222 ManagedSecret is a private vertical for creating, reading, updating, 4223 deleting, listing and rotating the managed secrets in the secrets engines as 4224 an authenticated user. 4225 See `strongdm.models.ManagedSecret`. 4226 ''' 4227 def __init__(self, channel, client): 4228 self.parent = client 4229 self.stub = ManagedSecretsStub(channel) 4230 4231 def list(self, filter, *args, timeout=None): 4232 ''' 4233 List returns Managed Secrets from a Secret Engine. 4234 ''' 4235 deadline = None if timeout is None else time.time() + timeout 4236 req = ManagedSecretListRequest() 4237 req.meta.CopyFrom(ListRequestMetadata()) 4238 if self.parent.page_limit > 0: 4239 req.meta.limit = self.parent.page_limit 4240 if self.parent.snapshot_datetime is not None: 4241 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4242 4243 req.filter = plumbing.quote_filter_args(filter, *args) 4244 4245 def generator(svc, req): 4246 tries = 0 4247 while True: 4248 t = None if deadline is None else deadline - time.time() 4249 try: 4250 plumbing_response = svc.stub.List( 4251 req, 4252 metadata=svc.parent.get_metadata( 4253 'ManagedSecrets.List', req), 4254 timeout=t) 4255 except Exception as e: 4256 if self.parent.shouldRetry(tries, e, deadline): 4257 tries += 1 4258 time.sleep( 4259 self.parent.exponentialBackoff(tries, deadline)) 4260 continue 4261 raise plumbing.convert_error_to_porcelain(e) from e 4262 tries = 0 4263 for plumbing_item in plumbing_response.managed_secrets: 4264 yield plumbing.convert_managed_secret_to_porcelain( 4265 plumbing_item) 4266 if plumbing_response.meta.next_cursor == '': 4267 break 4268 req.meta.cursor = plumbing_response.meta.next_cursor 4269 4270 return generator(self, req) 4271 4272 def list_by_actor(self, filter, *args, timeout=None): 4273 ''' 4274 List returns Managed Secrets for an Actor from a Secret Engine. 4275 ''' 4276 deadline = None if timeout is None else time.time() + timeout 4277 req = ManagedSecretListRequest() 4278 req.meta.CopyFrom(ListRequestMetadata()) 4279 if self.parent.page_limit > 0: 4280 req.meta.limit = self.parent.page_limit 4281 if self.parent.snapshot_datetime is not None: 4282 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4283 4284 req.filter = plumbing.quote_filter_args(filter, *args) 4285 4286 def generator(svc, req): 4287 tries = 0 4288 while True: 4289 t = None if deadline is None else deadline - time.time() 4290 try: 4291 plumbing_response = svc.stub.ListByActor( 4292 req, 4293 metadata=svc.parent.get_metadata( 4294 'ManagedSecrets.ListByActor', req), 4295 timeout=t) 4296 except Exception as e: 4297 if self.parent.shouldRetry(tries, e, deadline): 4298 tries += 1 4299 time.sleep( 4300 self.parent.exponentialBackoff(tries, deadline)) 4301 continue 4302 raise plumbing.convert_error_to_porcelain(e) from e 4303 tries = 0 4304 for plumbing_item in plumbing_response.managed_secrets: 4305 yield plumbing.convert_managed_secret_to_porcelain( 4306 plumbing_item) 4307 if plumbing_response.meta.next_cursor == '': 4308 break 4309 req.meta.cursor = plumbing_response.meta.next_cursor 4310 4311 return generator(self, req) 4312 4313 def create(self, managed_secret, timeout=None): 4314 ''' 4315 Create creates a Managed Secret 4316 ''' 4317 deadline = None if timeout is None else time.time() + timeout 4318 req = ManagedSecretCreateRequest() 4319 4320 if managed_secret is not None: 4321 req.managed_secret.CopyFrom( 4322 plumbing.convert_managed_secret_to_plumbing(managed_secret)) 4323 tries = 0 4324 plumbing_response = None 4325 while True: 4326 t = None if deadline is None else deadline - time.time() 4327 try: 4328 plumbing_response = self.stub.Create( 4329 req, 4330 metadata=self.parent.get_metadata('ManagedSecrets.Create', 4331 req), 4332 timeout=t) 4333 except Exception as e: 4334 if self.parent.shouldRetry(tries, e, deadline): 4335 tries += 1 4336 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4337 continue 4338 raise plumbing.convert_error_to_porcelain(e) from e 4339 break 4340 4341 resp = models.ManagedSecretCreateResponse() 4342 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 4343 plumbing_response.managed_secret) 4344 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4345 plumbing_response.meta) 4346 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4347 plumbing_response.rate_limit) 4348 return resp 4349 4350 def update(self, managed_secret, timeout=None): 4351 ''' 4352 Update updates a Managed Secret 4353 ''' 4354 deadline = None if timeout is None else time.time() + timeout 4355 req = ManagedSecretUpdateRequest() 4356 4357 if managed_secret is not None: 4358 req.managed_secret.CopyFrom( 4359 plumbing.convert_managed_secret_to_plumbing(managed_secret)) 4360 tries = 0 4361 plumbing_response = None 4362 while True: 4363 t = None if deadline is None else deadline - time.time() 4364 try: 4365 plumbing_response = self.stub.Update( 4366 req, 4367 metadata=self.parent.get_metadata('ManagedSecrets.Update', 4368 req), 4369 timeout=t) 4370 except Exception as e: 4371 if self.parent.shouldRetry(tries, e, deadline): 4372 tries += 1 4373 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4374 continue 4375 raise plumbing.convert_error_to_porcelain(e) from e 4376 break 4377 4378 resp = models.ManagedSecretUpdateResponse() 4379 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 4380 plumbing_response.managed_secret) 4381 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 4382 plumbing_response.meta) 4383 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4384 plumbing_response.rate_limit) 4385 return resp 4386 4387 def rotate(self, id, timeout=None): 4388 ''' 4389 Rotate forces rotation of Managed Secret 4390 ''' 4391 deadline = None if timeout is None else time.time() + timeout 4392 req = ManagedSecretRotateRequest() 4393 4394 req.id = (id) 4395 tries = 0 4396 plumbing_response = None 4397 while True: 4398 t = None if deadline is None else deadline - time.time() 4399 try: 4400 plumbing_response = self.stub.Rotate( 4401 req, 4402 metadata=self.parent.get_metadata('ManagedSecrets.Rotate', 4403 req), 4404 timeout=t) 4405 except Exception as e: 4406 if self.parent.shouldRetry(tries, e, deadline): 4407 tries += 1 4408 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4409 continue 4410 raise plumbing.convert_error_to_porcelain(e) from e 4411 break 4412 4413 resp = models.ManagedSecretRotateResponse() 4414 resp.meta = plumbing.convert_generic_response_metadata_to_porcelain( 4415 plumbing_response.meta) 4416 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4417 plumbing_response.rate_limit) 4418 return resp 4419 4420 def delete(self, id, timeout=None): 4421 ''' 4422 Delete deletes a Managed Secret 4423 ''' 4424 deadline = None if timeout is None else time.time() + timeout 4425 req = ManagedSecretDeleteRequest() 4426 4427 req.id = (id) 4428 tries = 0 4429 plumbing_response = None 4430 while True: 4431 t = None if deadline is None else deadline - time.time() 4432 try: 4433 plumbing_response = self.stub.Delete( 4434 req, 4435 metadata=self.parent.get_metadata('ManagedSecrets.Delete', 4436 req), 4437 timeout=t) 4438 except Exception as e: 4439 if self.parent.shouldRetry(tries, e, deadline): 4440 tries += 1 4441 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4442 continue 4443 raise plumbing.convert_error_to_porcelain(e) from e 4444 break 4445 4446 resp = models.ManagedSecretDeleteResponse() 4447 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4448 plumbing_response.rate_limit) 4449 return resp 4450 4451 def force_delete(self, id, timeout=None): 4452 ''' 4453 ForceDelete deletes a Managed Secret regardless of errors on external system 4454 ''' 4455 deadline = None if timeout is None else time.time() + timeout 4456 req = ManagedSecretDeleteRequest() 4457 4458 req.id = (id) 4459 tries = 0 4460 plumbing_response = None 4461 while True: 4462 t = None if deadline is None else deadline - time.time() 4463 try: 4464 plumbing_response = self.stub.ForceDelete( 4465 req, 4466 metadata=self.parent.get_metadata( 4467 'ManagedSecrets.ForceDelete', req), 4468 timeout=t) 4469 except Exception as e: 4470 if self.parent.shouldRetry(tries, e, deadline): 4471 tries += 1 4472 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4473 continue 4474 raise plumbing.convert_error_to_porcelain(e) from e 4475 break 4476 4477 resp = models.ManagedSecretDeleteResponse() 4478 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4479 plumbing_response.rate_limit) 4480 return resp 4481 4482 def get(self, id, timeout=None): 4483 ''' 4484 Get gets details of a Managed Secret without sensitive data 4485 ''' 4486 deadline = None if timeout is None else time.time() + timeout 4487 req = ManagedSecretGetRequest() 4488 if self.parent.snapshot_datetime is not None: 4489 req.meta.CopyFrom(GetRequestMetadata()) 4490 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4491 4492 req.id = (id) 4493 tries = 0 4494 plumbing_response = None 4495 while True: 4496 t = None if deadline is None else deadline - time.time() 4497 try: 4498 plumbing_response = self.stub.Get( 4499 req, 4500 metadata=self.parent.get_metadata('ManagedSecrets.Get', 4501 req), 4502 timeout=t) 4503 except Exception as e: 4504 if self.parent.shouldRetry(tries, e, deadline): 4505 tries += 1 4506 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4507 continue 4508 raise plumbing.convert_error_to_porcelain(e) from e 4509 break 4510 4511 resp = models.ManagedSecretGetResponse() 4512 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 4513 plumbing_response.managed_secret) 4514 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4515 plumbing_response.meta) 4516 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4517 plumbing_response.rate_limit) 4518 return resp 4519 4520 def retrieve(self, id, timeout=None): 4521 ''' 4522 Retrieve returns Managed Secret with sensitive data 4523 ''' 4524 deadline = None if timeout is None else time.time() + timeout 4525 req = ManagedSecretRetrieveRequest() 4526 4527 req.id = (id) 4528 tries = 0 4529 plumbing_response = None 4530 while True: 4531 t = None if deadline is None else deadline - time.time() 4532 try: 4533 plumbing_response = self.stub.Retrieve( 4534 req, 4535 metadata=self.parent.get_metadata( 4536 'ManagedSecrets.Retrieve', req), 4537 timeout=t) 4538 except Exception as e: 4539 if self.parent.shouldRetry(tries, e, deadline): 4540 tries += 1 4541 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4542 continue 4543 raise plumbing.convert_error_to_porcelain(e) from e 4544 break 4545 4546 resp = models.ManagedSecretRetrieveResponse() 4547 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 4548 plumbing_response.managed_secret) 4549 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4550 plumbing_response.meta) 4551 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4552 plumbing_response.rate_limit) 4553 return resp 4554 4555 def validate(self, id, timeout=None): 4556 ''' 4557 Validate returns the result of testing the stored credential against the 4558 secret engine. 4559 ''' 4560 deadline = None if timeout is None else time.time() + timeout 4561 req = ManagedSecretValidateRequest() 4562 4563 req.id = (id) 4564 tries = 0 4565 plumbing_response = None 4566 while True: 4567 t = None if deadline is None else deadline - time.time() 4568 try: 4569 plumbing_response = self.stub.Validate( 4570 req, 4571 metadata=self.parent.get_metadata( 4572 'ManagedSecrets.Validate', req), 4573 timeout=t) 4574 except Exception as e: 4575 if self.parent.shouldRetry(tries, e, deadline): 4576 tries += 1 4577 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4578 continue 4579 raise plumbing.convert_error_to_porcelain(e) from e 4580 break 4581 4582 resp = models.ManagedSecretValidateResponse() 4583 resp.invalid_info = (plumbing_response.invalid_info) 4584 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4585 plumbing_response.meta) 4586 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4587 plumbing_response.rate_limit) 4588 resp.valid = (plumbing_response.valid) 4589 return resp 4590 4591 def logs(self, filter, *args, timeout=None): 4592 ''' 4593 Logs returns the audit records for the managed secret. This may be replaced 4594 in the future. 4595 ''' 4596 deadline = None if timeout is None else time.time() + timeout 4597 req = ManagedSecretLogsRequest() 4598 req.meta.CopyFrom(ListRequestMetadata()) 4599 if self.parent.page_limit > 0: 4600 req.meta.limit = self.parent.page_limit 4601 if self.parent.snapshot_datetime is not None: 4602 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4603 4604 req.filter = plumbing.quote_filter_args(filter, *args) 4605 4606 def generator(svc, req): 4607 tries = 0 4608 while True: 4609 t = None if deadline is None else deadline - time.time() 4610 try: 4611 plumbing_response = svc.stub.Logs( 4612 req, 4613 metadata=svc.parent.get_metadata( 4614 'ManagedSecrets.Logs', req), 4615 timeout=t) 4616 except Exception as e: 4617 if self.parent.shouldRetry(tries, e, deadline): 4618 tries += 1 4619 time.sleep( 4620 self.parent.exponentialBackoff(tries, deadline)) 4621 continue 4622 raise plumbing.convert_error_to_porcelain(e) from e 4623 tries = 0 4624 for plumbing_item in plumbing_response.managed_secret_logs: 4625 yield plumbing.convert_managed_secret_log_to_porcelain( 4626 plumbing_item) 4627 if plumbing_response.meta.next_cursor == '': 4628 break 4629 req.meta.cursor = plumbing_response.meta.next_cursor 4630 4631 return generator(self, req) 4632 4633 4634class Nodes: 4635 ''' 4636 Nodes make up the StrongDM network, and allow your users to connect securely to your resources. 4637 There are three types of nodes: 4638 1. **Relay:** creates connectivity to your datasources, while maintaining the egress-only nature of your firewall 4639 2. **Gateway:** a relay that also listens for connections from StrongDM clients 4640 3. **Proxy Cluster:** a cluster of workers that together mediate access from clients to resources 4641 See: 4642 `strongdm.models.Gateway` 4643 `strongdm.models.ProxyCluster` 4644 `strongdm.models.Relay` 4645 ''' 4646 def __init__(self, channel, client): 4647 self.parent = client 4648 self.stub = NodesStub(channel) 4649 4650 def create(self, node, timeout=None): 4651 ''' 4652 Create registers a new Node. 4653 ''' 4654 deadline = None if timeout is None else time.time() + timeout 4655 req = NodeCreateRequest() 4656 4657 if node is not None: 4658 req.node.CopyFrom(plumbing.convert_node_to_plumbing(node)) 4659 tries = 0 4660 plumbing_response = None 4661 while True: 4662 t = None if deadline is None else deadline - time.time() 4663 try: 4664 plumbing_response = self.stub.Create( 4665 req, 4666 metadata=self.parent.get_metadata('Nodes.Create', req), 4667 timeout=t) 4668 except Exception as e: 4669 if self.parent.shouldRetry(tries, e, deadline): 4670 tries += 1 4671 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4672 continue 4673 raise plumbing.convert_error_to_porcelain(e) from e 4674 break 4675 4676 resp = models.NodeCreateResponse() 4677 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4678 plumbing_response.meta) 4679 resp.node = plumbing.convert_node_to_porcelain(plumbing_response.node) 4680 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4681 plumbing_response.rate_limit) 4682 resp.token = (plumbing_response.token) 4683 return resp 4684 4685 def get(self, id, timeout=None): 4686 ''' 4687 Get reads one Node by ID. 4688 ''' 4689 deadline = None if timeout is None else time.time() + timeout 4690 req = NodeGetRequest() 4691 if self.parent.snapshot_datetime is not None: 4692 req.meta.CopyFrom(GetRequestMetadata()) 4693 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4694 4695 req.id = (id) 4696 tries = 0 4697 plumbing_response = None 4698 while True: 4699 t = None if deadline is None else deadline - time.time() 4700 try: 4701 plumbing_response = self.stub.Get( 4702 req, 4703 metadata=self.parent.get_metadata('Nodes.Get', req), 4704 timeout=t) 4705 except Exception as e: 4706 if self.parent.shouldRetry(tries, e, deadline): 4707 tries += 1 4708 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4709 continue 4710 raise plumbing.convert_error_to_porcelain(e) from e 4711 break 4712 4713 resp = models.NodeGetResponse() 4714 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4715 plumbing_response.meta) 4716 resp.node = plumbing.convert_node_to_porcelain(plumbing_response.node) 4717 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4718 plumbing_response.rate_limit) 4719 return resp 4720 4721 def update(self, node, timeout=None): 4722 ''' 4723 Update replaces all the fields of a Node by ID. 4724 ''' 4725 deadline = None if timeout is None else time.time() + timeout 4726 req = NodeUpdateRequest() 4727 4728 if node is not None: 4729 req.node.CopyFrom(plumbing.convert_node_to_plumbing(node)) 4730 tries = 0 4731 plumbing_response = None 4732 while True: 4733 t = None if deadline is None else deadline - time.time() 4734 try: 4735 plumbing_response = self.stub.Update( 4736 req, 4737 metadata=self.parent.get_metadata('Nodes.Update', req), 4738 timeout=t) 4739 except Exception as e: 4740 if self.parent.shouldRetry(tries, e, deadline): 4741 tries += 1 4742 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4743 continue 4744 raise plumbing.convert_error_to_porcelain(e) from e 4745 break 4746 4747 resp = models.NodeUpdateResponse() 4748 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 4749 plumbing_response.meta) 4750 resp.node = plumbing.convert_node_to_porcelain(plumbing_response.node) 4751 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4752 plumbing_response.rate_limit) 4753 return resp 4754 4755 def delete(self, id, timeout=None): 4756 ''' 4757 Delete removes a Node by ID. 4758 ''' 4759 deadline = None if timeout is None else time.time() + timeout 4760 req = NodeDeleteRequest() 4761 4762 req.id = (id) 4763 tries = 0 4764 plumbing_response = None 4765 while True: 4766 t = None if deadline is None else deadline - time.time() 4767 try: 4768 plumbing_response = self.stub.Delete( 4769 req, 4770 metadata=self.parent.get_metadata('Nodes.Delete', req), 4771 timeout=t) 4772 except Exception as e: 4773 if self.parent.shouldRetry(tries, e, deadline): 4774 tries += 1 4775 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4776 continue 4777 raise plumbing.convert_error_to_porcelain(e) from e 4778 break 4779 4780 resp = models.NodeDeleteResponse() 4781 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 4782 plumbing_response.meta) 4783 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4784 plumbing_response.rate_limit) 4785 return resp 4786 4787 def list(self, filter, *args, timeout=None): 4788 ''' 4789 List gets a list of Nodes matching a given set of criteria. 4790 ''' 4791 deadline = None if timeout is None else time.time() + timeout 4792 req = NodeListRequest() 4793 req.meta.CopyFrom(ListRequestMetadata()) 4794 if self.parent.page_limit > 0: 4795 req.meta.limit = self.parent.page_limit 4796 if self.parent.snapshot_datetime is not None: 4797 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4798 4799 req.filter = plumbing.quote_filter_args(filter, *args) 4800 4801 def generator(svc, req): 4802 tries = 0 4803 while True: 4804 t = None if deadline is None else deadline - time.time() 4805 try: 4806 plumbing_response = svc.stub.List( 4807 req, 4808 metadata=svc.parent.get_metadata('Nodes.List', req), 4809 timeout=t) 4810 except Exception as e: 4811 if self.parent.shouldRetry(tries, e, deadline): 4812 tries += 1 4813 time.sleep( 4814 self.parent.exponentialBackoff(tries, deadline)) 4815 continue 4816 raise plumbing.convert_error_to_porcelain(e) from e 4817 tries = 0 4818 for plumbing_item in plumbing_response.nodes: 4819 yield plumbing.convert_node_to_porcelain(plumbing_item) 4820 if plumbing_response.meta.next_cursor == '': 4821 break 4822 req.meta.cursor = plumbing_response.meta.next_cursor 4823 4824 return generator(self, req) 4825 4826 def tcp_probe(self, node_id, host, port, timeout=None): 4827 ''' 4828 TCPProbe instructs a Node to connect to an address via TCP and report the 4829 result. 4830 ''' 4831 deadline = None if timeout is None else time.time() + timeout 4832 req = NodeTCPProbeRequest() 4833 4834 req.node_id = (node_id) 4835 req.host = (host) 4836 req.port = (port) 4837 tries = 0 4838 plumbing_response = None 4839 while True: 4840 t = None if deadline is None else deadline - time.time() 4841 try: 4842 plumbing_response = self.stub.TCPProbe( 4843 req, 4844 metadata=self.parent.get_metadata('Nodes.TCPProbe', req), 4845 timeout=t) 4846 except Exception as e: 4847 if self.parent.shouldRetry(tries, e, deadline): 4848 tries += 1 4849 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4850 continue 4851 raise plumbing.convert_error_to_porcelain(e) from e 4852 break 4853 4854 resp = models.NodeTCPProbeResponse() 4855 resp.error = (plumbing_response.error) 4856 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4857 plumbing_response.meta) 4858 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4859 plumbing_response.rate_limit) 4860 resp.succeeded = (plumbing_response.succeeded) 4861 return resp 4862 4863 4864class SnapshotNodes: 4865 ''' 4866 SnapshotNodes exposes the read only methods of the Nodes 4867 service for historical queries. 4868 ''' 4869 def __init__(self, nodes): 4870 self.nodes = nodes 4871 4872 def get(self, id, timeout=None): 4873 ''' 4874 Get reads one Node by ID. 4875 ''' 4876 return self.nodes.get(id, timeout=timeout) 4877 4878 def list(self, filter, *args, timeout=None): 4879 ''' 4880 List gets a list of Nodes matching a given set of criteria. 4881 ''' 4882 return self.nodes.list(filter, *args, timeout=timeout) 4883 4884 4885class NodesHistory: 4886 ''' 4887 NodesHistory records all changes to the state of a Node. 4888 See `strongdm.models.NodeHistory`. 4889 ''' 4890 def __init__(self, channel, client): 4891 self.parent = client 4892 self.stub = NodesHistoryStub(channel) 4893 4894 def list(self, filter, *args, timeout=None): 4895 ''' 4896 List gets a list of NodeHistory records matching a given set of criteria. 4897 ''' 4898 deadline = None if timeout is None else time.time() + timeout 4899 req = NodeHistoryListRequest() 4900 req.meta.CopyFrom(ListRequestMetadata()) 4901 if self.parent.page_limit > 0: 4902 req.meta.limit = self.parent.page_limit 4903 if self.parent.snapshot_datetime is not None: 4904 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4905 4906 req.filter = plumbing.quote_filter_args(filter, *args) 4907 4908 def generator(svc, req): 4909 tries = 0 4910 while True: 4911 t = None if deadline is None else deadline - time.time() 4912 try: 4913 plumbing_response = svc.stub.List( 4914 req, 4915 metadata=svc.parent.get_metadata( 4916 'NodesHistory.List', req), 4917 timeout=t) 4918 except Exception as e: 4919 if self.parent.shouldRetry(tries, e, deadline): 4920 tries += 1 4921 time.sleep( 4922 self.parent.exponentialBackoff(tries, deadline)) 4923 continue 4924 raise plumbing.convert_error_to_porcelain(e) from e 4925 tries = 0 4926 for plumbing_item in plumbing_response.history: 4927 yield plumbing.convert_node_history_to_porcelain( 4928 plumbing_item) 4929 if plumbing_response.meta.next_cursor == '': 4930 break 4931 req.meta.cursor = plumbing_response.meta.next_cursor 4932 4933 return generator(self, req) 4934 4935 4936class OrganizationHistory: 4937 ''' 4938 OrganizationHistory records all changes to the state of an Organization. 4939 See `strongdm.models.OrganizationHistoryRecord`. 4940 ''' 4941 def __init__(self, channel, client): 4942 self.parent = client 4943 self.stub = OrganizationHistoryStub(channel) 4944 4945 def list(self, filter, *args, timeout=None): 4946 ''' 4947 List gets a list of OrganizationHistory records matching a given set of criteria. 4948 ''' 4949 deadline = None if timeout is None else time.time() + timeout 4950 req = OrganizationHistoryListRequest() 4951 req.meta.CopyFrom(ListRequestMetadata()) 4952 if self.parent.page_limit > 0: 4953 req.meta.limit = self.parent.page_limit 4954 if self.parent.snapshot_datetime is not None: 4955 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4956 4957 req.filter = plumbing.quote_filter_args(filter, *args) 4958 4959 def generator(svc, req): 4960 tries = 0 4961 while True: 4962 t = None if deadline is None else deadline - time.time() 4963 try: 4964 plumbing_response = svc.stub.List( 4965 req, 4966 metadata=svc.parent.get_metadata( 4967 'OrganizationHistory.List', req), 4968 timeout=t) 4969 except Exception as e: 4970 if self.parent.shouldRetry(tries, e, deadline): 4971 tries += 1 4972 time.sleep( 4973 self.parent.exponentialBackoff(tries, deadline)) 4974 continue 4975 raise plumbing.convert_error_to_porcelain(e) from e 4976 tries = 0 4977 for plumbing_item in plumbing_response.history: 4978 yield plumbing.convert_organization_history_record_to_porcelain( 4979 plumbing_item) 4980 if plumbing_response.meta.next_cursor == '': 4981 break 4982 req.meta.cursor = plumbing_response.meta.next_cursor 4983 4984 return generator(self, req) 4985 4986 4987class PeeringGroupNodes: 4988 ''' 4989 PeeringGroupNodes provides the building blocks necessary to obtain attach a node to a peering group. 4990 See `strongdm.models.PeeringGroupNode`. 4991 ''' 4992 def __init__(self, channel, client): 4993 self.parent = client 4994 self.stub = PeeringGroupNodesStub(channel) 4995 4996 def create(self, peering_group_node, timeout=None): 4997 ''' 4998 Create attaches a Node to a PeeringGroup 4999 ''' 5000 deadline = None if timeout is None else time.time() + timeout 5001 req = PeeringGroupNodeCreateRequest() 5002 5003 if peering_group_node is not None: 5004 req.peering_group_node.CopyFrom( 5005 plumbing.convert_peering_group_node_to_plumbing( 5006 peering_group_node)) 5007 tries = 0 5008 plumbing_response = None 5009 while True: 5010 t = None if deadline is None else deadline - time.time() 5011 try: 5012 plumbing_response = self.stub.Create( 5013 req, 5014 metadata=self.parent.get_metadata( 5015 'PeeringGroupNodes.Create', req), 5016 timeout=t) 5017 except Exception as e: 5018 if self.parent.shouldRetry(tries, e, deadline): 5019 tries += 1 5020 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5021 continue 5022 raise plumbing.convert_error_to_porcelain(e) from e 5023 break 5024 5025 resp = models.PeeringGroupNodeCreateResponse() 5026 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5027 plumbing_response.meta) 5028 resp.peering_group_node = plumbing.convert_peering_group_node_to_porcelain( 5029 plumbing_response.peering_group_node) 5030 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5031 plumbing_response.rate_limit) 5032 return resp 5033 5034 def delete(self, id, timeout=None): 5035 ''' 5036 Delete detaches a Node to a PeeringGroup. 5037 ''' 5038 deadline = None if timeout is None else time.time() + timeout 5039 req = PeeringGroupNodeDeleteRequest() 5040 5041 req.id = (id) 5042 tries = 0 5043 plumbing_response = None 5044 while True: 5045 t = None if deadline is None else deadline - time.time() 5046 try: 5047 plumbing_response = self.stub.Delete( 5048 req, 5049 metadata=self.parent.get_metadata( 5050 'PeeringGroupNodes.Delete', req), 5051 timeout=t) 5052 except Exception as e: 5053 if self.parent.shouldRetry(tries, e, deadline): 5054 tries += 1 5055 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5056 continue 5057 raise plumbing.convert_error_to_porcelain(e) from e 5058 break 5059 5060 resp = models.PeeringGroupNodeDeleteResponse() 5061 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 5062 plumbing_response.meta) 5063 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5064 plumbing_response.rate_limit) 5065 return resp 5066 5067 def get(self, id, timeout=None): 5068 ''' 5069 Get reads the information of one peering group to node attachment. 5070 ''' 5071 deadline = None if timeout is None else time.time() + timeout 5072 req = PeeringGroupNodeGetRequest() 5073 if self.parent.snapshot_datetime is not None: 5074 req.meta.CopyFrom(GetRequestMetadata()) 5075 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5076 5077 req.id = (id) 5078 tries = 0 5079 plumbing_response = None 5080 while True: 5081 t = None if deadline is None else deadline - time.time() 5082 try: 5083 plumbing_response = self.stub.Get( 5084 req, 5085 metadata=self.parent.get_metadata('PeeringGroupNodes.Get', 5086 req), 5087 timeout=t) 5088 except Exception as e: 5089 if self.parent.shouldRetry(tries, e, deadline): 5090 tries += 1 5091 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5092 continue 5093 raise plumbing.convert_error_to_porcelain(e) from e 5094 break 5095 5096 resp = models.PeeringGroupNodeGetResponse() 5097 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5098 plumbing_response.meta) 5099 resp.peering_group_node = plumbing.convert_peering_group_node_to_porcelain( 5100 plumbing_response.peering_group_node) 5101 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5102 plumbing_response.rate_limit) 5103 return resp 5104 5105 def list(self, filter, *args, timeout=None): 5106 ''' 5107 List gets a list of peering group node attachments. 5108 ''' 5109 deadline = None if timeout is None else time.time() + timeout 5110 req = PeeringGroupNodeListRequest() 5111 req.meta.CopyFrom(ListRequestMetadata()) 5112 if self.parent.page_limit > 0: 5113 req.meta.limit = self.parent.page_limit 5114 if self.parent.snapshot_datetime is not None: 5115 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5116 5117 req.filter = plumbing.quote_filter_args(filter, *args) 5118 5119 def generator(svc, req): 5120 tries = 0 5121 while True: 5122 t = None if deadline is None else deadline - time.time() 5123 try: 5124 plumbing_response = svc.stub.List( 5125 req, 5126 metadata=svc.parent.get_metadata( 5127 'PeeringGroupNodes.List', req), 5128 timeout=t) 5129 except Exception as e: 5130 if self.parent.shouldRetry(tries, e, deadline): 5131 tries += 1 5132 time.sleep( 5133 self.parent.exponentialBackoff(tries, deadline)) 5134 continue 5135 raise plumbing.convert_error_to_porcelain(e) from e 5136 tries = 0 5137 for plumbing_item in plumbing_response.peering_group_nodes: 5138 yield plumbing.convert_peering_group_node_to_porcelain( 5139 plumbing_item) 5140 if plumbing_response.meta.next_cursor == '': 5141 break 5142 req.meta.cursor = plumbing_response.meta.next_cursor 5143 5144 return generator(self, req) 5145 5146 5147class PeeringGroupPeers: 5148 ''' 5149 PeeringGroupPeers provides the building blocks necessary to link two peering groups. 5150 See `strongdm.models.PeeringGroupPeer`. 5151 ''' 5152 def __init__(self, channel, client): 5153 self.parent = client 5154 self.stub = PeeringGroupPeersStub(channel) 5155 5156 def create(self, peering_group_peer, timeout=None): 5157 ''' 5158 Create links two peering groups. 5159 ''' 5160 deadline = None if timeout is None else time.time() + timeout 5161 req = PeeringGroupPeerCreateRequest() 5162 5163 if peering_group_peer is not None: 5164 req.peering_group_peer.CopyFrom( 5165 plumbing.convert_peering_group_peer_to_plumbing( 5166 peering_group_peer)) 5167 tries = 0 5168 plumbing_response = None 5169 while True: 5170 t = None if deadline is None else deadline - time.time() 5171 try: 5172 plumbing_response = self.stub.Create( 5173 req, 5174 metadata=self.parent.get_metadata( 5175 'PeeringGroupPeers.Create', req), 5176 timeout=t) 5177 except Exception as e: 5178 if self.parent.shouldRetry(tries, e, deadline): 5179 tries += 1 5180 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5181 continue 5182 raise plumbing.convert_error_to_porcelain(e) from e 5183 break 5184 5185 resp = models.PeeringGroupPeerCreateResponse() 5186 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5187 plumbing_response.meta) 5188 resp.peering_group_peer = plumbing.convert_peering_group_peer_to_porcelain( 5189 plumbing_response.peering_group_peer) 5190 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5191 plumbing_response.rate_limit) 5192 return resp 5193 5194 def delete(self, id, timeout=None): 5195 ''' 5196 Delete unlinks two peering groups. 5197 ''' 5198 deadline = None if timeout is None else time.time() + timeout 5199 req = PeeringGroupPeerDeleteRequest() 5200 5201 req.id = (id) 5202 tries = 0 5203 plumbing_response = None 5204 while True: 5205 t = None if deadline is None else deadline - time.time() 5206 try: 5207 plumbing_response = self.stub.Delete( 5208 req, 5209 metadata=self.parent.get_metadata( 5210 'PeeringGroupPeers.Delete', req), 5211 timeout=t) 5212 except Exception as e: 5213 if self.parent.shouldRetry(tries, e, deadline): 5214 tries += 1 5215 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5216 continue 5217 raise plumbing.convert_error_to_porcelain(e) from e 5218 break 5219 5220 resp = models.PeeringGroupPeerDeleteResponse() 5221 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 5222 plumbing_response.meta) 5223 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5224 plumbing_response.rate_limit) 5225 return resp 5226 5227 def get(self, id, timeout=None): 5228 ''' 5229 Get reads the information of one peering group link. 5230 ''' 5231 deadline = None if timeout is None else time.time() + timeout 5232 req = PeeringGroupPeerGetRequest() 5233 if self.parent.snapshot_datetime is not None: 5234 req.meta.CopyFrom(GetRequestMetadata()) 5235 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5236 5237 req.id = (id) 5238 tries = 0 5239 plumbing_response = None 5240 while True: 5241 t = None if deadline is None else deadline - time.time() 5242 try: 5243 plumbing_response = self.stub.Get( 5244 req, 5245 metadata=self.parent.get_metadata('PeeringGroupPeers.Get', 5246 req), 5247 timeout=t) 5248 except Exception as e: 5249 if self.parent.shouldRetry(tries, e, deadline): 5250 tries += 1 5251 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5252 continue 5253 raise plumbing.convert_error_to_porcelain(e) from e 5254 break 5255 5256 resp = models.PeeringGroupPeerGetResponse() 5257 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5258 plumbing_response.meta) 5259 resp.peering_group_peer = plumbing.convert_peering_group_peer_to_porcelain( 5260 plumbing_response.peering_group_peer) 5261 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5262 plumbing_response.rate_limit) 5263 return resp 5264 5265 def list(self, filter, *args, timeout=None): 5266 ''' 5267 List gets a list of peering group links. 5268 ''' 5269 deadline = None if timeout is None else time.time() + timeout 5270 req = PeeringGroupPeerListRequest() 5271 req.meta.CopyFrom(ListRequestMetadata()) 5272 if self.parent.page_limit > 0: 5273 req.meta.limit = self.parent.page_limit 5274 if self.parent.snapshot_datetime is not None: 5275 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5276 5277 req.filter = plumbing.quote_filter_args(filter, *args) 5278 5279 def generator(svc, req): 5280 tries = 0 5281 while True: 5282 t = None if deadline is None else deadline - time.time() 5283 try: 5284 plumbing_response = svc.stub.List( 5285 req, 5286 metadata=svc.parent.get_metadata( 5287 'PeeringGroupPeers.List', req), 5288 timeout=t) 5289 except Exception as e: 5290 if self.parent.shouldRetry(tries, e, deadline): 5291 tries += 1 5292 time.sleep( 5293 self.parent.exponentialBackoff(tries, deadline)) 5294 continue 5295 raise plumbing.convert_error_to_porcelain(e) from e 5296 tries = 0 5297 for plumbing_item in plumbing_response.peering_group_peers: 5298 yield plumbing.convert_peering_group_peer_to_porcelain( 5299 plumbing_item) 5300 if plumbing_response.meta.next_cursor == '': 5301 break 5302 req.meta.cursor = plumbing_response.meta.next_cursor 5303 5304 return generator(self, req) 5305 5306 5307class PeeringGroupResources: 5308 ''' 5309 PeeringGroupResources provides the building blocks necessary to obtain attach a resource to a peering group. 5310 See `strongdm.models.PeeringGroupResource`. 5311 ''' 5312 def __init__(self, channel, client): 5313 self.parent = client 5314 self.stub = PeeringGroupResourcesStub(channel) 5315 5316 def create(self, peering_group_resource, timeout=None): 5317 ''' 5318 Create attaches a Resource to a PeeringGroup 5319 ''' 5320 deadline = None if timeout is None else time.time() + timeout 5321 req = PeeringGroupResourceCreateRequest() 5322 5323 if peering_group_resource is not None: 5324 req.peering_group_resource.CopyFrom( 5325 plumbing.convert_peering_group_resource_to_plumbing( 5326 peering_group_resource)) 5327 tries = 0 5328 plumbing_response = None 5329 while True: 5330 t = None if deadline is None else deadline - time.time() 5331 try: 5332 plumbing_response = self.stub.Create( 5333 req, 5334 metadata=self.parent.get_metadata( 5335 'PeeringGroupResources.Create', req), 5336 timeout=t) 5337 except Exception as e: 5338 if self.parent.shouldRetry(tries, e, deadline): 5339 tries += 1 5340 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5341 continue 5342 raise plumbing.convert_error_to_porcelain(e) from e 5343 break 5344 5345 resp = models.PeeringGroupResourceCreateResponse() 5346 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5347 plumbing_response.meta) 5348 resp.peering_group_resource = plumbing.convert_peering_group_resource_to_porcelain( 5349 plumbing_response.peering_group_resource) 5350 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5351 plumbing_response.rate_limit) 5352 return resp 5353 5354 def delete(self, id, timeout=None): 5355 ''' 5356 Delete detaches a Resource to a PeeringGroup 5357 ''' 5358 deadline = None if timeout is None else time.time() + timeout 5359 req = PeeringGroupResourceDeleteRequest() 5360 5361 req.id = (id) 5362 tries = 0 5363 plumbing_response = None 5364 while True: 5365 t = None if deadline is None else deadline - time.time() 5366 try: 5367 plumbing_response = self.stub.Delete( 5368 req, 5369 metadata=self.parent.get_metadata( 5370 'PeeringGroupResources.Delete', req), 5371 timeout=t) 5372 except Exception as e: 5373 if self.parent.shouldRetry(tries, e, deadline): 5374 tries += 1 5375 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5376 continue 5377 raise plumbing.convert_error_to_porcelain(e) from e 5378 break 5379 5380 resp = models.PeeringGroupResourceDeleteResponse() 5381 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 5382 plumbing_response.meta) 5383 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5384 plumbing_response.rate_limit) 5385 return resp 5386 5387 def get(self, id, timeout=None): 5388 ''' 5389 Get reads the information of one peering group to resource attachment. 5390 ''' 5391 deadline = None if timeout is None else time.time() + timeout 5392 req = PeeringGroupResourceGetRequest() 5393 if self.parent.snapshot_datetime is not None: 5394 req.meta.CopyFrom(GetRequestMetadata()) 5395 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5396 5397 req.id = (id) 5398 tries = 0 5399 plumbing_response = None 5400 while True: 5401 t = None if deadline is None else deadline - time.time() 5402 try: 5403 plumbing_response = self.stub.Get( 5404 req, 5405 metadata=self.parent.get_metadata( 5406 'PeeringGroupResources.Get', req), 5407 timeout=t) 5408 except Exception as e: 5409 if self.parent.shouldRetry(tries, e, deadline): 5410 tries += 1 5411 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5412 continue 5413 raise plumbing.convert_error_to_porcelain(e) from e 5414 break 5415 5416 resp = models.PeeringGroupResourceGetResponse() 5417 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5418 plumbing_response.meta) 5419 resp.peering_group_resource = plumbing.convert_peering_group_resource_to_porcelain( 5420 plumbing_response.peering_group_resource) 5421 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5422 plumbing_response.rate_limit) 5423 return resp 5424 5425 def list(self, filter, *args, timeout=None): 5426 ''' 5427 List gets a list of peering group resource attachments. 5428 ''' 5429 deadline = None if timeout is None else time.time() + timeout 5430 req = PeeringGroupResourceListRequest() 5431 req.meta.CopyFrom(ListRequestMetadata()) 5432 if self.parent.page_limit > 0: 5433 req.meta.limit = self.parent.page_limit 5434 if self.parent.snapshot_datetime is not None: 5435 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5436 5437 req.filter = plumbing.quote_filter_args(filter, *args) 5438 5439 def generator(svc, req): 5440 tries = 0 5441 while True: 5442 t = None if deadline is None else deadline - time.time() 5443 try: 5444 plumbing_response = svc.stub.List( 5445 req, 5446 metadata=svc.parent.get_metadata( 5447 'PeeringGroupResources.List', req), 5448 timeout=t) 5449 except Exception as e: 5450 if self.parent.shouldRetry(tries, e, deadline): 5451 tries += 1 5452 time.sleep( 5453 self.parent.exponentialBackoff(tries, deadline)) 5454 continue 5455 raise plumbing.convert_error_to_porcelain(e) from e 5456 tries = 0 5457 for plumbing_item in plumbing_response.peering_group_resources: 5458 yield plumbing.convert_peering_group_resource_to_porcelain( 5459 plumbing_item) 5460 if plumbing_response.meta.next_cursor == '': 5461 break 5462 req.meta.cursor = plumbing_response.meta.next_cursor 5463 5464 return generator(self, req) 5465 5466 5467class PeeringGroups: 5468 ''' 5469 PeeringGroups provides the building blocks necessary to obtain explicit network topology and routing. 5470 See `strongdm.models.PeeringGroup`. 5471 ''' 5472 def __init__(self, channel, client): 5473 self.parent = client 5474 self.stub = PeeringGroupsStub(channel) 5475 5476 def create(self, peering_group, timeout=None): 5477 ''' 5478 Create registers a new PeeringGroup. 5479 ''' 5480 deadline = None if timeout is None else time.time() + timeout 5481 req = PeeringGroupCreateRequest() 5482 5483 if peering_group is not None: 5484 req.peering_group.CopyFrom( 5485 plumbing.convert_peering_group_to_plumbing(peering_group)) 5486 tries = 0 5487 plumbing_response = None 5488 while True: 5489 t = None if deadline is None else deadline - time.time() 5490 try: 5491 plumbing_response = self.stub.Create( 5492 req, 5493 metadata=self.parent.get_metadata('PeeringGroups.Create', 5494 req), 5495 timeout=t) 5496 except Exception as e: 5497 if self.parent.shouldRetry(tries, e, deadline): 5498 tries += 1 5499 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5500 continue 5501 raise plumbing.convert_error_to_porcelain(e) from e 5502 break 5503 5504 resp = models.PeeringGroupCreateResponse() 5505 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5506 plumbing_response.meta) 5507 resp.peering_group = plumbing.convert_peering_group_to_porcelain( 5508 plumbing_response.peering_group) 5509 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5510 plumbing_response.rate_limit) 5511 return resp 5512 5513 def delete(self, id, timeout=None): 5514 ''' 5515 Delete removes a PeeringGroup by ID. 5516 ''' 5517 deadline = None if timeout is None else time.time() + timeout 5518 req = PeeringGroupDeleteRequest() 5519 5520 req.id = (id) 5521 tries = 0 5522 plumbing_response = None 5523 while True: 5524 t = None if deadline is None else deadline - time.time() 5525 try: 5526 plumbing_response = self.stub.Delete( 5527 req, 5528 metadata=self.parent.get_metadata('PeeringGroups.Delete', 5529 req), 5530 timeout=t) 5531 except Exception as e: 5532 if self.parent.shouldRetry(tries, e, deadline): 5533 tries += 1 5534 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5535 continue 5536 raise plumbing.convert_error_to_porcelain(e) from e 5537 break 5538 5539 resp = models.PeeringGroupDeleteResponse() 5540 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 5541 plumbing_response.meta) 5542 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5543 plumbing_response.rate_limit) 5544 return resp 5545 5546 def get(self, id, timeout=None): 5547 ''' 5548 Get reads one PeeringGroup by ID. It will load all its dependencies. 5549 ''' 5550 deadline = None if timeout is None else time.time() + timeout 5551 req = PeeringGroupGetRequest() 5552 if self.parent.snapshot_datetime is not None: 5553 req.meta.CopyFrom(GetRequestMetadata()) 5554 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5555 5556 req.id = (id) 5557 tries = 0 5558 plumbing_response = None 5559 while True: 5560 t = None if deadline is None else deadline - time.time() 5561 try: 5562 plumbing_response = self.stub.Get( 5563 req, 5564 metadata=self.parent.get_metadata('PeeringGroups.Get', 5565 req), 5566 timeout=t) 5567 except Exception as e: 5568 if self.parent.shouldRetry(tries, e, deadline): 5569 tries += 1 5570 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5571 continue 5572 raise plumbing.convert_error_to_porcelain(e) from e 5573 break 5574 5575 resp = models.PeeringGroupGetResponse() 5576 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5577 plumbing_response.meta) 5578 resp.peering_group = plumbing.convert_peering_group_to_porcelain( 5579 plumbing_response.peering_group) 5580 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5581 plumbing_response.rate_limit) 5582 return resp 5583 5584 def list(self, filter, *args, timeout=None): 5585 ''' 5586 List gets a list of Peering Groups. 5587 ''' 5588 deadline = None if timeout is None else time.time() + timeout 5589 req = PeeringGroupListRequest() 5590 req.meta.CopyFrom(ListRequestMetadata()) 5591 if self.parent.page_limit > 0: 5592 req.meta.limit = self.parent.page_limit 5593 if self.parent.snapshot_datetime is not None: 5594 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5595 5596 req.filter = plumbing.quote_filter_args(filter, *args) 5597 5598 def generator(svc, req): 5599 tries = 0 5600 while True: 5601 t = None if deadline is None else deadline - time.time() 5602 try: 5603 plumbing_response = svc.stub.List( 5604 req, 5605 metadata=svc.parent.get_metadata( 5606 'PeeringGroups.List', req), 5607 timeout=t) 5608 except Exception as e: 5609 if self.parent.shouldRetry(tries, e, deadline): 5610 tries += 1 5611 time.sleep( 5612 self.parent.exponentialBackoff(tries, deadline)) 5613 continue 5614 raise plumbing.convert_error_to_porcelain(e) from e 5615 tries = 0 5616 for plumbing_item in plumbing_response.peering_groups: 5617 yield plumbing.convert_peering_group_to_porcelain( 5618 plumbing_item) 5619 if plumbing_response.meta.next_cursor == '': 5620 break 5621 req.meta.cursor = plumbing_response.meta.next_cursor 5622 5623 return generator(self, req) 5624 5625 5626class Policies: 5627 ''' 5628 Policies are the collection of one or more statements that enforce fine-grained access 5629 control for the users of an organization. 5630 See `strongdm.models.Policy`. 5631 ''' 5632 def __init__(self, channel, client): 5633 self.parent = client 5634 self.stub = PoliciesStub(channel) 5635 5636 def create(self, policy, timeout=None): 5637 ''' 5638 Create creates a new Policy. 5639 ''' 5640 deadline = None if timeout is None else time.time() + timeout 5641 req = PolicyCreateRequest() 5642 5643 if policy is not None: 5644 req.policy.CopyFrom(plumbing.convert_policy_to_plumbing(policy)) 5645 tries = 0 5646 plumbing_response = None 5647 while True: 5648 t = None if deadline is None else deadline - time.time() 5649 try: 5650 plumbing_response = self.stub.Create( 5651 req, 5652 metadata=self.parent.get_metadata('Policies.Create', req), 5653 timeout=t) 5654 except Exception as e: 5655 if self.parent.shouldRetry(tries, e, deadline): 5656 tries += 1 5657 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5658 continue 5659 raise plumbing.convert_error_to_porcelain(e) from e 5660 break 5661 5662 resp = models.PolicyCreateResponse() 5663 resp.policy = plumbing.convert_policy_to_porcelain( 5664 plumbing_response.policy) 5665 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5666 plumbing_response.rate_limit) 5667 return resp 5668 5669 def delete(self, id, timeout=None): 5670 ''' 5671 Delete removes a Policy by ID. 5672 ''' 5673 deadline = None if timeout is None else time.time() + timeout 5674 req = PolicyDeleteRequest() 5675 5676 req.id = (id) 5677 tries = 0 5678 plumbing_response = None 5679 while True: 5680 t = None if deadline is None else deadline - time.time() 5681 try: 5682 plumbing_response = self.stub.Delete( 5683 req, 5684 metadata=self.parent.get_metadata('Policies.Delete', req), 5685 timeout=t) 5686 except Exception as e: 5687 if self.parent.shouldRetry(tries, e, deadline): 5688 tries += 1 5689 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5690 continue 5691 raise plumbing.convert_error_to_porcelain(e) from e 5692 break 5693 5694 resp = models.PolicyDeleteResponse() 5695 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5696 plumbing_response.rate_limit) 5697 return resp 5698 5699 def update(self, policy, timeout=None): 5700 ''' 5701 Update replaces all the fields of a Policy by ID. 5702 ''' 5703 deadline = None if timeout is None else time.time() + timeout 5704 req = PolicyUpdateRequest() 5705 5706 if policy is not None: 5707 req.policy.CopyFrom(plumbing.convert_policy_to_plumbing(policy)) 5708 tries = 0 5709 plumbing_response = None 5710 while True: 5711 t = None if deadline is None else deadline - time.time() 5712 try: 5713 plumbing_response = self.stub.Update( 5714 req, 5715 metadata=self.parent.get_metadata('Policies.Update', req), 5716 timeout=t) 5717 except Exception as e: 5718 if self.parent.shouldRetry(tries, e, deadline): 5719 tries += 1 5720 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5721 continue 5722 raise plumbing.convert_error_to_porcelain(e) from e 5723 break 5724 5725 resp = models.PolicyUpdateResponse() 5726 resp.policy = plumbing.convert_policy_to_porcelain( 5727 plumbing_response.policy) 5728 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5729 plumbing_response.rate_limit) 5730 return resp 5731 5732 def get(self, id, timeout=None): 5733 ''' 5734 Get reads one Policy by ID. 5735 ''' 5736 deadline = None if timeout is None else time.time() + timeout 5737 req = PolicyGetRequest() 5738 if self.parent.snapshot_datetime is not None: 5739 req.meta.CopyFrom(GetRequestMetadata()) 5740 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5741 5742 req.id = (id) 5743 tries = 0 5744 plumbing_response = None 5745 while True: 5746 t = None if deadline is None else deadline - time.time() 5747 try: 5748 plumbing_response = self.stub.Get( 5749 req, 5750 metadata=self.parent.get_metadata('Policies.Get', req), 5751 timeout=t) 5752 except Exception as e: 5753 if self.parent.shouldRetry(tries, e, deadline): 5754 tries += 1 5755 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5756 continue 5757 raise plumbing.convert_error_to_porcelain(e) from e 5758 break 5759 5760 resp = models.PolicyGetResponse() 5761 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5762 plumbing_response.meta) 5763 resp.policy = plumbing.convert_policy_to_porcelain( 5764 plumbing_response.policy) 5765 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5766 plumbing_response.rate_limit) 5767 return resp 5768 5769 def list(self, filter, *args, timeout=None): 5770 ''' 5771 List gets a list of Policy matching a given set of criteria 5772 ''' 5773 deadline = None if timeout is None else time.time() + timeout 5774 req = PolicyListRequest() 5775 req.meta.CopyFrom(ListRequestMetadata()) 5776 if self.parent.page_limit > 0: 5777 req.meta.limit = self.parent.page_limit 5778 if self.parent.snapshot_datetime is not None: 5779 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5780 5781 req.filter = plumbing.quote_filter_args(filter, *args) 5782 5783 def generator(svc, req): 5784 tries = 0 5785 while True: 5786 t = None if deadline is None else deadline - time.time() 5787 try: 5788 plumbing_response = svc.stub.List( 5789 req, 5790 metadata=svc.parent.get_metadata('Policies.List', req), 5791 timeout=t) 5792 except Exception as e: 5793 if self.parent.shouldRetry(tries, e, deadline): 5794 tries += 1 5795 time.sleep( 5796 self.parent.exponentialBackoff(tries, deadline)) 5797 continue 5798 raise plumbing.convert_error_to_porcelain(e) from e 5799 tries = 0 5800 for plumbing_item in plumbing_response.policies: 5801 yield plumbing.convert_policy_to_porcelain(plumbing_item) 5802 if plumbing_response.meta.next_cursor == '': 5803 break 5804 req.meta.cursor = plumbing_response.meta.next_cursor 5805 5806 return generator(self, req) 5807 5808 5809class SnapshotPolicies: 5810 ''' 5811 SnapshotPolicies exposes the read only methods of the Policies 5812 service for historical queries. 5813 ''' 5814 def __init__(self, policies): 5815 self.policies = policies 5816 5817 def get(self, id, timeout=None): 5818 ''' 5819 Get reads one Policy by ID. 5820 ''' 5821 return self.policies.get(id, timeout=timeout) 5822 5823 def list(self, filter, *args, timeout=None): 5824 ''' 5825 List gets a list of Policy matching a given set of criteria 5826 ''' 5827 return self.policies.list(filter, *args, timeout=timeout) 5828 5829 5830class PoliciesHistory: 5831 ''' 5832 PoliciesHistory records all changes to the state of a Policy. 5833 See `strongdm.models.PolicyHistory`. 5834 ''' 5835 def __init__(self, channel, client): 5836 self.parent = client 5837 self.stub = PoliciesHistoryStub(channel) 5838 5839 def list(self, filter, *args, timeout=None): 5840 ''' 5841 List gets a list of PolicyHistory records matching a given set of criteria. 5842 ''' 5843 deadline = None if timeout is None else time.time() + timeout 5844 req = PoliciesHistoryListRequest() 5845 req.meta.CopyFrom(ListRequestMetadata()) 5846 if self.parent.page_limit > 0: 5847 req.meta.limit = self.parent.page_limit 5848 if self.parent.snapshot_datetime is not None: 5849 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5850 5851 req.filter = plumbing.quote_filter_args(filter, *args) 5852 5853 def generator(svc, req): 5854 tries = 0 5855 while True: 5856 t = None if deadline is None else deadline - time.time() 5857 try: 5858 plumbing_response = svc.stub.List( 5859 req, 5860 metadata=svc.parent.get_metadata( 5861 'PoliciesHistory.List', req), 5862 timeout=t) 5863 except Exception as e: 5864 if self.parent.shouldRetry(tries, e, deadline): 5865 tries += 1 5866 time.sleep( 5867 self.parent.exponentialBackoff(tries, deadline)) 5868 continue 5869 raise plumbing.convert_error_to_porcelain(e) from e 5870 tries = 0 5871 for plumbing_item in plumbing_response.history: 5872 yield plumbing.convert_policy_history_to_porcelain( 5873 plumbing_item) 5874 if plumbing_response.meta.next_cursor == '': 5875 break 5876 req.meta.cursor = plumbing_response.meta.next_cursor 5877 5878 return generator(self, req) 5879 5880 5881class ProxyClusterKeys: 5882 ''' 5883 Proxy Cluster Keys are authentication keys for all proxies within a cluster. 5884 The proxies within a cluster share the same key. One cluster can have 5885 multiple keys in order to facilitate key rotation. 5886 See `strongdm.models.ProxyClusterKey`. 5887 ''' 5888 def __init__(self, channel, client): 5889 self.parent = client 5890 self.stub = ProxyClusterKeysStub(channel) 5891 5892 def create(self, proxy_cluster_key, timeout=None): 5893 ''' 5894 Create registers a new ProxyClusterKey. 5895 ''' 5896 deadline = None if timeout is None else time.time() + timeout 5897 req = ProxyClusterKeyCreateRequest() 5898 5899 if proxy_cluster_key is not None: 5900 req.proxy_cluster_key.CopyFrom( 5901 plumbing.convert_proxy_cluster_key_to_plumbing( 5902 proxy_cluster_key)) 5903 tries = 0 5904 plumbing_response = None 5905 while True: 5906 t = None if deadline is None else deadline - time.time() 5907 try: 5908 plumbing_response = self.stub.Create( 5909 req, 5910 metadata=self.parent.get_metadata( 5911 'ProxyClusterKeys.Create', req), 5912 timeout=t) 5913 except Exception as e: 5914 if self.parent.shouldRetry(tries, e, deadline): 5915 tries += 1 5916 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5917 continue 5918 raise plumbing.convert_error_to_porcelain(e) from e 5919 break 5920 5921 resp = models.ProxyClusterKeyCreateResponse() 5922 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5923 plumbing_response.meta) 5924 resp.proxy_cluster_key = plumbing.convert_proxy_cluster_key_to_porcelain( 5925 plumbing_response.proxy_cluster_key) 5926 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5927 plumbing_response.rate_limit) 5928 resp.secret_key = (plumbing_response.secret_key) 5929 return resp 5930 5931 def get(self, id, timeout=None): 5932 ''' 5933 Get reads one ProxyClusterKey by ID. 5934 ''' 5935 deadline = None if timeout is None else time.time() + timeout 5936 req = ProxyClusterKeyGetRequest() 5937 if self.parent.snapshot_datetime is not None: 5938 req.meta.CopyFrom(GetRequestMetadata()) 5939 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5940 5941 req.id = (id) 5942 tries = 0 5943 plumbing_response = None 5944 while True: 5945 t = None if deadline is None else deadline - time.time() 5946 try: 5947 plumbing_response = self.stub.Get( 5948 req, 5949 metadata=self.parent.get_metadata('ProxyClusterKeys.Get', 5950 req), 5951 timeout=t) 5952 except Exception as e: 5953 if self.parent.shouldRetry(tries, e, deadline): 5954 tries += 1 5955 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5956 continue 5957 raise plumbing.convert_error_to_porcelain(e) from e 5958 break 5959 5960 resp = models.ProxyClusterKeyGetResponse() 5961 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5962 plumbing_response.meta) 5963 resp.proxy_cluster_key = plumbing.convert_proxy_cluster_key_to_porcelain( 5964 plumbing_response.proxy_cluster_key) 5965 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5966 plumbing_response.rate_limit) 5967 return resp 5968 5969 def delete(self, id, timeout=None): 5970 ''' 5971 Delete removes a ProxyClusterKey by ID. 5972 ''' 5973 deadline = None if timeout is None else time.time() + timeout 5974 req = ProxyClusterKeyDeleteRequest() 5975 5976 req.id = (id) 5977 tries = 0 5978 plumbing_response = None 5979 while True: 5980 t = None if deadline is None else deadline - time.time() 5981 try: 5982 plumbing_response = self.stub.Delete( 5983 req, 5984 metadata=self.parent.get_metadata( 5985 'ProxyClusterKeys.Delete', req), 5986 timeout=t) 5987 except Exception as e: 5988 if self.parent.shouldRetry(tries, e, deadline): 5989 tries += 1 5990 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5991 continue 5992 raise plumbing.convert_error_to_porcelain(e) from e 5993 break 5994 5995 resp = models.ProxyClusterKeyDeleteResponse() 5996 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 5997 plumbing_response.meta) 5998 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5999 plumbing_response.rate_limit) 6000 return resp 6001 6002 def list(self, filter, *args, timeout=None): 6003 ''' 6004 List gets a list of ProxyClusterKeys matching a given set of criteria. 6005 ''' 6006 deadline = None if timeout is None else time.time() + timeout 6007 req = ProxyClusterKeyListRequest() 6008 req.meta.CopyFrom(ListRequestMetadata()) 6009 if self.parent.page_limit > 0: 6010 req.meta.limit = self.parent.page_limit 6011 if self.parent.snapshot_datetime is not None: 6012 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6013 6014 req.filter = plumbing.quote_filter_args(filter, *args) 6015 6016 def generator(svc, req): 6017 tries = 0 6018 while True: 6019 t = None if deadline is None else deadline - time.time() 6020 try: 6021 plumbing_response = svc.stub.List( 6022 req, 6023 metadata=svc.parent.get_metadata( 6024 'ProxyClusterKeys.List', req), 6025 timeout=t) 6026 except Exception as e: 6027 if self.parent.shouldRetry(tries, e, deadline): 6028 tries += 1 6029 time.sleep( 6030 self.parent.exponentialBackoff(tries, deadline)) 6031 continue 6032 raise plumbing.convert_error_to_porcelain(e) from e 6033 tries = 0 6034 for plumbing_item in plumbing_response.proxy_cluster_keys: 6035 yield plumbing.convert_proxy_cluster_key_to_porcelain( 6036 plumbing_item) 6037 if plumbing_response.meta.next_cursor == '': 6038 break 6039 req.meta.cursor = plumbing_response.meta.next_cursor 6040 6041 return generator(self, req) 6042 6043 6044class SnapshotProxyClusterKeys: 6045 ''' 6046 SnapshotProxyClusterKeys exposes the read only methods of the ProxyClusterKeys 6047 service for historical queries. 6048 ''' 6049 def __init__(self, proxy_cluster_keys): 6050 self.proxy_cluster_keys = proxy_cluster_keys 6051 6052 def get(self, id, timeout=None): 6053 ''' 6054 Get reads one ProxyClusterKey by ID. 6055 ''' 6056 return self.proxy_cluster_keys.get(id, timeout=timeout) 6057 6058 def list(self, filter, *args, timeout=None): 6059 ''' 6060 List gets a list of ProxyClusterKeys matching a given set of criteria. 6061 ''' 6062 return self.proxy_cluster_keys.list(filter, *args, timeout=timeout) 6063 6064 6065class Queries: 6066 ''' 6067 A Query is a record of a single client request to a resource, such as a SQL query. 6068 Long-running SSH, RDP, or Kubernetes interactive sessions also count as queries. 6069 The Queries service is read-only. 6070 See `strongdm.models.Query`. 6071 ''' 6072 def __init__(self, channel, client): 6073 self.parent = client 6074 self.stub = QueriesStub(channel) 6075 6076 def list(self, filter, *args, timeout=None): 6077 ''' 6078 List gets a list of Queries matching a given set of criteria. 6079 ''' 6080 deadline = None if timeout is None else time.time() + timeout 6081 req = QueryListRequest() 6082 req.meta.CopyFrom(ListRequestMetadata()) 6083 if self.parent.page_limit > 0: 6084 req.meta.limit = self.parent.page_limit 6085 if self.parent.snapshot_datetime is not None: 6086 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6087 6088 req.filter = plumbing.quote_filter_args(filter, *args) 6089 6090 def generator(svc, req): 6091 tries = 0 6092 while True: 6093 t = None if deadline is None else deadline - time.time() 6094 try: 6095 plumbing_response = svc.stub.List( 6096 req, 6097 metadata=svc.parent.get_metadata('Queries.List', req), 6098 timeout=t) 6099 except Exception as e: 6100 if self.parent.shouldRetry(tries, e, deadline): 6101 tries += 1 6102 time.sleep( 6103 self.parent.exponentialBackoff(tries, deadline)) 6104 continue 6105 raise plumbing.convert_error_to_porcelain(e) from e 6106 tries = 0 6107 for plumbing_item in plumbing_response.queries: 6108 yield plumbing.convert_query_to_porcelain(plumbing_item) 6109 if plumbing_response.meta.next_cursor == '': 6110 break 6111 req.meta.cursor = plumbing_response.meta.next_cursor 6112 6113 return generator(self, req) 6114 6115 6116class RemoteIdentities: 6117 ''' 6118 RemoteIdentities assign a resource directly to an account, giving the account the permission to connect to that resource. 6119 See `strongdm.models.RemoteIdentity`. 6120 ''' 6121 def __init__(self, channel, client): 6122 self.parent = client 6123 self.stub = RemoteIdentitiesStub(channel) 6124 6125 def create(self, remote_identity, timeout=None): 6126 ''' 6127 Create registers a new RemoteIdentity. 6128 ''' 6129 deadline = None if timeout is None else time.time() + timeout 6130 req = RemoteIdentityCreateRequest() 6131 6132 if remote_identity is not None: 6133 req.remote_identity.CopyFrom( 6134 plumbing.convert_remote_identity_to_plumbing(remote_identity)) 6135 tries = 0 6136 plumbing_response = None 6137 while True: 6138 t = None if deadline is None else deadline - time.time() 6139 try: 6140 plumbing_response = self.stub.Create( 6141 req, 6142 metadata=self.parent.get_metadata( 6143 'RemoteIdentities.Create', req), 6144 timeout=t) 6145 except Exception as e: 6146 if self.parent.shouldRetry(tries, e, deadline): 6147 tries += 1 6148 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6149 continue 6150 raise plumbing.convert_error_to_porcelain(e) from e 6151 break 6152 6153 resp = models.RemoteIdentityCreateResponse() 6154 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 6155 plumbing_response.meta) 6156 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6157 plumbing_response.rate_limit) 6158 resp.remote_identity = plumbing.convert_remote_identity_to_porcelain( 6159 plumbing_response.remote_identity) 6160 return resp 6161 6162 def get(self, id, timeout=None): 6163 ''' 6164 Get reads one RemoteIdentity by ID. 6165 ''' 6166 deadline = None if timeout is None else time.time() + timeout 6167 req = RemoteIdentityGetRequest() 6168 if self.parent.snapshot_datetime is not None: 6169 req.meta.CopyFrom(GetRequestMetadata()) 6170 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6171 6172 req.id = (id) 6173 tries = 0 6174 plumbing_response = None 6175 while True: 6176 t = None if deadline is None else deadline - time.time() 6177 try: 6178 plumbing_response = self.stub.Get( 6179 req, 6180 metadata=self.parent.get_metadata('RemoteIdentities.Get', 6181 req), 6182 timeout=t) 6183 except Exception as e: 6184 if self.parent.shouldRetry(tries, e, deadline): 6185 tries += 1 6186 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6187 continue 6188 raise plumbing.convert_error_to_porcelain(e) from e 6189 break 6190 6191 resp = models.RemoteIdentityGetResponse() 6192 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 6193 plumbing_response.meta) 6194 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6195 plumbing_response.rate_limit) 6196 resp.remote_identity = plumbing.convert_remote_identity_to_porcelain( 6197 plumbing_response.remote_identity) 6198 return resp 6199 6200 def update(self, remote_identity, timeout=None): 6201 ''' 6202 Update replaces all the fields of a RemoteIdentity by ID. 6203 ''' 6204 deadline = None if timeout is None else time.time() + timeout 6205 req = RemoteIdentityUpdateRequest() 6206 6207 if remote_identity is not None: 6208 req.remote_identity.CopyFrom( 6209 plumbing.convert_remote_identity_to_plumbing(remote_identity)) 6210 tries = 0 6211 plumbing_response = None 6212 while True: 6213 t = None if deadline is None else deadline - time.time() 6214 try: 6215 plumbing_response = self.stub.Update( 6216 req, 6217 metadata=self.parent.get_metadata( 6218 'RemoteIdentities.Update', req), 6219 timeout=t) 6220 except Exception as e: 6221 if self.parent.shouldRetry(tries, e, deadline): 6222 tries += 1 6223 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6224 continue 6225 raise plumbing.convert_error_to_porcelain(e) from e 6226 break 6227 6228 resp = models.RemoteIdentityUpdateResponse() 6229 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 6230 plumbing_response.meta) 6231 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6232 plumbing_response.rate_limit) 6233 resp.remote_identity = plumbing.convert_remote_identity_to_porcelain( 6234 plumbing_response.remote_identity) 6235 return resp 6236 6237 def delete(self, id, timeout=None): 6238 ''' 6239 Delete removes a RemoteIdentity by ID. 6240 ''' 6241 deadline = None if timeout is None else time.time() + timeout 6242 req = RemoteIdentityDeleteRequest() 6243 6244 req.id = (id) 6245 tries = 0 6246 plumbing_response = None 6247 while True: 6248 t = None if deadline is None else deadline - time.time() 6249 try: 6250 plumbing_response = self.stub.Delete( 6251 req, 6252 metadata=self.parent.get_metadata( 6253 'RemoteIdentities.Delete', req), 6254 timeout=t) 6255 except Exception as e: 6256 if self.parent.shouldRetry(tries, e, deadline): 6257 tries += 1 6258 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6259 continue 6260 raise plumbing.convert_error_to_porcelain(e) from e 6261 break 6262 6263 resp = models.RemoteIdentityDeleteResponse() 6264 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 6265 plumbing_response.meta) 6266 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6267 plumbing_response.rate_limit) 6268 return resp 6269 6270 def list(self, filter, *args, timeout=None): 6271 ''' 6272 List gets a list of RemoteIdentities matching a given set of criteria. 6273 ''' 6274 deadline = None if timeout is None else time.time() + timeout 6275 req = RemoteIdentityListRequest() 6276 req.meta.CopyFrom(ListRequestMetadata()) 6277 if self.parent.page_limit > 0: 6278 req.meta.limit = self.parent.page_limit 6279 if self.parent.snapshot_datetime is not None: 6280 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6281 6282 req.filter = plumbing.quote_filter_args(filter, *args) 6283 6284 def generator(svc, req): 6285 tries = 0 6286 while True: 6287 t = None if deadline is None else deadline - time.time() 6288 try: 6289 plumbing_response = svc.stub.List( 6290 req, 6291 metadata=svc.parent.get_metadata( 6292 'RemoteIdentities.List', req), 6293 timeout=t) 6294 except Exception as e: 6295 if self.parent.shouldRetry(tries, e, deadline): 6296 tries += 1 6297 time.sleep( 6298 self.parent.exponentialBackoff(tries, deadline)) 6299 continue 6300 raise plumbing.convert_error_to_porcelain(e) from e 6301 tries = 0 6302 for plumbing_item in plumbing_response.remote_identities: 6303 yield plumbing.convert_remote_identity_to_porcelain( 6304 plumbing_item) 6305 if plumbing_response.meta.next_cursor == '': 6306 break 6307 req.meta.cursor = plumbing_response.meta.next_cursor 6308 6309 return generator(self, req) 6310 6311 6312class SnapshotRemoteIdentities: 6313 ''' 6314 SnapshotRemoteIdentities exposes the read only methods of the RemoteIdentities 6315 service for historical queries. 6316 ''' 6317 def __init__(self, remote_identities): 6318 self.remote_identities = remote_identities 6319 6320 def get(self, id, timeout=None): 6321 ''' 6322 Get reads one RemoteIdentity by ID. 6323 ''' 6324 return self.remote_identities.get(id, timeout=timeout) 6325 6326 def list(self, filter, *args, timeout=None): 6327 ''' 6328 List gets a list of RemoteIdentities matching a given set of criteria. 6329 ''' 6330 return self.remote_identities.list(filter, *args, timeout=timeout) 6331 6332 6333class RemoteIdentitiesHistory: 6334 ''' 6335 RemoteIdentitiesHistory records all changes to the state of a RemoteIdentity. 6336 See `strongdm.models.RemoteIdentityHistory`. 6337 ''' 6338 def __init__(self, channel, client): 6339 self.parent = client 6340 self.stub = RemoteIdentitiesHistoryStub(channel) 6341 6342 def list(self, filter, *args, timeout=None): 6343 ''' 6344 List gets a list of RemoteIdentityHistory records matching a given set of criteria. 6345 ''' 6346 deadline = None if timeout is None else time.time() + timeout 6347 req = RemoteIdentityHistoryListRequest() 6348 req.meta.CopyFrom(ListRequestMetadata()) 6349 if self.parent.page_limit > 0: 6350 req.meta.limit = self.parent.page_limit 6351 if self.parent.snapshot_datetime is not None: 6352 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6353 6354 req.filter = plumbing.quote_filter_args(filter, *args) 6355 6356 def generator(svc, req): 6357 tries = 0 6358 while True: 6359 t = None if deadline is None else deadline - time.time() 6360 try: 6361 plumbing_response = svc.stub.List( 6362 req, 6363 metadata=svc.parent.get_metadata( 6364 'RemoteIdentitiesHistory.List', req), 6365 timeout=t) 6366 except Exception as e: 6367 if self.parent.shouldRetry(tries, e, deadline): 6368 tries += 1 6369 time.sleep( 6370 self.parent.exponentialBackoff(tries, deadline)) 6371 continue 6372 raise plumbing.convert_error_to_porcelain(e) from e 6373 tries = 0 6374 for plumbing_item in plumbing_response.history: 6375 yield plumbing.convert_remote_identity_history_to_porcelain( 6376 plumbing_item) 6377 if plumbing_response.meta.next_cursor == '': 6378 break 6379 req.meta.cursor = plumbing_response.meta.next_cursor 6380 6381 return generator(self, req) 6382 6383 6384class RemoteIdentityGroups: 6385 ''' 6386 A RemoteIdentityGroup is a named grouping of Remote Identities for Accounts. 6387 An Account's relationship to a RemoteIdentityGroup is defined via RemoteIdentity objects. 6388 See `strongdm.models.RemoteIdentityGroup`. 6389 ''' 6390 def __init__(self, channel, client): 6391 self.parent = client 6392 self.stub = RemoteIdentityGroupsStub(channel) 6393 6394 def get(self, id, timeout=None): 6395 ''' 6396 Get reads one RemoteIdentityGroup by ID. 6397 ''' 6398 deadline = None if timeout is None else time.time() + timeout 6399 req = RemoteIdentityGroupGetRequest() 6400 if self.parent.snapshot_datetime is not None: 6401 req.meta.CopyFrom(GetRequestMetadata()) 6402 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6403 6404 req.id = (id) 6405 tries = 0 6406 plumbing_response = None 6407 while True: 6408 t = None if deadline is None else deadline - time.time() 6409 try: 6410 plumbing_response = self.stub.Get( 6411 req, 6412 metadata=self.parent.get_metadata( 6413 'RemoteIdentityGroups.Get', req), 6414 timeout=t) 6415 except Exception as e: 6416 if self.parent.shouldRetry(tries, e, deadline): 6417 tries += 1 6418 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6419 continue 6420 raise plumbing.convert_error_to_porcelain(e) from e 6421 break 6422 6423 resp = models.RemoteIdentityGroupGetResponse() 6424 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 6425 plumbing_response.meta) 6426 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6427 plumbing_response.rate_limit) 6428 resp.remote_identity_group = plumbing.convert_remote_identity_group_to_porcelain( 6429 plumbing_response.remote_identity_group) 6430 return resp 6431 6432 def list(self, filter, *args, timeout=None): 6433 ''' 6434 List gets a list of RemoteIdentityGroups matching a given set of criteria. 6435 ''' 6436 deadline = None if timeout is None else time.time() + timeout 6437 req = RemoteIdentityGroupListRequest() 6438 req.meta.CopyFrom(ListRequestMetadata()) 6439 if self.parent.page_limit > 0: 6440 req.meta.limit = self.parent.page_limit 6441 if self.parent.snapshot_datetime is not None: 6442 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6443 6444 req.filter = plumbing.quote_filter_args(filter, *args) 6445 6446 def generator(svc, req): 6447 tries = 0 6448 while True: 6449 t = None if deadline is None else deadline - time.time() 6450 try: 6451 plumbing_response = svc.stub.List( 6452 req, 6453 metadata=svc.parent.get_metadata( 6454 'RemoteIdentityGroups.List', req), 6455 timeout=t) 6456 except Exception as e: 6457 if self.parent.shouldRetry(tries, e, deadline): 6458 tries += 1 6459 time.sleep( 6460 self.parent.exponentialBackoff(tries, deadline)) 6461 continue 6462 raise plumbing.convert_error_to_porcelain(e) from e 6463 tries = 0 6464 for plumbing_item in plumbing_response.remote_identity_groups: 6465 yield plumbing.convert_remote_identity_group_to_porcelain( 6466 plumbing_item) 6467 if plumbing_response.meta.next_cursor == '': 6468 break 6469 req.meta.cursor = plumbing_response.meta.next_cursor 6470 6471 return generator(self, req) 6472 6473 6474class SnapshotRemoteIdentityGroups: 6475 ''' 6476 SnapshotRemoteIdentityGroups exposes the read only methods of the RemoteIdentityGroups 6477 service for historical queries. 6478 ''' 6479 def __init__(self, remote_identity_groups): 6480 self.remote_identity_groups = remote_identity_groups 6481 6482 def get(self, id, timeout=None): 6483 ''' 6484 Get reads one RemoteIdentityGroup by ID. 6485 ''' 6486 return self.remote_identity_groups.get(id, timeout=timeout) 6487 6488 def list(self, filter, *args, timeout=None): 6489 ''' 6490 List gets a list of RemoteIdentityGroups matching a given set of criteria. 6491 ''' 6492 return self.remote_identity_groups.list(filter, *args, timeout=timeout) 6493 6494 6495class RemoteIdentityGroupsHistory: 6496 ''' 6497 RemoteIdentityGroupsHistory records all changes to the state of a RemoteIdentityGroup. 6498 See `strongdm.models.RemoteIdentityGroupHistory`. 6499 ''' 6500 def __init__(self, channel, client): 6501 self.parent = client 6502 self.stub = RemoteIdentityGroupsHistoryStub(channel) 6503 6504 def list(self, filter, *args, timeout=None): 6505 ''' 6506 List gets a list of RemoteIdentityGroupHistory records matching a given set of criteria. 6507 ''' 6508 deadline = None if timeout is None else time.time() + timeout 6509 req = RemoteIdentityGroupHistoryListRequest() 6510 req.meta.CopyFrom(ListRequestMetadata()) 6511 if self.parent.page_limit > 0: 6512 req.meta.limit = self.parent.page_limit 6513 if self.parent.snapshot_datetime is not None: 6514 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6515 6516 req.filter = plumbing.quote_filter_args(filter, *args) 6517 6518 def generator(svc, req): 6519 tries = 0 6520 while True: 6521 t = None if deadline is None else deadline - time.time() 6522 try: 6523 plumbing_response = svc.stub.List( 6524 req, 6525 metadata=svc.parent.get_metadata( 6526 'RemoteIdentityGroupsHistory.List', req), 6527 timeout=t) 6528 except Exception as e: 6529 if self.parent.shouldRetry(tries, e, deadline): 6530 tries += 1 6531 time.sleep( 6532 self.parent.exponentialBackoff(tries, deadline)) 6533 continue 6534 raise plumbing.convert_error_to_porcelain(e) from e 6535 tries = 0 6536 for plumbing_item in plumbing_response.history: 6537 yield plumbing.convert_remote_identity_group_history_to_porcelain( 6538 plumbing_item) 6539 if plumbing_response.meta.next_cursor == '': 6540 break 6541 req.meta.cursor = plumbing_response.meta.next_cursor 6542 6543 return generator(self, req) 6544 6545 6546class Replays: 6547 ''' 6548 A Replay captures the data transferred over a long-running SSH, RDP, or Kubernetes interactive session 6549 (otherwise referred to as a query). The Replays service is read-only. 6550 See `strongdm.models.ReplayChunk`. 6551 ''' 6552 def __init__(self, channel, client): 6553 self.parent = client 6554 self.stub = ReplaysStub(channel) 6555 6556 def list(self, filter, *args, timeout=None): 6557 ''' 6558 List gets a list of ReplayChunks for the Query ID specified by the filter criteria. 6559 ''' 6560 deadline = None if timeout is None else time.time() + timeout 6561 req = ReplayListRequest() 6562 req.meta.CopyFrom(ListRequestMetadata()) 6563 if self.parent.page_limit > 0: 6564 req.meta.limit = self.parent.page_limit 6565 if self.parent.snapshot_datetime is not None: 6566 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6567 6568 req.filter = plumbing.quote_filter_args(filter, *args) 6569 6570 def generator(svc, req): 6571 tries = 0 6572 while True: 6573 t = None if deadline is None else deadline - time.time() 6574 try: 6575 plumbing_response = svc.stub.List( 6576 req, 6577 metadata=svc.parent.get_metadata('Replays.List', req), 6578 timeout=t) 6579 except Exception as e: 6580 if self.parent.shouldRetry(tries, e, deadline): 6581 tries += 1 6582 time.sleep( 6583 self.parent.exponentialBackoff(tries, deadline)) 6584 continue 6585 raise plumbing.convert_error_to_porcelain(e) from e 6586 tries = 0 6587 for plumbing_item in plumbing_response.chunks: 6588 yield plumbing.convert_replay_chunk_to_porcelain( 6589 plumbing_item) 6590 if plumbing_response.meta.next_cursor == '': 6591 break 6592 req.meta.cursor = plumbing_response.meta.next_cursor 6593 6594 return generator(self, req) 6595 6596 6597class Resources: 6598 ''' 6599 Resources are databases, servers, clusters, websites, or clouds that strongDM 6600 delegates access to. 6601 See: 6602 `strongdm.models.Aerospike` 6603 `strongdm.models.AKS` 6604 `strongdm.models.AKSBasicAuth` 6605 `strongdm.models.AKSServiceAccount` 6606 `strongdm.models.AKSServiceAccountUserImpersonation` 6607 `strongdm.models.AKSUserImpersonation` 6608 `strongdm.models.AmazonEKS` 6609 `strongdm.models.AmazonEKSInstanceProfile` 6610 `strongdm.models.AmazonEKSInstanceProfileUserImpersonation` 6611 `strongdm.models.AmazonEKSUserImpersonation` 6612 `strongdm.models.AmazonES` 6613 `strongdm.models.AmazonESIAM` 6614 `strongdm.models.AmazonMQAMQP091` 6615 `strongdm.models.AMQP` 6616 `strongdm.models.Athena` 6617 `strongdm.models.AthenaIAM` 6618 `strongdm.models.AuroraMysql` 6619 `strongdm.models.AuroraMysqlIAM` 6620 `strongdm.models.AuroraPostgres` 6621 `strongdm.models.AuroraPostgresIAM` 6622 `strongdm.models.AWS` 6623 `strongdm.models.AWSConsole` 6624 `strongdm.models.AWSConsoleStaticKeyPair` 6625 `strongdm.models.AWSInstanceProfile` 6626 `strongdm.models.Azure` 6627 `strongdm.models.AzureCertificate` 6628 `strongdm.models.AzureMysql` 6629 `strongdm.models.AzureMysqlManagedIdentity` 6630 `strongdm.models.AzurePostgres` 6631 `strongdm.models.AzurePostgresManagedIdentity` 6632 `strongdm.models.BigQuery` 6633 `strongdm.models.Cassandra` 6634 `strongdm.models.Citus` 6635 `strongdm.models.ClickHouseHTTP` 6636 `strongdm.models.ClickHouseMySQL` 6637 `strongdm.models.ClickHouseTCP` 6638 `strongdm.models.Clustrix` 6639 `strongdm.models.Cockroach` 6640 `strongdm.models.CouchbaseDatabase` 6641 `strongdm.models.CouchbaseWebUI` 6642 `strongdm.models.Databricks` 6643 `strongdm.models.DB2I` 6644 `strongdm.models.DB2LUW` 6645 `strongdm.models.DocumentDBHost` 6646 `strongdm.models.DocumentDBHostIAM` 6647 `strongdm.models.DocumentDBReplicaSet` 6648 `strongdm.models.DocumentDBReplicaSetIAM` 6649 `strongdm.models.Druid` 6650 `strongdm.models.DynamoDB` 6651 `strongdm.models.DynamoDBIAM` 6652 `strongdm.models.Elastic` 6653 `strongdm.models.ElasticacheRedis` 6654 `strongdm.models.ElasticacheRedisIAM` 6655 `strongdm.models.EntraID` 6656 `strongdm.models.GCP` 6657 `strongdm.models.GCPConsole` 6658 `strongdm.models.GCPWIF` 6659 `strongdm.models.GoogleGKE` 6660 `strongdm.models.GoogleGKEUserImpersonation` 6661 `strongdm.models.GoogleSpanner` 6662 `strongdm.models.Greenplum` 6663 `strongdm.models.HTTPAuth` 6664 `strongdm.models.HTTPBasicAuth` 6665 `strongdm.models.HTTPNoAuth` 6666 `strongdm.models.Kubernetes` 6667 `strongdm.models.KubernetesBasicAuth` 6668 `strongdm.models.KubernetesPodIdentity` 6669 `strongdm.models.KubernetesServiceAccount` 6670 `strongdm.models.KubernetesServiceAccountUserImpersonation` 6671 `strongdm.models.KubernetesUserImpersonation` 6672 `strongdm.models.Maria` 6673 `strongdm.models.MCP` 6674 `strongdm.models.MCPDCR` 6675 `strongdm.models.Memcached` 6676 `strongdm.models.Memsql` 6677 `strongdm.models.MongoHost` 6678 `strongdm.models.MongoLegacyHost` 6679 `strongdm.models.MongoLegacyReplicaset` 6680 `strongdm.models.MongoReplicaSet` 6681 `strongdm.models.MongoShardedCluster` 6682 `strongdm.models.MTLSMysql` 6683 `strongdm.models.MTLSPostgres` 6684 `strongdm.models.Mysql` 6685 `strongdm.models.Neptune` 6686 `strongdm.models.NeptuneIAM` 6687 `strongdm.models.OktaGroups` 6688 `strongdm.models.Oracle` 6689 `strongdm.models.OracleNNE` 6690 `strongdm.models.Postgres` 6691 `strongdm.models.Presto` 6692 `strongdm.models.RabbitMQAMQP091` 6693 `strongdm.models.RawTCP` 6694 `strongdm.models.RDP` 6695 `strongdm.models.RDPCert` 6696 `strongdm.models.RDSPostgresIAM` 6697 `strongdm.models.Redis` 6698 `strongdm.models.RedisCluster` 6699 `strongdm.models.Redshift` 6700 `strongdm.models.RedshiftIAM` 6701 `strongdm.models.RedshiftServerlessIAM` 6702 `strongdm.models.SingleStore` 6703 `strongdm.models.Snowflake` 6704 `strongdm.models.Snowsight` 6705 `strongdm.models.SQLServer` 6706 `strongdm.models.SQLServerAzureAD` 6707 `strongdm.models.SQLServerKerberosAD` 6708 `strongdm.models.SSH` 6709 `strongdm.models.SSHCert` 6710 `strongdm.models.SSHCustomerKey` 6711 `strongdm.models.SSHPassword` 6712 `strongdm.models.Sybase` 6713 `strongdm.models.SybaseIQ` 6714 `strongdm.models.Teradata` 6715 `strongdm.models.Trino` 6716 `strongdm.models.Vertica` 6717 ''' 6718 def __init__(self, channel, client): 6719 self.parent = client 6720 self.stub = ResourcesStub(channel) 6721 6722 def enumerate_tags(self, filter, *args, timeout=None): 6723 ''' 6724 EnumerateTags gets a list of the filter matching tags. 6725 ''' 6726 deadline = None if timeout is None else time.time() + timeout 6727 req = EnumerateTagsRequest() 6728 req.meta.CopyFrom(ListRequestMetadata()) 6729 if self.parent.page_limit > 0: 6730 req.meta.limit = self.parent.page_limit 6731 if self.parent.snapshot_datetime is not None: 6732 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6733 6734 req.filter = plumbing.quote_filter_args(filter, *args) 6735 6736 def generator(svc, req): 6737 tries = 0 6738 while True: 6739 t = None if deadline is None else deadline - time.time() 6740 try: 6741 plumbing_response = svc.stub.EnumerateTags( 6742 req, 6743 metadata=svc.parent.get_metadata( 6744 'Resources.EnumerateTags', req), 6745 timeout=t) 6746 except Exception as e: 6747 if self.parent.shouldRetry(tries, e, deadline): 6748 tries += 1 6749 time.sleep( 6750 self.parent.exponentialBackoff(tries, deadline)) 6751 continue 6752 raise plumbing.convert_error_to_porcelain(e) from e 6753 tries = 0 6754 for plumbing_item in plumbing_response.matches: 6755 yield plumbing.convert_tag_to_porcelain(plumbing_item) 6756 if plumbing_response.meta.next_cursor == '': 6757 break 6758 req.meta.cursor = plumbing_response.meta.next_cursor 6759 6760 return generator(self, req) 6761 6762 def create(self, resource, timeout=None): 6763 ''' 6764 Create registers a new Resource. 6765 ''' 6766 deadline = None if timeout is None else time.time() + timeout 6767 req = ResourceCreateRequest() 6768 6769 if resource is not None: 6770 req.resource.CopyFrom( 6771 plumbing.convert_resource_to_plumbing(resource)) 6772 tries = 0 6773 plumbing_response = None 6774 while True: 6775 t = None if deadline is None else deadline - time.time() 6776 try: 6777 plumbing_response = self.stub.Create( 6778 req, 6779 metadata=self.parent.get_metadata('Resources.Create', req), 6780 timeout=t) 6781 except Exception as e: 6782 if self.parent.shouldRetry(tries, e, deadline): 6783 tries += 1 6784 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6785 continue 6786 raise plumbing.convert_error_to_porcelain(e) from e 6787 break 6788 6789 resp = models.ResourceCreateResponse() 6790 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 6791 plumbing_response.meta) 6792 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6793 plumbing_response.rate_limit) 6794 resp.resource = plumbing.convert_resource_to_porcelain( 6795 plumbing_response.resource) 6796 return resp 6797 6798 def get(self, id, timeout=None): 6799 ''' 6800 Get reads one Resource by ID. 6801 ''' 6802 deadline = None if timeout is None else time.time() + timeout 6803 req = ResourceGetRequest() 6804 if self.parent.snapshot_datetime is not None: 6805 req.meta.CopyFrom(GetRequestMetadata()) 6806 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6807 6808 req.id = (id) 6809 tries = 0 6810 plumbing_response = None 6811 while True: 6812 t = None if deadline is None else deadline - time.time() 6813 try: 6814 plumbing_response = self.stub.Get( 6815 req, 6816 metadata=self.parent.get_metadata('Resources.Get', req), 6817 timeout=t) 6818 except Exception as e: 6819 if self.parent.shouldRetry(tries, e, deadline): 6820 tries += 1 6821 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6822 continue 6823 raise plumbing.convert_error_to_porcelain(e) from e 6824 break 6825 6826 resp = models.ResourceGetResponse() 6827 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 6828 plumbing_response.meta) 6829 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6830 plumbing_response.rate_limit) 6831 resp.resource = plumbing.convert_resource_to_porcelain( 6832 plumbing_response.resource) 6833 return resp 6834 6835 def update(self, resource, timeout=None): 6836 ''' 6837 Update replaces all the fields of a Resource by ID. 6838 ''' 6839 deadline = None if timeout is None else time.time() + timeout 6840 req = ResourceUpdateRequest() 6841 6842 if resource is not None: 6843 req.resource.CopyFrom( 6844 plumbing.convert_resource_to_plumbing(resource)) 6845 tries = 0 6846 plumbing_response = None 6847 while True: 6848 t = None if deadline is None else deadline - time.time() 6849 try: 6850 plumbing_response = self.stub.Update( 6851 req, 6852 metadata=self.parent.get_metadata('Resources.Update', req), 6853 timeout=t) 6854 except Exception as e: 6855 if self.parent.shouldRetry(tries, e, deadline): 6856 tries += 1 6857 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6858 continue 6859 raise plumbing.convert_error_to_porcelain(e) from e 6860 break 6861 6862 resp = models.ResourceUpdateResponse() 6863 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 6864 plumbing_response.meta) 6865 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6866 plumbing_response.rate_limit) 6867 resp.resource = plumbing.convert_resource_to_porcelain( 6868 plumbing_response.resource) 6869 return resp 6870 6871 def delete(self, id, timeout=None): 6872 ''' 6873 Delete removes a Resource by ID. 6874 ''' 6875 deadline = None if timeout is None else time.time() + timeout 6876 req = ResourceDeleteRequest() 6877 6878 req.id = (id) 6879 tries = 0 6880 plumbing_response = None 6881 while True: 6882 t = None if deadline is None else deadline - time.time() 6883 try: 6884 plumbing_response = self.stub.Delete( 6885 req, 6886 metadata=self.parent.get_metadata('Resources.Delete', req), 6887 timeout=t) 6888 except Exception as e: 6889 if self.parent.shouldRetry(tries, e, deadline): 6890 tries += 1 6891 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6892 continue 6893 raise plumbing.convert_error_to_porcelain(e) from e 6894 break 6895 6896 resp = models.ResourceDeleteResponse() 6897 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 6898 plumbing_response.meta) 6899 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6900 plumbing_response.rate_limit) 6901 return resp 6902 6903 def list(self, filter, *args, timeout=None): 6904 ''' 6905 List gets a list of Resources matching a given set of criteria. 6906 ''' 6907 deadline = None if timeout is None else time.time() + timeout 6908 req = ResourceListRequest() 6909 req.meta.CopyFrom(ListRequestMetadata()) 6910 if self.parent.page_limit > 0: 6911 req.meta.limit = self.parent.page_limit 6912 if self.parent.snapshot_datetime is not None: 6913 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6914 6915 req.filter = plumbing.quote_filter_args(filter, *args) 6916 6917 def generator(svc, req): 6918 tries = 0 6919 while True: 6920 t = None if deadline is None else deadline - time.time() 6921 try: 6922 plumbing_response = svc.stub.List( 6923 req, 6924 metadata=svc.parent.get_metadata( 6925 'Resources.List', req), 6926 timeout=t) 6927 except Exception as e: 6928 if self.parent.shouldRetry(tries, e, deadline): 6929 tries += 1 6930 time.sleep( 6931 self.parent.exponentialBackoff(tries, deadline)) 6932 continue 6933 raise plumbing.convert_error_to_porcelain(e) from e 6934 tries = 0 6935 for plumbing_item in plumbing_response.resources: 6936 yield plumbing.convert_resource_to_porcelain(plumbing_item) 6937 if plumbing_response.meta.next_cursor == '': 6938 break 6939 req.meta.cursor = plumbing_response.meta.next_cursor 6940 6941 return generator(self, req) 6942 6943 def healthcheck(self, id, timeout=None): 6944 ''' 6945 Healthcheck triggers a remote healthcheck. It may take minutes to propagate across a 6946 large network of Nodes. The call will return immediately, and the updated health of the 6947 Resource can be retrieved via Get or List. 6948 ''' 6949 deadline = None if timeout is None else time.time() + timeout 6950 req = ResourceHealthcheckRequest() 6951 6952 req.id = (id) 6953 tries = 0 6954 plumbing_response = None 6955 while True: 6956 t = None if deadline is None else deadline - time.time() 6957 try: 6958 plumbing_response = self.stub.Healthcheck( 6959 req, 6960 metadata=self.parent.get_metadata('Resources.Healthcheck', 6961 req), 6962 timeout=t) 6963 except Exception as e: 6964 if self.parent.shouldRetry(tries, e, deadline): 6965 tries += 1 6966 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6967 continue 6968 raise plumbing.convert_error_to_porcelain(e) from e 6969 break 6970 6971 resp = models.ResourceHealthcheckResponse() 6972 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 6973 plumbing_response.meta) 6974 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6975 plumbing_response.rate_limit) 6976 return resp 6977 6978 6979class SnapshotResources: 6980 ''' 6981 SnapshotResources exposes the read only methods of the Resources 6982 service for historical queries. 6983 ''' 6984 def __init__(self, resources): 6985 self.resources = resources 6986 6987 def get(self, id, timeout=None): 6988 ''' 6989 Get reads one Resource by ID. 6990 ''' 6991 return self.resources.get(id, timeout=timeout) 6992 6993 def list(self, filter, *args, timeout=None): 6994 ''' 6995 List gets a list of Resources matching a given set of criteria. 6996 ''' 6997 return self.resources.list(filter, *args, timeout=timeout) 6998 6999 7000class ResourcesHistory: 7001 ''' 7002 ResourcesHistory records all changes to the state of a Resource. 7003 See `strongdm.models.ResourceHistory`. 7004 ''' 7005 def __init__(self, channel, client): 7006 self.parent = client 7007 self.stub = ResourcesHistoryStub(channel) 7008 7009 def list(self, filter, *args, timeout=None): 7010 ''' 7011 List gets a list of ResourceHistory records matching a given set of criteria. 7012 ''' 7013 deadline = None if timeout is None else time.time() + timeout 7014 req = ResourceHistoryListRequest() 7015 req.meta.CopyFrom(ListRequestMetadata()) 7016 if self.parent.page_limit > 0: 7017 req.meta.limit = self.parent.page_limit 7018 if self.parent.snapshot_datetime is not None: 7019 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7020 7021 req.filter = plumbing.quote_filter_args(filter, *args) 7022 7023 def generator(svc, req): 7024 tries = 0 7025 while True: 7026 t = None if deadline is None else deadline - time.time() 7027 try: 7028 plumbing_response = svc.stub.List( 7029 req, 7030 metadata=svc.parent.get_metadata( 7031 'ResourcesHistory.List', req), 7032 timeout=t) 7033 except Exception as e: 7034 if self.parent.shouldRetry(tries, e, deadline): 7035 tries += 1 7036 time.sleep( 7037 self.parent.exponentialBackoff(tries, deadline)) 7038 continue 7039 raise plumbing.convert_error_to_porcelain(e) from e 7040 tries = 0 7041 for plumbing_item in plumbing_response.history: 7042 yield plumbing.convert_resource_history_to_porcelain( 7043 plumbing_item) 7044 if plumbing_response.meta.next_cursor == '': 7045 break 7046 req.meta.cursor = plumbing_response.meta.next_cursor 7047 7048 return generator(self, req) 7049 7050 7051class RoleResources: 7052 ''' 7053 RoleResources enumerates the resources to which roles have access. 7054 The RoleResources service is read-only. 7055 See `strongdm.models.RoleResource`. 7056 ''' 7057 def __init__(self, channel, client): 7058 self.parent = client 7059 self.stub = RoleResourcesStub(channel) 7060 7061 def list(self, filter, *args, timeout=None): 7062 ''' 7063 List gets a list of RoleResource records matching a given set of criteria. 7064 ''' 7065 deadline = None if timeout is None else time.time() + timeout 7066 req = RoleResourceListRequest() 7067 req.meta.CopyFrom(ListRequestMetadata()) 7068 if self.parent.page_limit > 0: 7069 req.meta.limit = self.parent.page_limit 7070 if self.parent.snapshot_datetime is not None: 7071 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7072 7073 req.filter = plumbing.quote_filter_args(filter, *args) 7074 7075 def generator(svc, req): 7076 tries = 0 7077 while True: 7078 t = None if deadline is None else deadline - time.time() 7079 try: 7080 plumbing_response = svc.stub.List( 7081 req, 7082 metadata=svc.parent.get_metadata( 7083 'RoleResources.List', req), 7084 timeout=t) 7085 except Exception as e: 7086 if self.parent.shouldRetry(tries, e, deadline): 7087 tries += 1 7088 time.sleep( 7089 self.parent.exponentialBackoff(tries, deadline)) 7090 continue 7091 raise plumbing.convert_error_to_porcelain(e) from e 7092 tries = 0 7093 for plumbing_item in plumbing_response.role_resources: 7094 yield plumbing.convert_role_resource_to_porcelain( 7095 plumbing_item) 7096 if plumbing_response.meta.next_cursor == '': 7097 break 7098 req.meta.cursor = plumbing_response.meta.next_cursor 7099 7100 return generator(self, req) 7101 7102 7103class SnapshotRoleResources: 7104 ''' 7105 SnapshotRoleResources exposes the read only methods of the RoleResources 7106 service for historical queries. 7107 ''' 7108 def __init__(self, role_resources): 7109 self.role_resources = role_resources 7110 7111 def list(self, filter, *args, timeout=None): 7112 ''' 7113 List gets a list of RoleResource records matching a given set of criteria. 7114 ''' 7115 return self.role_resources.list(filter, *args, timeout=timeout) 7116 7117 7118class RoleResourcesHistory: 7119 ''' 7120 RoleResourcesHistory records all changes to the state of a RoleResource. 7121 See `strongdm.models.RoleResourceHistory`. 7122 ''' 7123 def __init__(self, channel, client): 7124 self.parent = client 7125 self.stub = RoleResourcesHistoryStub(channel) 7126 7127 def list(self, filter, *args, timeout=None): 7128 ''' 7129 List gets a list of RoleResourceHistory records matching a given set of criteria. 7130 ''' 7131 deadline = None if timeout is None else time.time() + timeout 7132 req = RoleResourceHistoryListRequest() 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 'RoleResourcesHistory.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.history: 7160 yield plumbing.convert_role_resource_history_to_porcelain( 7161 plumbing_item) 7162 if plumbing_response.meta.next_cursor == '': 7163 break 7164 req.meta.cursor = plumbing_response.meta.next_cursor 7165 7166 return generator(self, req) 7167 7168 7169class RolesHistory: 7170 ''' 7171 RolesHistory records all changes to the state of a Role. 7172 See `strongdm.models.RoleHistory`. 7173 ''' 7174 def __init__(self, channel, client): 7175 self.parent = client 7176 self.stub = RolesHistoryStub(channel) 7177 7178 def list(self, filter, *args, timeout=None): 7179 ''' 7180 List gets a list of RoleHistory records matching a given set of criteria. 7181 ''' 7182 deadline = None if timeout is None else time.time() + timeout 7183 req = RoleHistoryListRequest() 7184 req.meta.CopyFrom(ListRequestMetadata()) 7185 if self.parent.page_limit > 0: 7186 req.meta.limit = self.parent.page_limit 7187 if self.parent.snapshot_datetime is not None: 7188 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7189 7190 req.filter = plumbing.quote_filter_args(filter, *args) 7191 7192 def generator(svc, req): 7193 tries = 0 7194 while True: 7195 t = None if deadline is None else deadline - time.time() 7196 try: 7197 plumbing_response = svc.stub.List( 7198 req, 7199 metadata=svc.parent.get_metadata( 7200 'RolesHistory.List', req), 7201 timeout=t) 7202 except Exception as e: 7203 if self.parent.shouldRetry(tries, e, deadline): 7204 tries += 1 7205 time.sleep( 7206 self.parent.exponentialBackoff(tries, deadline)) 7207 continue 7208 raise plumbing.convert_error_to_porcelain(e) from e 7209 tries = 0 7210 for plumbing_item in plumbing_response.history: 7211 yield plumbing.convert_role_history_to_porcelain( 7212 plumbing_item) 7213 if plumbing_response.meta.next_cursor == '': 7214 break 7215 req.meta.cursor = plumbing_response.meta.next_cursor 7216 7217 return generator(self, req) 7218 7219 7220class SecretStores: 7221 ''' 7222 SecretStores are servers where resource secrets (passwords, keys) are stored. 7223 See: 7224 `strongdm.models.ActiveDirectoryStore` 7225 `strongdm.models.AWSStore` 7226 `strongdm.models.AWSCertX509Store` 7227 `strongdm.models.AzureStore` 7228 `strongdm.models.CyberarkConjurStore` 7229 `strongdm.models.CyberarkPAMStore` 7230 `strongdm.models.CyberarkPAMExperimentalStore` 7231 `strongdm.models.DelineaStore` 7232 `strongdm.models.GCPStore` 7233 `strongdm.models.GCPCertX509Store` 7234 `strongdm.models.KeyfactorSSHStore` 7235 `strongdm.models.KeyfactorX509Store` 7236 `strongdm.models.StrongVaultStore` 7237 `strongdm.models.VaultAppRoleStore` 7238 `strongdm.models.VaultAppRoleCertSSHStore` 7239 `strongdm.models.VaultAppRoleCertX509Store` 7240 `strongdm.models.VaultAWSEC2Store` 7241 `strongdm.models.VaultAWSEC2CertSSHStore` 7242 `strongdm.models.VaultAWSEC2CertX509Store` 7243 `strongdm.models.VaultAWSIAMStore` 7244 `strongdm.models.VaultAWSIAMCertSSHStore` 7245 `strongdm.models.VaultAWSIAMCertX509Store` 7246 `strongdm.models.VaultTLSStore` 7247 `strongdm.models.VaultTLSCertSSHStore` 7248 `strongdm.models.VaultTLSCertX509Store` 7249 `strongdm.models.VaultTokenStore` 7250 `strongdm.models.VaultTokenCertSSHStore` 7251 `strongdm.models.VaultTokenCertX509Store` 7252 ''' 7253 def __init__(self, channel, client): 7254 self.parent = client 7255 self.stub = SecretStoresStub(channel) 7256 7257 def create(self, secret_store, timeout=None): 7258 deadline = None if timeout is None else time.time() + timeout 7259 req = SecretStoreCreateRequest() 7260 7261 if secret_store is not None: 7262 req.secret_store.CopyFrom( 7263 plumbing.convert_secret_store_to_plumbing(secret_store)) 7264 tries = 0 7265 plumbing_response = None 7266 while True: 7267 t = None if deadline is None else deadline - time.time() 7268 try: 7269 plumbing_response = self.stub.Create( 7270 req, 7271 metadata=self.parent.get_metadata('SecretStores.Create', 7272 req), 7273 timeout=t) 7274 except Exception as e: 7275 if self.parent.shouldRetry(tries, e, deadline): 7276 tries += 1 7277 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7278 continue 7279 raise plumbing.convert_error_to_porcelain(e) from e 7280 break 7281 7282 resp = models.SecretStoreCreateResponse() 7283 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 7284 plumbing_response.meta) 7285 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7286 plumbing_response.rate_limit) 7287 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 7288 plumbing_response.secret_store) 7289 return resp 7290 7291 def get(self, id, timeout=None): 7292 ''' 7293 Get reads one SecretStore by ID. 7294 ''' 7295 deadline = None if timeout is None else time.time() + timeout 7296 req = SecretStoreGetRequest() 7297 if self.parent.snapshot_datetime is not None: 7298 req.meta.CopyFrom(GetRequestMetadata()) 7299 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7300 7301 req.id = (id) 7302 tries = 0 7303 plumbing_response = None 7304 while True: 7305 t = None if deadline is None else deadline - time.time() 7306 try: 7307 plumbing_response = self.stub.Get( 7308 req, 7309 metadata=self.parent.get_metadata('SecretStores.Get', req), 7310 timeout=t) 7311 except Exception as e: 7312 if self.parent.shouldRetry(tries, e, deadline): 7313 tries += 1 7314 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7315 continue 7316 raise plumbing.convert_error_to_porcelain(e) from e 7317 break 7318 7319 resp = models.SecretStoreGetResponse() 7320 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 7321 plumbing_response.meta) 7322 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7323 plumbing_response.rate_limit) 7324 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 7325 plumbing_response.secret_store) 7326 return resp 7327 7328 def update(self, secret_store, timeout=None): 7329 ''' 7330 Update replaces all the fields of a SecretStore by ID. 7331 ''' 7332 deadline = None if timeout is None else time.time() + timeout 7333 req = SecretStoreUpdateRequest() 7334 7335 if secret_store is not None: 7336 req.secret_store.CopyFrom( 7337 plumbing.convert_secret_store_to_plumbing(secret_store)) 7338 tries = 0 7339 plumbing_response = None 7340 while True: 7341 t = None if deadline is None else deadline - time.time() 7342 try: 7343 plumbing_response = self.stub.Update( 7344 req, 7345 metadata=self.parent.get_metadata('SecretStores.Update', 7346 req), 7347 timeout=t) 7348 except Exception as e: 7349 if self.parent.shouldRetry(tries, e, deadline): 7350 tries += 1 7351 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7352 continue 7353 raise plumbing.convert_error_to_porcelain(e) from e 7354 break 7355 7356 resp = models.SecretStoreUpdateResponse() 7357 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 7358 plumbing_response.meta) 7359 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7360 plumbing_response.rate_limit) 7361 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 7362 plumbing_response.secret_store) 7363 return resp 7364 7365 def delete(self, id, timeout=None): 7366 ''' 7367 Delete removes a SecretStore by ID. 7368 ''' 7369 deadline = None if timeout is None else time.time() + timeout 7370 req = SecretStoreDeleteRequest() 7371 7372 req.id = (id) 7373 tries = 0 7374 plumbing_response = None 7375 while True: 7376 t = None if deadline is None else deadline - time.time() 7377 try: 7378 plumbing_response = self.stub.Delete( 7379 req, 7380 metadata=self.parent.get_metadata('SecretStores.Delete', 7381 req), 7382 timeout=t) 7383 except Exception as e: 7384 if self.parent.shouldRetry(tries, e, deadline): 7385 tries += 1 7386 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7387 continue 7388 raise plumbing.convert_error_to_porcelain(e) from e 7389 break 7390 7391 resp = models.SecretStoreDeleteResponse() 7392 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 7393 plumbing_response.meta) 7394 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7395 plumbing_response.rate_limit) 7396 return resp 7397 7398 def list(self, filter, *args, timeout=None): 7399 ''' 7400 List gets a list of SecretStores matching a given set of criteria. 7401 ''' 7402 deadline = None if timeout is None else time.time() + timeout 7403 req = SecretStoreListRequest() 7404 req.meta.CopyFrom(ListRequestMetadata()) 7405 if self.parent.page_limit > 0: 7406 req.meta.limit = self.parent.page_limit 7407 if self.parent.snapshot_datetime is not None: 7408 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7409 7410 req.filter = plumbing.quote_filter_args(filter, *args) 7411 7412 def generator(svc, req): 7413 tries = 0 7414 while True: 7415 t = None if deadline is None else deadline - time.time() 7416 try: 7417 plumbing_response = svc.stub.List( 7418 req, 7419 metadata=svc.parent.get_metadata( 7420 'SecretStores.List', req), 7421 timeout=t) 7422 except Exception as e: 7423 if self.parent.shouldRetry(tries, e, deadline): 7424 tries += 1 7425 time.sleep( 7426 self.parent.exponentialBackoff(tries, deadline)) 7427 continue 7428 raise plumbing.convert_error_to_porcelain(e) from e 7429 tries = 0 7430 for plumbing_item in plumbing_response.secret_stores: 7431 yield plumbing.convert_secret_store_to_porcelain( 7432 plumbing_item) 7433 if plumbing_response.meta.next_cursor == '': 7434 break 7435 req.meta.cursor = plumbing_response.meta.next_cursor 7436 7437 return generator(self, req) 7438 7439 7440class SnapshotSecretStores: 7441 ''' 7442 SnapshotSecretStores exposes the read only methods of the SecretStores 7443 service for historical queries. 7444 ''' 7445 def __init__(self, secret_stores): 7446 self.secret_stores = secret_stores 7447 7448 def get(self, id, timeout=None): 7449 ''' 7450 Get reads one SecretStore by ID. 7451 ''' 7452 return self.secret_stores.get(id, timeout=timeout) 7453 7454 def list(self, filter, *args, timeout=None): 7455 ''' 7456 List gets a list of SecretStores matching a given set of criteria. 7457 ''' 7458 return self.secret_stores.list(filter, *args, timeout=timeout) 7459 7460 7461class SecretEngines: 7462 ''' 7463 7464 See: 7465 `strongdm.models.ActiveDirectoryEngine` 7466 `strongdm.models.KeyValueEngine` 7467 `strongdm.models.MysqlEngine` 7468 `strongdm.models.PostgresEngine` 7469 `strongdm.models.SqlserverEngine` 7470 ''' 7471 def __init__(self, channel, client): 7472 self.parent = client 7473 self.stub = SecretEnginesStub(channel) 7474 7475 def list(self, filter, *args, timeout=None): 7476 ''' 7477 List returns a list of Secret Engines 7478 ''' 7479 deadline = None if timeout is None else time.time() + timeout 7480 req = SecretEngineListRequest() 7481 req.meta.CopyFrom(ListRequestMetadata()) 7482 if self.parent.page_limit > 0: 7483 req.meta.limit = self.parent.page_limit 7484 if self.parent.snapshot_datetime is not None: 7485 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7486 7487 req.filter = plumbing.quote_filter_args(filter, *args) 7488 7489 def generator(svc, req): 7490 tries = 0 7491 while True: 7492 t = None if deadline is None else deadline - time.time() 7493 try: 7494 plumbing_response = svc.stub.List( 7495 req, 7496 metadata=svc.parent.get_metadata( 7497 'SecretEngines.List', req), 7498 timeout=t) 7499 except Exception as e: 7500 if self.parent.shouldRetry(tries, e, deadline): 7501 tries += 1 7502 time.sleep( 7503 self.parent.exponentialBackoff(tries, deadline)) 7504 continue 7505 raise plumbing.convert_error_to_porcelain(e) from e 7506 tries = 0 7507 for plumbing_item in plumbing_response.secret_engines: 7508 yield plumbing.convert_secret_engine_to_porcelain( 7509 plumbing_item) 7510 if plumbing_response.meta.next_cursor == '': 7511 break 7512 req.meta.cursor = plumbing_response.meta.next_cursor 7513 7514 return generator(self, req) 7515 7516 def get(self, id, timeout=None): 7517 ''' 7518 Get returns a secret engine details 7519 ''' 7520 deadline = None if timeout is None else time.time() + timeout 7521 req = SecretEngineGetRequest() 7522 if self.parent.snapshot_datetime is not None: 7523 req.meta.CopyFrom(GetRequestMetadata()) 7524 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7525 7526 req.id = (id) 7527 tries = 0 7528 plumbing_response = None 7529 while True: 7530 t = None if deadline is None else deadline - time.time() 7531 try: 7532 plumbing_response = self.stub.Get( 7533 req, 7534 metadata=self.parent.get_metadata('SecretEngines.Get', 7535 req), 7536 timeout=t) 7537 except Exception as e: 7538 if self.parent.shouldRetry(tries, e, deadline): 7539 tries += 1 7540 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7541 continue 7542 raise plumbing.convert_error_to_porcelain(e) from e 7543 break 7544 7545 resp = models.SecretEngineGetResponse() 7546 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 7547 plumbing_response.meta) 7548 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7549 plumbing_response.rate_limit) 7550 resp.secret_engine = plumbing.convert_secret_engine_to_porcelain( 7551 plumbing_response.secret_engine) 7552 return resp 7553 7554 def create(self, secret_engine, timeout=None): 7555 ''' 7556 Create creates a secret engine 7557 ''' 7558 deadline = None if timeout is None else time.time() + timeout 7559 req = SecretEngineCreateRequest() 7560 7561 if secret_engine is not None: 7562 req.secret_engine.CopyFrom( 7563 plumbing.convert_secret_engine_to_plumbing(secret_engine)) 7564 tries = 0 7565 plumbing_response = None 7566 while True: 7567 t = None if deadline is None else deadline - time.time() 7568 try: 7569 plumbing_response = self.stub.Create( 7570 req, 7571 metadata=self.parent.get_metadata('SecretEngines.Create', 7572 req), 7573 timeout=t) 7574 except Exception as e: 7575 if self.parent.shouldRetry(tries, e, deadline): 7576 tries += 1 7577 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7578 continue 7579 raise plumbing.convert_error_to_porcelain(e) from e 7580 break 7581 7582 resp = models.SecretEngineCreateResponse() 7583 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 7584 plumbing_response.meta) 7585 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7586 plumbing_response.rate_limit) 7587 resp.secret_engine = plumbing.convert_secret_engine_to_porcelain( 7588 plumbing_response.secret_engine) 7589 return resp 7590 7591 def update(self, secret_engine, timeout=None): 7592 ''' 7593 Update updates a secret engine 7594 ''' 7595 deadline = None if timeout is None else time.time() + timeout 7596 req = SecretEngineUpdateRequest() 7597 7598 if secret_engine is not None: 7599 req.secret_engine.CopyFrom( 7600 plumbing.convert_secret_engine_to_plumbing(secret_engine)) 7601 tries = 0 7602 plumbing_response = None 7603 while True: 7604 t = None if deadline is None else deadline - time.time() 7605 try: 7606 plumbing_response = self.stub.Update( 7607 req, 7608 metadata=self.parent.get_metadata('SecretEngines.Update', 7609 req), 7610 timeout=t) 7611 except Exception as e: 7612 if self.parent.shouldRetry(tries, e, deadline): 7613 tries += 1 7614 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7615 continue 7616 raise plumbing.convert_error_to_porcelain(e) from e 7617 break 7618 7619 resp = models.SecretEngineUpdateResponse() 7620 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 7621 plumbing_response.meta) 7622 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7623 plumbing_response.rate_limit) 7624 resp.secret_engine = plumbing.convert_secret_engine_to_porcelain( 7625 plumbing_response.secret_engine) 7626 return resp 7627 7628 def delete(self, id, timeout=None): 7629 ''' 7630 Delete deletes a secret engine 7631 ''' 7632 deadline = None if timeout is None else time.time() + timeout 7633 req = SecretEngineDeleteRequest() 7634 7635 req.id = (id) 7636 tries = 0 7637 plumbing_response = None 7638 while True: 7639 t = None if deadline is None else deadline - time.time() 7640 try: 7641 plumbing_response = self.stub.Delete( 7642 req, 7643 metadata=self.parent.get_metadata('SecretEngines.Delete', 7644 req), 7645 timeout=t) 7646 except Exception as e: 7647 if self.parent.shouldRetry(tries, e, deadline): 7648 tries += 1 7649 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7650 continue 7651 raise plumbing.convert_error_to_porcelain(e) from e 7652 break 7653 7654 resp = models.SecretEngineDeleteResponse() 7655 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7656 plumbing_response.rate_limit) 7657 return resp 7658 7659 def list_secret_stores(self, filter, *args, timeout=None): 7660 ''' 7661 ListSecretStores returns a list of Secret Stores that can be used as a backing store 7662 for Secret Engine 7663 ''' 7664 deadline = None if timeout is None else time.time() + timeout 7665 req = SecretStoreListRequest() 7666 req.meta.CopyFrom(ListRequestMetadata()) 7667 if self.parent.page_limit > 0: 7668 req.meta.limit = self.parent.page_limit 7669 if self.parent.snapshot_datetime is not None: 7670 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7671 7672 req.filter = plumbing.quote_filter_args(filter, *args) 7673 7674 def generator(svc, req): 7675 tries = 0 7676 while True: 7677 t = None if deadline is None else deadline - time.time() 7678 try: 7679 plumbing_response = svc.stub.ListSecretStores( 7680 req, 7681 metadata=svc.parent.get_metadata( 7682 'SecretEngines.ListSecretStores', req), 7683 timeout=t) 7684 except Exception as e: 7685 if self.parent.shouldRetry(tries, e, deadline): 7686 tries += 1 7687 time.sleep( 7688 self.parent.exponentialBackoff(tries, deadline)) 7689 continue 7690 raise plumbing.convert_error_to_porcelain(e) from e 7691 tries = 0 7692 for plumbing_item in plumbing_response.secret_stores: 7693 yield plumbing.convert_secret_store_to_porcelain( 7694 plumbing_item) 7695 if plumbing_response.meta.next_cursor == '': 7696 break 7697 req.meta.cursor = plumbing_response.meta.next_cursor 7698 7699 return generator(self, req) 7700 7701 def generate_keys(self, secret_engine_id, timeout=None): 7702 ''' 7703 GenerateKeys generates a private key, stores it in a secret store and stores a public key in a secret engine 7704 ''' 7705 deadline = None if timeout is None else time.time() + timeout 7706 req = GenerateKeysRequest() 7707 7708 req.secret_engine_id = (secret_engine_id) 7709 tries = 0 7710 plumbing_response = None 7711 while True: 7712 t = None if deadline is None else deadline - time.time() 7713 try: 7714 plumbing_response = self.stub.GenerateKeys( 7715 req, 7716 metadata=self.parent.get_metadata( 7717 'SecretEngines.GenerateKeys', req), 7718 timeout=t) 7719 except Exception as e: 7720 if self.parent.shouldRetry(tries, e, deadline): 7721 tries += 1 7722 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7723 continue 7724 raise plumbing.convert_error_to_porcelain(e) from e 7725 break 7726 7727 resp = models.GenerateKeysResponse() 7728 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7729 plumbing_response.rate_limit) 7730 return resp 7731 7732 def healthcheck(self, secret_engine_id, timeout=None): 7733 ''' 7734 Healthcheck triggers a healthcheck for all nodes serving a secret engine 7735 ''' 7736 deadline = None if timeout is None else time.time() + timeout 7737 req = HealthcheckRequest() 7738 7739 req.secret_engine_id = (secret_engine_id) 7740 tries = 0 7741 plumbing_response = None 7742 while True: 7743 t = None if deadline is None else deadline - time.time() 7744 try: 7745 plumbing_response = self.stub.Healthcheck( 7746 req, 7747 metadata=self.parent.get_metadata( 7748 'SecretEngines.Healthcheck', req), 7749 timeout=t) 7750 except Exception as e: 7751 if self.parent.shouldRetry(tries, e, deadline): 7752 tries += 1 7753 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7754 continue 7755 raise plumbing.convert_error_to_porcelain(e) from e 7756 break 7757 7758 resp = models.HealthcheckResponse() 7759 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7760 plumbing_response.rate_limit) 7761 resp.status = plumbing.convert_repeated_healthcheck_status_to_porcelain( 7762 plumbing_response.status) 7763 return resp 7764 7765 def rotate(self, id, password_policy, timeout=None): 7766 ''' 7767 Rotate rotates secret engine's credentials 7768 ''' 7769 deadline = None if timeout is None else time.time() + timeout 7770 req = SecretEngineRotateRequest() 7771 7772 req.id = (id) 7773 if password_policy is not None: 7774 req.password_policy.CopyFrom( 7775 plumbing.convert_secret_engine_password_policy_to_plumbing( 7776 password_policy)) 7777 tries = 0 7778 plumbing_response = None 7779 while True: 7780 t = None if deadline is None else deadline - time.time() 7781 try: 7782 plumbing_response = self.stub.Rotate( 7783 req, 7784 metadata=self.parent.get_metadata('SecretEngines.Rotate', 7785 req), 7786 timeout=t) 7787 except Exception as e: 7788 if self.parent.shouldRetry(tries, e, deadline): 7789 tries += 1 7790 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7791 continue 7792 raise plumbing.convert_error_to_porcelain(e) from e 7793 break 7794 7795 resp = models.SecretEngineRotateResponse() 7796 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7797 plumbing_response.rate_limit) 7798 return resp 7799 7800 7801class SecretStoreHealths: 7802 ''' 7803 SecretStoreHealths exposes health states for secret stores. 7804 See `strongdm.models.SecretStoreHealth`. 7805 ''' 7806 def __init__(self, channel, client): 7807 self.parent = client 7808 self.stub = SecretStoreHealthsStub(channel) 7809 7810 def list(self, filter, *args, timeout=None): 7811 ''' 7812 List reports the health status of node to secret store pairs. 7813 ''' 7814 deadline = None if timeout is None else time.time() + timeout 7815 req = SecretStoreHealthListRequest() 7816 req.meta.CopyFrom(ListRequestMetadata()) 7817 if self.parent.page_limit > 0: 7818 req.meta.limit = self.parent.page_limit 7819 if self.parent.snapshot_datetime is not None: 7820 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7821 7822 req.filter = plumbing.quote_filter_args(filter, *args) 7823 7824 def generator(svc, req): 7825 tries = 0 7826 while True: 7827 t = None if deadline is None else deadline - time.time() 7828 try: 7829 plumbing_response = svc.stub.List( 7830 req, 7831 metadata=svc.parent.get_metadata( 7832 'SecretStoreHealths.List', req), 7833 timeout=t) 7834 except Exception as e: 7835 if self.parent.shouldRetry(tries, e, deadline): 7836 tries += 1 7837 time.sleep( 7838 self.parent.exponentialBackoff(tries, deadline)) 7839 continue 7840 raise plumbing.convert_error_to_porcelain(e) from e 7841 tries = 0 7842 for plumbing_item in plumbing_response.secret_store_healths: 7843 yield plumbing.convert_secret_store_health_to_porcelain( 7844 plumbing_item) 7845 if plumbing_response.meta.next_cursor == '': 7846 break 7847 req.meta.cursor = plumbing_response.meta.next_cursor 7848 7849 return generator(self, req) 7850 7851 def healthcheck(self, secret_store_id, timeout=None): 7852 ''' 7853 Healthcheck triggers a remote healthcheck request for a secret store. It may take minutes 7854 to propagate across a large network of Nodes. The call will return immediately, and the 7855 updated health of the Secret Store can be retrieved via List. 7856 ''' 7857 deadline = None if timeout is None else time.time() + timeout 7858 req = SecretStoreHealthcheckRequest() 7859 7860 req.secret_store_id = (secret_store_id) 7861 tries = 0 7862 plumbing_response = None 7863 while True: 7864 t = None if deadline is None else deadline - time.time() 7865 try: 7866 plumbing_response = self.stub.Healthcheck( 7867 req, 7868 metadata=self.parent.get_metadata( 7869 'SecretStoreHealths.Healthcheck', req), 7870 timeout=t) 7871 except Exception as e: 7872 if self.parent.shouldRetry(tries, e, deadline): 7873 tries += 1 7874 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7875 continue 7876 raise plumbing.convert_error_to_porcelain(e) from e 7877 break 7878 7879 resp = models.SecretStoreHealthcheckResponse() 7880 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7881 plumbing_response.rate_limit) 7882 return resp 7883 7884 7885class SecretStoresHistory: 7886 ''' 7887 SecretStoresHistory records all changes to the state of a SecretStore. 7888 See `strongdm.models.SecretStoreHistory`. 7889 ''' 7890 def __init__(self, channel, client): 7891 self.parent = client 7892 self.stub = SecretStoresHistoryStub(channel) 7893 7894 def list(self, filter, *args, timeout=None): 7895 ''' 7896 List gets a list of SecretStoreHistory records matching a given set of criteria. 7897 ''' 7898 deadline = None if timeout is None else time.time() + timeout 7899 req = SecretStoreHistoryListRequest() 7900 req.meta.CopyFrom(ListRequestMetadata()) 7901 if self.parent.page_limit > 0: 7902 req.meta.limit = self.parent.page_limit 7903 if self.parent.snapshot_datetime is not None: 7904 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7905 7906 req.filter = plumbing.quote_filter_args(filter, *args) 7907 7908 def generator(svc, req): 7909 tries = 0 7910 while True: 7911 t = None if deadline is None else deadline - time.time() 7912 try: 7913 plumbing_response = svc.stub.List( 7914 req, 7915 metadata=svc.parent.get_metadata( 7916 'SecretStoresHistory.List', req), 7917 timeout=t) 7918 except Exception as e: 7919 if self.parent.shouldRetry(tries, e, deadline): 7920 tries += 1 7921 time.sleep( 7922 self.parent.exponentialBackoff(tries, deadline)) 7923 continue 7924 raise plumbing.convert_error_to_porcelain(e) from e 7925 tries = 0 7926 for plumbing_item in plumbing_response.history: 7927 yield plumbing.convert_secret_store_history_to_porcelain( 7928 plumbing_item) 7929 if plumbing_response.meta.next_cursor == '': 7930 break 7931 req.meta.cursor = plumbing_response.meta.next_cursor 7932 7933 return generator(self, req) 7934 7935 7936class WorkflowApprovers: 7937 ''' 7938 WorkflowApprovers is an account or a role with the ability to approve requests bound to a workflow. 7939 See `strongdm.models.WorkflowApprover`. 7940 ''' 7941 def __init__(self, channel, client): 7942 self.parent = client 7943 self.stub = WorkflowApproversStub(channel) 7944 7945 def create(self, workflow_approver, timeout=None): 7946 ''' 7947 Create creates a new workflow approver 7948 ''' 7949 deadline = None if timeout is None else time.time() + timeout 7950 req = WorkflowApproversCreateRequest() 7951 7952 if workflow_approver is not None: 7953 req.workflow_approver.CopyFrom( 7954 plumbing.convert_workflow_approver_to_plumbing( 7955 workflow_approver)) 7956 tries = 0 7957 plumbing_response = None 7958 while True: 7959 t = None if deadline is None else deadline - time.time() 7960 try: 7961 plumbing_response = self.stub.Create( 7962 req, 7963 metadata=self.parent.get_metadata( 7964 'WorkflowApprovers.Create', req), 7965 timeout=t) 7966 except Exception as e: 7967 if self.parent.shouldRetry(tries, e, deadline): 7968 tries += 1 7969 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7970 continue 7971 raise plumbing.convert_error_to_porcelain(e) from e 7972 break 7973 7974 resp = models.WorkflowApproversCreateResponse() 7975 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7976 plumbing_response.rate_limit) 7977 resp.workflow_approver = plumbing.convert_workflow_approver_to_porcelain( 7978 plumbing_response.workflow_approver) 7979 return resp 7980 7981 def get(self, id, timeout=None): 7982 ''' 7983 Get reads one workflow approver by ID. 7984 ''' 7985 deadline = None if timeout is None else time.time() + timeout 7986 req = WorkflowApproverGetRequest() 7987 if self.parent.snapshot_datetime is not None: 7988 req.meta.CopyFrom(GetRequestMetadata()) 7989 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7990 7991 req.id = (id) 7992 tries = 0 7993 plumbing_response = None 7994 while True: 7995 t = None if deadline is None else deadline - time.time() 7996 try: 7997 plumbing_response = self.stub.Get( 7998 req, 7999 metadata=self.parent.get_metadata('WorkflowApprovers.Get', 8000 req), 8001 timeout=t) 8002 except Exception as e: 8003 if self.parent.shouldRetry(tries, e, deadline): 8004 tries += 1 8005 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8006 continue 8007 raise plumbing.convert_error_to_porcelain(e) from e 8008 break 8009 8010 resp = models.WorkflowApproverGetResponse() 8011 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 8012 plumbing_response.meta) 8013 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8014 plumbing_response.rate_limit) 8015 resp.workflow_approver = plumbing.convert_workflow_approver_to_porcelain( 8016 plumbing_response.workflow_approver) 8017 return resp 8018 8019 def delete(self, id, timeout=None): 8020 ''' 8021 Delete deletes a workflow approver 8022 ''' 8023 deadline = None if timeout is None else time.time() + timeout 8024 req = WorkflowApproversDeleteRequest() 8025 8026 req.id = (id) 8027 tries = 0 8028 plumbing_response = None 8029 while True: 8030 t = None if deadline is None else deadline - time.time() 8031 try: 8032 plumbing_response = self.stub.Delete( 8033 req, 8034 metadata=self.parent.get_metadata( 8035 'WorkflowApprovers.Delete', req), 8036 timeout=t) 8037 except Exception as e: 8038 if self.parent.shouldRetry(tries, e, deadline): 8039 tries += 1 8040 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8041 continue 8042 raise plumbing.convert_error_to_porcelain(e) from e 8043 break 8044 8045 resp = models.WorkflowApproversDeleteResponse() 8046 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8047 plumbing_response.rate_limit) 8048 return resp 8049 8050 def list(self, filter, *args, timeout=None): 8051 ''' 8052 Lists existing workflow approvers. 8053 ''' 8054 deadline = None if timeout is None else time.time() + timeout 8055 req = WorkflowApproversListRequest() 8056 req.meta.CopyFrom(ListRequestMetadata()) 8057 if self.parent.page_limit > 0: 8058 req.meta.limit = self.parent.page_limit 8059 if self.parent.snapshot_datetime is not None: 8060 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8061 8062 req.filter = plumbing.quote_filter_args(filter, *args) 8063 8064 def generator(svc, req): 8065 tries = 0 8066 while True: 8067 t = None if deadline is None else deadline - time.time() 8068 try: 8069 plumbing_response = svc.stub.List( 8070 req, 8071 metadata=svc.parent.get_metadata( 8072 'WorkflowApprovers.List', req), 8073 timeout=t) 8074 except Exception as e: 8075 if self.parent.shouldRetry(tries, e, deadline): 8076 tries += 1 8077 time.sleep( 8078 self.parent.exponentialBackoff(tries, deadline)) 8079 continue 8080 raise plumbing.convert_error_to_porcelain(e) from e 8081 tries = 0 8082 for plumbing_item in plumbing_response.workflow_approvers: 8083 yield plumbing.convert_workflow_approver_to_porcelain( 8084 plumbing_item) 8085 if plumbing_response.meta.next_cursor == '': 8086 break 8087 req.meta.cursor = plumbing_response.meta.next_cursor 8088 8089 return generator(self, req) 8090 8091 8092class SnapshotWorkflowApprovers: 8093 ''' 8094 SnapshotWorkflowApprovers exposes the read only methods of the WorkflowApprovers 8095 service for historical queries. 8096 ''' 8097 def __init__(self, workflow_approvers): 8098 self.workflow_approvers = workflow_approvers 8099 8100 def get(self, id, timeout=None): 8101 ''' 8102 Get reads one workflow approver by ID. 8103 ''' 8104 return self.workflow_approvers.get(id, timeout=timeout) 8105 8106 def list(self, filter, *args, timeout=None): 8107 ''' 8108 Lists existing workflow approvers. 8109 ''' 8110 return self.workflow_approvers.list(filter, *args, timeout=timeout) 8111 8112 8113class WorkflowApproversHistory: 8114 ''' 8115 WorkflowApproversHistory provides records of all changes to the state of a WorkflowApprover. 8116 See `strongdm.models.WorkflowApproverHistory`. 8117 ''' 8118 def __init__(self, channel, client): 8119 self.parent = client 8120 self.stub = WorkflowApproversHistoryStub(channel) 8121 8122 def list(self, filter, *args, timeout=None): 8123 ''' 8124 List gets a list of WorkflowApproversHistory records matching a given set of criteria. 8125 ''' 8126 deadline = None if timeout is None else time.time() + timeout 8127 req = WorkflowApproversHistoryListRequest() 8128 req.meta.CopyFrom(ListRequestMetadata()) 8129 if self.parent.page_limit > 0: 8130 req.meta.limit = self.parent.page_limit 8131 if self.parent.snapshot_datetime is not None: 8132 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8133 8134 req.filter = plumbing.quote_filter_args(filter, *args) 8135 8136 def generator(svc, req): 8137 tries = 0 8138 while True: 8139 t = None if deadline is None else deadline - time.time() 8140 try: 8141 plumbing_response = svc.stub.List( 8142 req, 8143 metadata=svc.parent.get_metadata( 8144 'WorkflowApproversHistory.List', req), 8145 timeout=t) 8146 except Exception as e: 8147 if self.parent.shouldRetry(tries, e, deadline): 8148 tries += 1 8149 time.sleep( 8150 self.parent.exponentialBackoff(tries, deadline)) 8151 continue 8152 raise plumbing.convert_error_to_porcelain(e) from e 8153 tries = 0 8154 for plumbing_item in plumbing_response.history: 8155 yield plumbing.convert_workflow_approver_history_to_porcelain( 8156 plumbing_item) 8157 if plumbing_response.meta.next_cursor == '': 8158 break 8159 req.meta.cursor = plumbing_response.meta.next_cursor 8160 8161 return generator(self, req) 8162 8163 8164class WorkflowRoles: 8165 ''' 8166 WorkflowRole links a role to a workflow. The linked roles indicate which roles a user must be a part of 8167 to request access to a resource via the workflow. 8168 See `strongdm.models.WorkflowRole`. 8169 ''' 8170 def __init__(self, channel, client): 8171 self.parent = client 8172 self.stub = WorkflowRolesStub(channel) 8173 8174 def create(self, workflow_role, timeout=None): 8175 ''' 8176 Create creates a new workflow role 8177 ''' 8178 deadline = None if timeout is None else time.time() + timeout 8179 req = WorkflowRolesCreateRequest() 8180 8181 if workflow_role is not None: 8182 req.workflow_role.CopyFrom( 8183 plumbing.convert_workflow_role_to_plumbing(workflow_role)) 8184 tries = 0 8185 plumbing_response = None 8186 while True: 8187 t = None if deadline is None else deadline - time.time() 8188 try: 8189 plumbing_response = self.stub.Create( 8190 req, 8191 metadata=self.parent.get_metadata('WorkflowRoles.Create', 8192 req), 8193 timeout=t) 8194 except Exception as e: 8195 if self.parent.shouldRetry(tries, e, deadline): 8196 tries += 1 8197 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8198 continue 8199 raise plumbing.convert_error_to_porcelain(e) from e 8200 break 8201 8202 resp = models.WorkflowRolesCreateResponse() 8203 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8204 plumbing_response.rate_limit) 8205 resp.workflow_role = plumbing.convert_workflow_role_to_porcelain( 8206 plumbing_response.workflow_role) 8207 return resp 8208 8209 def get(self, id, timeout=None): 8210 ''' 8211 Get reads one workflow role by ID. 8212 ''' 8213 deadline = None if timeout is None else time.time() + timeout 8214 req = WorkflowRoleGetRequest() 8215 if self.parent.snapshot_datetime is not None: 8216 req.meta.CopyFrom(GetRequestMetadata()) 8217 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8218 8219 req.id = (id) 8220 tries = 0 8221 plumbing_response = None 8222 while True: 8223 t = None if deadline is None else deadline - time.time() 8224 try: 8225 plumbing_response = self.stub.Get( 8226 req, 8227 metadata=self.parent.get_metadata('WorkflowRoles.Get', 8228 req), 8229 timeout=t) 8230 except Exception as e: 8231 if self.parent.shouldRetry(tries, e, deadline): 8232 tries += 1 8233 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8234 continue 8235 raise plumbing.convert_error_to_porcelain(e) from e 8236 break 8237 8238 resp = models.WorkflowRoleGetResponse() 8239 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 8240 plumbing_response.meta) 8241 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8242 plumbing_response.rate_limit) 8243 resp.workflow_role = plumbing.convert_workflow_role_to_porcelain( 8244 plumbing_response.workflow_role) 8245 return resp 8246 8247 def delete(self, id, timeout=None): 8248 ''' 8249 Delete deletes a workflow role 8250 ''' 8251 deadline = None if timeout is None else time.time() + timeout 8252 req = WorkflowRolesDeleteRequest() 8253 8254 req.id = (id) 8255 tries = 0 8256 plumbing_response = None 8257 while True: 8258 t = None if deadline is None else deadline - time.time() 8259 try: 8260 plumbing_response = self.stub.Delete( 8261 req, 8262 metadata=self.parent.get_metadata('WorkflowRoles.Delete', 8263 req), 8264 timeout=t) 8265 except Exception as e: 8266 if self.parent.shouldRetry(tries, e, deadline): 8267 tries += 1 8268 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8269 continue 8270 raise plumbing.convert_error_to_porcelain(e) from e 8271 break 8272 8273 resp = models.WorkflowRolesDeleteResponse() 8274 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8275 plumbing_response.rate_limit) 8276 return resp 8277 8278 def list(self, filter, *args, timeout=None): 8279 ''' 8280 Lists existing workflow roles. 8281 ''' 8282 deadline = None if timeout is None else time.time() + timeout 8283 req = WorkflowRolesListRequest() 8284 req.meta.CopyFrom(ListRequestMetadata()) 8285 if self.parent.page_limit > 0: 8286 req.meta.limit = self.parent.page_limit 8287 if self.parent.snapshot_datetime is not None: 8288 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8289 8290 req.filter = plumbing.quote_filter_args(filter, *args) 8291 8292 def generator(svc, req): 8293 tries = 0 8294 while True: 8295 t = None if deadline is None else deadline - time.time() 8296 try: 8297 plumbing_response = svc.stub.List( 8298 req, 8299 metadata=svc.parent.get_metadata( 8300 'WorkflowRoles.List', req), 8301 timeout=t) 8302 except Exception as e: 8303 if self.parent.shouldRetry(tries, e, deadline): 8304 tries += 1 8305 time.sleep( 8306 self.parent.exponentialBackoff(tries, deadline)) 8307 continue 8308 raise plumbing.convert_error_to_porcelain(e) from e 8309 tries = 0 8310 for plumbing_item in plumbing_response.workflow_role: 8311 yield plumbing.convert_workflow_role_to_porcelain( 8312 plumbing_item) 8313 if plumbing_response.meta.next_cursor == '': 8314 break 8315 req.meta.cursor = plumbing_response.meta.next_cursor 8316 8317 return generator(self, req) 8318 8319 8320class SnapshotWorkflowRoles: 8321 ''' 8322 SnapshotWorkflowRoles exposes the read only methods of the WorkflowRoles 8323 service for historical queries. 8324 ''' 8325 def __init__(self, workflow_roles): 8326 self.workflow_roles = workflow_roles 8327 8328 def get(self, id, timeout=None): 8329 ''' 8330 Get reads one workflow role by ID. 8331 ''' 8332 return self.workflow_roles.get(id, timeout=timeout) 8333 8334 def list(self, filter, *args, timeout=None): 8335 ''' 8336 Lists existing workflow roles. 8337 ''' 8338 return self.workflow_roles.list(filter, *args, timeout=timeout) 8339 8340 8341class WorkflowRolesHistory: 8342 ''' 8343 WorkflowRolesHistory provides records of all changes to the state of a WorkflowRole 8344 See `strongdm.models.WorkflowRoleHistory`. 8345 ''' 8346 def __init__(self, channel, client): 8347 self.parent = client 8348 self.stub = WorkflowRolesHistoryStub(channel) 8349 8350 def list(self, filter, *args, timeout=None): 8351 ''' 8352 List gets a list of WorkflowRolesHistory records matching a given set of criteria. 8353 ''' 8354 deadline = None if timeout is None else time.time() + timeout 8355 req = WorkflowRolesHistoryListRequest() 8356 req.meta.CopyFrom(ListRequestMetadata()) 8357 if self.parent.page_limit > 0: 8358 req.meta.limit = self.parent.page_limit 8359 if self.parent.snapshot_datetime is not None: 8360 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8361 8362 req.filter = plumbing.quote_filter_args(filter, *args) 8363 8364 def generator(svc, req): 8365 tries = 0 8366 while True: 8367 t = None if deadline is None else deadline - time.time() 8368 try: 8369 plumbing_response = svc.stub.List( 8370 req, 8371 metadata=svc.parent.get_metadata( 8372 'WorkflowRolesHistory.List', req), 8373 timeout=t) 8374 except Exception as e: 8375 if self.parent.shouldRetry(tries, e, deadline): 8376 tries += 1 8377 time.sleep( 8378 self.parent.exponentialBackoff(tries, deadline)) 8379 continue 8380 raise plumbing.convert_error_to_porcelain(e) from e 8381 tries = 0 8382 for plumbing_item in plumbing_response.history: 8383 yield plumbing.convert_workflow_role_history_to_porcelain( 8384 plumbing_item) 8385 if plumbing_response.meta.next_cursor == '': 8386 break 8387 req.meta.cursor = plumbing_response.meta.next_cursor 8388 8389 return generator(self, req) 8390 8391 8392class Workflows: 8393 ''' 8394 Workflows are the collection of rules that define the resources to which access can be requested, 8395 the users that can request that access, and the mechanism for approving those requests which can either 8396 be automatic approval or a set of users authorized to approve the requests. 8397 See `strongdm.models.Workflow`. 8398 ''' 8399 def __init__(self, channel, client): 8400 self.parent = client 8401 self.stub = WorkflowsStub(channel) 8402 8403 def create(self, workflow, timeout=None): 8404 ''' 8405 Create creates a new workflow and requires a name for the workflow. 8406 ''' 8407 deadline = None if timeout is None else time.time() + timeout 8408 req = WorkflowCreateRequest() 8409 8410 if workflow is not None: 8411 req.workflow.CopyFrom( 8412 plumbing.convert_workflow_to_plumbing(workflow)) 8413 tries = 0 8414 plumbing_response = None 8415 while True: 8416 t = None if deadline is None else deadline - time.time() 8417 try: 8418 plumbing_response = self.stub.Create( 8419 req, 8420 metadata=self.parent.get_metadata('Workflows.Create', req), 8421 timeout=t) 8422 except Exception as e: 8423 if self.parent.shouldRetry(tries, e, deadline): 8424 tries += 1 8425 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8426 continue 8427 raise plumbing.convert_error_to_porcelain(e) from e 8428 break 8429 8430 resp = models.WorkflowCreateResponse() 8431 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8432 plumbing_response.rate_limit) 8433 resp.workflow = plumbing.convert_workflow_to_porcelain( 8434 plumbing_response.workflow) 8435 return resp 8436 8437 def get(self, id, timeout=None): 8438 ''' 8439 Get reads one workflow by ID. 8440 ''' 8441 deadline = None if timeout is None else time.time() + timeout 8442 req = WorkflowGetRequest() 8443 if self.parent.snapshot_datetime is not None: 8444 req.meta.CopyFrom(GetRequestMetadata()) 8445 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8446 8447 req.id = (id) 8448 tries = 0 8449 plumbing_response = None 8450 while True: 8451 t = None if deadline is None else deadline - time.time() 8452 try: 8453 plumbing_response = self.stub.Get( 8454 req, 8455 metadata=self.parent.get_metadata('Workflows.Get', req), 8456 timeout=t) 8457 except Exception as e: 8458 if self.parent.shouldRetry(tries, e, deadline): 8459 tries += 1 8460 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8461 continue 8462 raise plumbing.convert_error_to_porcelain(e) from e 8463 break 8464 8465 resp = models.WorkflowGetResponse() 8466 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 8467 plumbing_response.meta) 8468 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8469 plumbing_response.rate_limit) 8470 resp.workflow = plumbing.convert_workflow_to_porcelain( 8471 plumbing_response.workflow) 8472 return resp 8473 8474 def delete(self, id, timeout=None): 8475 ''' 8476 Delete deletes an existing workflow. 8477 ''' 8478 deadline = None if timeout is None else time.time() + timeout 8479 req = WorkflowDeleteRequest() 8480 8481 req.id = (id) 8482 tries = 0 8483 plumbing_response = None 8484 while True: 8485 t = None if deadline is None else deadline - time.time() 8486 try: 8487 plumbing_response = self.stub.Delete( 8488 req, 8489 metadata=self.parent.get_metadata('Workflows.Delete', req), 8490 timeout=t) 8491 except Exception as e: 8492 if self.parent.shouldRetry(tries, e, deadline): 8493 tries += 1 8494 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8495 continue 8496 raise plumbing.convert_error_to_porcelain(e) from e 8497 break 8498 8499 resp = models.WorkflowDeleteResponse() 8500 resp.id = (plumbing_response.id) 8501 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8502 plumbing_response.rate_limit) 8503 return resp 8504 8505 def update(self, workflow, timeout=None): 8506 ''' 8507 Update updates an existing workflow. 8508 ''' 8509 deadline = None if timeout is None else time.time() + timeout 8510 req = WorkflowUpdateRequest() 8511 8512 if workflow is not None: 8513 req.workflow.CopyFrom( 8514 plumbing.convert_workflow_to_plumbing(workflow)) 8515 tries = 0 8516 plumbing_response = None 8517 while True: 8518 t = None if deadline is None else deadline - time.time() 8519 try: 8520 plumbing_response = self.stub.Update( 8521 req, 8522 metadata=self.parent.get_metadata('Workflows.Update', req), 8523 timeout=t) 8524 except Exception as e: 8525 if self.parent.shouldRetry(tries, e, deadline): 8526 tries += 1 8527 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8528 continue 8529 raise plumbing.convert_error_to_porcelain(e) from e 8530 break 8531 8532 resp = models.WorkflowUpdateResponse() 8533 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8534 plumbing_response.rate_limit) 8535 resp.workflow = plumbing.convert_workflow_to_porcelain( 8536 plumbing_response.workflow) 8537 return resp 8538 8539 def list(self, filter, *args, timeout=None): 8540 ''' 8541 Lists existing workflows. 8542 ''' 8543 deadline = None if timeout is None else time.time() + timeout 8544 req = WorkflowListRequest() 8545 req.meta.CopyFrom(ListRequestMetadata()) 8546 if self.parent.page_limit > 0: 8547 req.meta.limit = self.parent.page_limit 8548 if self.parent.snapshot_datetime is not None: 8549 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8550 8551 req.filter = plumbing.quote_filter_args(filter, *args) 8552 8553 def generator(svc, req): 8554 tries = 0 8555 while True: 8556 t = None if deadline is None else deadline - time.time() 8557 try: 8558 plumbing_response = svc.stub.List( 8559 req, 8560 metadata=svc.parent.get_metadata( 8561 'Workflows.List', req), 8562 timeout=t) 8563 except Exception as e: 8564 if self.parent.shouldRetry(tries, e, deadline): 8565 tries += 1 8566 time.sleep( 8567 self.parent.exponentialBackoff(tries, deadline)) 8568 continue 8569 raise plumbing.convert_error_to_porcelain(e) from e 8570 tries = 0 8571 for plumbing_item in plumbing_response.workflows: 8572 yield plumbing.convert_workflow_to_porcelain(plumbing_item) 8573 if plumbing_response.meta.next_cursor == '': 8574 break 8575 req.meta.cursor = plumbing_response.meta.next_cursor 8576 8577 return generator(self, req) 8578 8579 8580class SnapshotWorkflows: 8581 ''' 8582 SnapshotWorkflows exposes the read only methods of the Workflows 8583 service for historical queries. 8584 ''' 8585 def __init__(self, workflows): 8586 self.workflows = workflows 8587 8588 def get(self, id, timeout=None): 8589 ''' 8590 Get reads one workflow by ID. 8591 ''' 8592 return self.workflows.get(id, timeout=timeout) 8593 8594 def list(self, filter, *args, timeout=None): 8595 ''' 8596 Lists existing workflows. 8597 ''' 8598 return self.workflows.list(filter, *args, timeout=timeout) 8599 8600 8601class WorkflowsHistory: 8602 ''' 8603 WorkflowsHistory provides records of all changes to the state of a Workflow. 8604 See `strongdm.models.WorkflowHistory`. 8605 ''' 8606 def __init__(self, channel, client): 8607 self.parent = client 8608 self.stub = WorkflowsHistoryStub(channel) 8609 8610 def list(self, filter, *args, timeout=None): 8611 ''' 8612 List gets a list of WorkflowHistory records matching a given set of criteria. 8613 ''' 8614 deadline = None if timeout is None else time.time() + timeout 8615 req = WorkflowHistoryListRequest() 8616 req.meta.CopyFrom(ListRequestMetadata()) 8617 if self.parent.page_limit > 0: 8618 req.meta.limit = self.parent.page_limit 8619 if self.parent.snapshot_datetime is not None: 8620 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8621 8622 req.filter = plumbing.quote_filter_args(filter, *args) 8623 8624 def generator(svc, req): 8625 tries = 0 8626 while True: 8627 t = None if deadline is None else deadline - time.time() 8628 try: 8629 plumbing_response = svc.stub.List( 8630 req, 8631 metadata=svc.parent.get_metadata( 8632 'WorkflowsHistory.List', req), 8633 timeout=t) 8634 except Exception as e: 8635 if self.parent.shouldRetry(tries, e, deadline): 8636 tries += 1 8637 time.sleep( 8638 self.parent.exponentialBackoff(tries, deadline)) 8639 continue 8640 raise plumbing.convert_error_to_porcelain(e) from e 8641 tries = 0 8642 for plumbing_item in plumbing_response.history: 8643 yield plumbing.convert_workflow_history_to_porcelain( 8644 plumbing_item) 8645 if plumbing_response.meta.next_cursor == '': 8646 break 8647 req.meta.cursor = plumbing_response.meta.next_cursor 8648 8649 return generator(self, req)
def
deprecated(func)
183def deprecated(func): 184 """This is a decorator which can be used to mark functions 185 as deprecated. It will result in a warning being emitted 186 when the function is used.""" 187 @functools.wraps(func) 188 def new_func(*args, **kwargs): 189 warnings.warn("Call to deprecated function {}.".format(func.__name__), 190 category=DeprecationWarning, 191 stacklevel=2) 192 return func(*args, **kwargs) 193 194 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:
197class AccessRequests: 198 ''' 199 AccessRequests are requests for access to a resource that may match a Workflow. 200 See `strongdm.models.AccessRequest`. 201 ''' 202 def __init__(self, channel, client): 203 self.parent = client 204 self.stub = AccessRequestsStub(channel) 205 206 def list(self, filter, *args, timeout=None): 207 ''' 208 Lists existing access requests. 209 ''' 210 deadline = None if timeout is None else time.time() + timeout 211 req = AccessRequestListRequest() 212 req.meta.CopyFrom(ListRequestMetadata()) 213 if self.parent.page_limit > 0: 214 req.meta.limit = self.parent.page_limit 215 if self.parent.snapshot_datetime is not None: 216 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 217 218 req.filter = plumbing.quote_filter_args(filter, *args) 219 220 def generator(svc, req): 221 tries = 0 222 while True: 223 t = None if deadline is None else deadline - time.time() 224 try: 225 plumbing_response = svc.stub.List( 226 req, 227 metadata=svc.parent.get_metadata( 228 'AccessRequests.List', req), 229 timeout=t) 230 except Exception as e: 231 if self.parent.shouldRetry(tries, e, deadline): 232 tries += 1 233 time.sleep( 234 self.parent.exponentialBackoff(tries, deadline)) 235 continue 236 raise plumbing.convert_error_to_porcelain(e) from e 237 tries = 0 238 for plumbing_item in plumbing_response.access_requests: 239 yield plumbing.convert_access_request_to_porcelain( 240 plumbing_item) 241 if plumbing_response.meta.next_cursor == '': 242 break 243 req.meta.cursor = plumbing_response.meta.next_cursor 244 245 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)
206 def list(self, filter, *args, timeout=None): 207 ''' 208 Lists existing access requests. 209 ''' 210 deadline = None if timeout is None else time.time() + timeout 211 req = AccessRequestListRequest() 212 req.meta.CopyFrom(ListRequestMetadata()) 213 if self.parent.page_limit > 0: 214 req.meta.limit = self.parent.page_limit 215 if self.parent.snapshot_datetime is not None: 216 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 217 218 req.filter = plumbing.quote_filter_args(filter, *args) 219 220 def generator(svc, req): 221 tries = 0 222 while True: 223 t = None if deadline is None else deadline - time.time() 224 try: 225 plumbing_response = svc.stub.List( 226 req, 227 metadata=svc.parent.get_metadata( 228 'AccessRequests.List', req), 229 timeout=t) 230 except Exception as e: 231 if self.parent.shouldRetry(tries, e, deadline): 232 tries += 1 233 time.sleep( 234 self.parent.exponentialBackoff(tries, deadline)) 235 continue 236 raise plumbing.convert_error_to_porcelain(e) from e 237 tries = 0 238 for plumbing_item in plumbing_response.access_requests: 239 yield plumbing.convert_access_request_to_porcelain( 240 plumbing_item) 241 if plumbing_response.meta.next_cursor == '': 242 break 243 req.meta.cursor = plumbing_response.meta.next_cursor 244 245 return generator(self, req)
Lists existing access requests.
class
SnapshotAccessRequests:
248class SnapshotAccessRequests: 249 ''' 250 SnapshotAccessRequests exposes the read only methods of the AccessRequests 251 service for historical queries. 252 ''' 253 def __init__(self, access_requests): 254 self.access_requests = access_requests 255 256 def list(self, filter, *args, timeout=None): 257 ''' 258 Lists existing access requests. 259 ''' 260 return self.access_requests.list(filter, *args, timeout=timeout)
SnapshotAccessRequests exposes the read only methods of the AccessRequests service for historical queries.
class
AccessRequestEventsHistory:
263class AccessRequestEventsHistory: 264 ''' 265 AccessRequestEventsHistory provides records of all changes to the state of an AccessRequest. 266 See `strongdm.models.AccessRequestEventHistory`. 267 ''' 268 def __init__(self, channel, client): 269 self.parent = client 270 self.stub = AccessRequestEventsHistoryStub(channel) 271 272 def list(self, filter, *args, timeout=None): 273 ''' 274 List gets a list of AccessRequestEventHistory records matching a given set of criteria. 275 ''' 276 deadline = None if timeout is None else time.time() + timeout 277 req = AccessRequestEventHistoryListRequest() 278 req.meta.CopyFrom(ListRequestMetadata()) 279 if self.parent.page_limit > 0: 280 req.meta.limit = self.parent.page_limit 281 if self.parent.snapshot_datetime is not None: 282 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 283 284 req.filter = plumbing.quote_filter_args(filter, *args) 285 286 def generator(svc, req): 287 tries = 0 288 while True: 289 t = None if deadline is None else deadline - time.time() 290 try: 291 plumbing_response = svc.stub.List( 292 req, 293 metadata=svc.parent.get_metadata( 294 'AccessRequestEventsHistory.List', req), 295 timeout=t) 296 except Exception as e: 297 if self.parent.shouldRetry(tries, e, deadline): 298 tries += 1 299 time.sleep( 300 self.parent.exponentialBackoff(tries, deadline)) 301 continue 302 raise plumbing.convert_error_to_porcelain(e) from e 303 tries = 0 304 for plumbing_item in plumbing_response.history: 305 yield plumbing.convert_access_request_event_history_to_porcelain( 306 plumbing_item) 307 if plumbing_response.meta.next_cursor == '': 308 break 309 req.meta.cursor = plumbing_response.meta.next_cursor 310 311 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)
272 def list(self, filter, *args, timeout=None): 273 ''' 274 List gets a list of AccessRequestEventHistory records matching a given set of criteria. 275 ''' 276 deadline = None if timeout is None else time.time() + timeout 277 req = AccessRequestEventHistoryListRequest() 278 req.meta.CopyFrom(ListRequestMetadata()) 279 if self.parent.page_limit > 0: 280 req.meta.limit = self.parent.page_limit 281 if self.parent.snapshot_datetime is not None: 282 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 283 284 req.filter = plumbing.quote_filter_args(filter, *args) 285 286 def generator(svc, req): 287 tries = 0 288 while True: 289 t = None if deadline is None else deadline - time.time() 290 try: 291 plumbing_response = svc.stub.List( 292 req, 293 metadata=svc.parent.get_metadata( 294 'AccessRequestEventsHistory.List', req), 295 timeout=t) 296 except Exception as e: 297 if self.parent.shouldRetry(tries, e, deadline): 298 tries += 1 299 time.sleep( 300 self.parent.exponentialBackoff(tries, deadline)) 301 continue 302 raise plumbing.convert_error_to_porcelain(e) from e 303 tries = 0 304 for plumbing_item in plumbing_response.history: 305 yield plumbing.convert_access_request_event_history_to_porcelain( 306 plumbing_item) 307 if plumbing_response.meta.next_cursor == '': 308 break 309 req.meta.cursor = plumbing_response.meta.next_cursor 310 311 return generator(self, req)
List gets a list of AccessRequestEventHistory records matching a given set of criteria.
class
AccessRequestsHistory:
314class AccessRequestsHistory: 315 ''' 316 AccessRequestsHistory provides records of all changes to the state of an AccessRequest. 317 See `strongdm.models.AccessRequestHistory`. 318 ''' 319 def __init__(self, channel, client): 320 self.parent = client 321 self.stub = AccessRequestsHistoryStub(channel) 322 323 def list(self, filter, *args, timeout=None): 324 ''' 325 List gets a list of AccessRequestHistory records matching a given set of criteria. 326 ''' 327 deadline = None if timeout is None else time.time() + timeout 328 req = AccessRequestHistoryListRequest() 329 req.meta.CopyFrom(ListRequestMetadata()) 330 if self.parent.page_limit > 0: 331 req.meta.limit = self.parent.page_limit 332 if self.parent.snapshot_datetime is not None: 333 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 334 335 req.filter = plumbing.quote_filter_args(filter, *args) 336 337 def generator(svc, req): 338 tries = 0 339 while True: 340 t = None if deadline is None else deadline - time.time() 341 try: 342 plumbing_response = svc.stub.List( 343 req, 344 metadata=svc.parent.get_metadata( 345 'AccessRequestsHistory.List', req), 346 timeout=t) 347 except Exception as e: 348 if self.parent.shouldRetry(tries, e, deadline): 349 tries += 1 350 time.sleep( 351 self.parent.exponentialBackoff(tries, deadline)) 352 continue 353 raise plumbing.convert_error_to_porcelain(e) from e 354 tries = 0 355 for plumbing_item in plumbing_response.history: 356 yield plumbing.convert_access_request_history_to_porcelain( 357 plumbing_item) 358 if plumbing_response.meta.next_cursor == '': 359 break 360 req.meta.cursor = plumbing_response.meta.next_cursor 361 362 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)
323 def list(self, filter, *args, timeout=None): 324 ''' 325 List gets a list of AccessRequestHistory records matching a given set of criteria. 326 ''' 327 deadline = None if timeout is None else time.time() + timeout 328 req = AccessRequestHistoryListRequest() 329 req.meta.CopyFrom(ListRequestMetadata()) 330 if self.parent.page_limit > 0: 331 req.meta.limit = self.parent.page_limit 332 if self.parent.snapshot_datetime is not None: 333 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 334 335 req.filter = plumbing.quote_filter_args(filter, *args) 336 337 def generator(svc, req): 338 tries = 0 339 while True: 340 t = None if deadline is None else deadline - time.time() 341 try: 342 plumbing_response = svc.stub.List( 343 req, 344 metadata=svc.parent.get_metadata( 345 'AccessRequestsHistory.List', req), 346 timeout=t) 347 except Exception as e: 348 if self.parent.shouldRetry(tries, e, deadline): 349 tries += 1 350 time.sleep( 351 self.parent.exponentialBackoff(tries, deadline)) 352 continue 353 raise plumbing.convert_error_to_porcelain(e) from e 354 tries = 0 355 for plumbing_item in plumbing_response.history: 356 yield plumbing.convert_access_request_history_to_porcelain( 357 plumbing_item) 358 if plumbing_response.meta.next_cursor == '': 359 break 360 req.meta.cursor = plumbing_response.meta.next_cursor 361 362 return generator(self, req)
List gets a list of AccessRequestHistory records matching a given set of criteria.
class
AccountAttachments:
365class AccountAttachments: 366 ''' 367 AccountAttachments assign an account to a role. 368 See `strongdm.models.AccountAttachment`. 369 ''' 370 def __init__(self, channel, client): 371 self.parent = client 372 self.stub = AccountAttachmentsStub(channel) 373 374 def create(self, account_attachment, timeout=None): 375 ''' 376 Create registers a new AccountAttachment. 377 ''' 378 deadline = None if timeout is None else time.time() + timeout 379 req = AccountAttachmentCreateRequest() 380 381 if account_attachment is not None: 382 req.account_attachment.CopyFrom( 383 plumbing.convert_account_attachment_to_plumbing( 384 account_attachment)) 385 tries = 0 386 plumbing_response = None 387 while True: 388 t = None if deadline is None else deadline - time.time() 389 try: 390 plumbing_response = self.stub.Create( 391 req, 392 metadata=self.parent.get_metadata( 393 'AccountAttachments.Create', req), 394 timeout=t) 395 except Exception as e: 396 if self.parent.shouldRetry(tries, e, deadline): 397 tries += 1 398 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 399 continue 400 raise plumbing.convert_error_to_porcelain(e) from e 401 break 402 403 resp = models.AccountAttachmentCreateResponse() 404 resp.account_attachment = plumbing.convert_account_attachment_to_porcelain( 405 plumbing_response.account_attachment) 406 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 407 plumbing_response.meta) 408 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 409 plumbing_response.rate_limit) 410 return resp 411 412 def get(self, id, timeout=None): 413 ''' 414 Get reads one AccountAttachment by ID. 415 ''' 416 deadline = None if timeout is None else time.time() + timeout 417 req = AccountAttachmentGetRequest() 418 if self.parent.snapshot_datetime is not None: 419 req.meta.CopyFrom(GetRequestMetadata()) 420 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 421 422 req.id = (id) 423 tries = 0 424 plumbing_response = None 425 while True: 426 t = None if deadline is None else deadline - time.time() 427 try: 428 plumbing_response = self.stub.Get( 429 req, 430 metadata=self.parent.get_metadata('AccountAttachments.Get', 431 req), 432 timeout=t) 433 except Exception as e: 434 if self.parent.shouldRetry(tries, e, deadline): 435 tries += 1 436 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 437 continue 438 raise plumbing.convert_error_to_porcelain(e) from e 439 break 440 441 resp = models.AccountAttachmentGetResponse() 442 resp.account_attachment = plumbing.convert_account_attachment_to_porcelain( 443 plumbing_response.account_attachment) 444 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 445 plumbing_response.meta) 446 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 447 plumbing_response.rate_limit) 448 return resp 449 450 def delete(self, id, timeout=None): 451 ''' 452 Delete removes a AccountAttachment by ID. 453 ''' 454 deadline = None if timeout is None else time.time() + timeout 455 req = AccountAttachmentDeleteRequest() 456 457 req.id = (id) 458 tries = 0 459 plumbing_response = None 460 while True: 461 t = None if deadline is None else deadline - time.time() 462 try: 463 plumbing_response = self.stub.Delete( 464 req, 465 metadata=self.parent.get_metadata( 466 'AccountAttachments.Delete', req), 467 timeout=t) 468 except Exception as e: 469 if self.parent.shouldRetry(tries, e, deadline): 470 tries += 1 471 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 472 continue 473 raise plumbing.convert_error_to_porcelain(e) from e 474 break 475 476 resp = models.AccountAttachmentDeleteResponse() 477 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 478 plumbing_response.meta) 479 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 480 plumbing_response.rate_limit) 481 return resp 482 483 def list(self, filter, *args, timeout=None): 484 ''' 485 List gets a list of AccountAttachments matching a given set of criteria. 486 ''' 487 deadline = None if timeout is None else time.time() + timeout 488 req = AccountAttachmentListRequest() 489 req.meta.CopyFrom(ListRequestMetadata()) 490 if self.parent.page_limit > 0: 491 req.meta.limit = self.parent.page_limit 492 if self.parent.snapshot_datetime is not None: 493 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 494 495 req.filter = plumbing.quote_filter_args(filter, *args) 496 497 def generator(svc, req): 498 tries = 0 499 while True: 500 t = None if deadline is None else deadline - time.time() 501 try: 502 plumbing_response = svc.stub.List( 503 req, 504 metadata=svc.parent.get_metadata( 505 'AccountAttachments.List', req), 506 timeout=t) 507 except Exception as e: 508 if self.parent.shouldRetry(tries, e, deadline): 509 tries += 1 510 time.sleep( 511 self.parent.exponentialBackoff(tries, deadline)) 512 continue 513 raise plumbing.convert_error_to_porcelain(e) from e 514 tries = 0 515 for plumbing_item in plumbing_response.account_attachments: 516 yield plumbing.convert_account_attachment_to_porcelain( 517 plumbing_item) 518 if plumbing_response.meta.next_cursor == '': 519 break 520 req.meta.cursor = plumbing_response.meta.next_cursor 521 522 return generator(self, req)
AccountAttachments assign an account to a role.
See strongdm.models.AccountAttachment.
def
create(self, account_attachment, timeout=None)
374 def create(self, account_attachment, timeout=None): 375 ''' 376 Create registers a new AccountAttachment. 377 ''' 378 deadline = None if timeout is None else time.time() + timeout 379 req = AccountAttachmentCreateRequest() 380 381 if account_attachment is not None: 382 req.account_attachment.CopyFrom( 383 plumbing.convert_account_attachment_to_plumbing( 384 account_attachment)) 385 tries = 0 386 plumbing_response = None 387 while True: 388 t = None if deadline is None else deadline - time.time() 389 try: 390 plumbing_response = self.stub.Create( 391 req, 392 metadata=self.parent.get_metadata( 393 'AccountAttachments.Create', req), 394 timeout=t) 395 except Exception as e: 396 if self.parent.shouldRetry(tries, e, deadline): 397 tries += 1 398 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 399 continue 400 raise plumbing.convert_error_to_porcelain(e) from e 401 break 402 403 resp = models.AccountAttachmentCreateResponse() 404 resp.account_attachment = plumbing.convert_account_attachment_to_porcelain( 405 plumbing_response.account_attachment) 406 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 407 plumbing_response.meta) 408 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 409 plumbing_response.rate_limit) 410 return resp
Create registers a new AccountAttachment.
def
get(self, id, timeout=None)
412 def get(self, id, timeout=None): 413 ''' 414 Get reads one AccountAttachment by ID. 415 ''' 416 deadline = None if timeout is None else time.time() + timeout 417 req = AccountAttachmentGetRequest() 418 if self.parent.snapshot_datetime is not None: 419 req.meta.CopyFrom(GetRequestMetadata()) 420 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 421 422 req.id = (id) 423 tries = 0 424 plumbing_response = None 425 while True: 426 t = None if deadline is None else deadline - time.time() 427 try: 428 plumbing_response = self.stub.Get( 429 req, 430 metadata=self.parent.get_metadata('AccountAttachments.Get', 431 req), 432 timeout=t) 433 except Exception as e: 434 if self.parent.shouldRetry(tries, e, deadline): 435 tries += 1 436 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 437 continue 438 raise plumbing.convert_error_to_porcelain(e) from e 439 break 440 441 resp = models.AccountAttachmentGetResponse() 442 resp.account_attachment = plumbing.convert_account_attachment_to_porcelain( 443 plumbing_response.account_attachment) 444 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 445 plumbing_response.meta) 446 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 447 plumbing_response.rate_limit) 448 return resp
Get reads one AccountAttachment by ID.
def
delete(self, id, timeout=None)
450 def delete(self, id, timeout=None): 451 ''' 452 Delete removes a AccountAttachment by ID. 453 ''' 454 deadline = None if timeout is None else time.time() + timeout 455 req = AccountAttachmentDeleteRequest() 456 457 req.id = (id) 458 tries = 0 459 plumbing_response = None 460 while True: 461 t = None if deadline is None else deadline - time.time() 462 try: 463 plumbing_response = self.stub.Delete( 464 req, 465 metadata=self.parent.get_metadata( 466 'AccountAttachments.Delete', req), 467 timeout=t) 468 except Exception as e: 469 if self.parent.shouldRetry(tries, e, deadline): 470 tries += 1 471 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 472 continue 473 raise plumbing.convert_error_to_porcelain(e) from e 474 break 475 476 resp = models.AccountAttachmentDeleteResponse() 477 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 478 plumbing_response.meta) 479 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 480 plumbing_response.rate_limit) 481 return resp
Delete removes a AccountAttachment by ID.
def
list(self, filter, *args, timeout=None)
483 def list(self, filter, *args, timeout=None): 484 ''' 485 List gets a list of AccountAttachments matching a given set of criteria. 486 ''' 487 deadline = None if timeout is None else time.time() + timeout 488 req = AccountAttachmentListRequest() 489 req.meta.CopyFrom(ListRequestMetadata()) 490 if self.parent.page_limit > 0: 491 req.meta.limit = self.parent.page_limit 492 if self.parent.snapshot_datetime is not None: 493 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 494 495 req.filter = plumbing.quote_filter_args(filter, *args) 496 497 def generator(svc, req): 498 tries = 0 499 while True: 500 t = None if deadline is None else deadline - time.time() 501 try: 502 plumbing_response = svc.stub.List( 503 req, 504 metadata=svc.parent.get_metadata( 505 'AccountAttachments.List', req), 506 timeout=t) 507 except Exception as e: 508 if self.parent.shouldRetry(tries, e, deadline): 509 tries += 1 510 time.sleep( 511 self.parent.exponentialBackoff(tries, deadline)) 512 continue 513 raise plumbing.convert_error_to_porcelain(e) from e 514 tries = 0 515 for plumbing_item in plumbing_response.account_attachments: 516 yield plumbing.convert_account_attachment_to_porcelain( 517 plumbing_item) 518 if plumbing_response.meta.next_cursor == '': 519 break 520 req.meta.cursor = plumbing_response.meta.next_cursor 521 522 return generator(self, req)
List gets a list of AccountAttachments matching a given set of criteria.
class
SnapshotAccountAttachments:
525class SnapshotAccountAttachments: 526 ''' 527 SnapshotAccountAttachments exposes the read only methods of the AccountAttachments 528 service for historical queries. 529 ''' 530 def __init__(self, account_attachments): 531 self.account_attachments = account_attachments 532 533 def get(self, id, timeout=None): 534 ''' 535 Get reads one AccountAttachment by ID. 536 ''' 537 return self.account_attachments.get(id, timeout=timeout) 538 539 def list(self, filter, *args, timeout=None): 540 ''' 541 List gets a list of AccountAttachments matching a given set of criteria. 542 ''' 543 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)
533 def get(self, id, timeout=None): 534 ''' 535 Get reads one AccountAttachment by ID. 536 ''' 537 return self.account_attachments.get(id, timeout=timeout)
Get reads one AccountAttachment by ID.
def
list(self, filter, *args, timeout=None)
539 def list(self, filter, *args, timeout=None): 540 ''' 541 List gets a list of AccountAttachments matching a given set of criteria. 542 ''' 543 return self.account_attachments.list(filter, *args, timeout=timeout)
List gets a list of AccountAttachments matching a given set of criteria.
class
AccountAttachmentsHistory:
546class AccountAttachmentsHistory: 547 ''' 548 AccountAttachmentsHistory records all changes to the state of an AccountAttachment. 549 See `strongdm.models.AccountAttachmentHistory`. 550 ''' 551 def __init__(self, channel, client): 552 self.parent = client 553 self.stub = AccountAttachmentsHistoryStub(channel) 554 555 def list(self, filter, *args, timeout=None): 556 ''' 557 List gets a list of AccountAttachmentHistory records matching a given set of criteria. 558 ''' 559 deadline = None if timeout is None else time.time() + timeout 560 req = AccountAttachmentHistoryListRequest() 561 req.meta.CopyFrom(ListRequestMetadata()) 562 if self.parent.page_limit > 0: 563 req.meta.limit = self.parent.page_limit 564 if self.parent.snapshot_datetime is not None: 565 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 566 567 req.filter = plumbing.quote_filter_args(filter, *args) 568 569 def generator(svc, req): 570 tries = 0 571 while True: 572 t = None if deadline is None else deadline - time.time() 573 try: 574 plumbing_response = svc.stub.List( 575 req, 576 metadata=svc.parent.get_metadata( 577 'AccountAttachmentsHistory.List', req), 578 timeout=t) 579 except Exception as e: 580 if self.parent.shouldRetry(tries, e, deadline): 581 tries += 1 582 time.sleep( 583 self.parent.exponentialBackoff(tries, deadline)) 584 continue 585 raise plumbing.convert_error_to_porcelain(e) from e 586 tries = 0 587 for plumbing_item in plumbing_response.history: 588 yield plumbing.convert_account_attachment_history_to_porcelain( 589 plumbing_item) 590 if plumbing_response.meta.next_cursor == '': 591 break 592 req.meta.cursor = plumbing_response.meta.next_cursor 593 594 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)
555 def list(self, filter, *args, timeout=None): 556 ''' 557 List gets a list of AccountAttachmentHistory records matching a given set of criteria. 558 ''' 559 deadline = None if timeout is None else time.time() + timeout 560 req = AccountAttachmentHistoryListRequest() 561 req.meta.CopyFrom(ListRequestMetadata()) 562 if self.parent.page_limit > 0: 563 req.meta.limit = self.parent.page_limit 564 if self.parent.snapshot_datetime is not None: 565 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 566 567 req.filter = plumbing.quote_filter_args(filter, *args) 568 569 def generator(svc, req): 570 tries = 0 571 while True: 572 t = None if deadline is None else deadline - time.time() 573 try: 574 plumbing_response = svc.stub.List( 575 req, 576 metadata=svc.parent.get_metadata( 577 'AccountAttachmentsHistory.List', req), 578 timeout=t) 579 except Exception as e: 580 if self.parent.shouldRetry(tries, e, deadline): 581 tries += 1 582 time.sleep( 583 self.parent.exponentialBackoff(tries, deadline)) 584 continue 585 raise plumbing.convert_error_to_porcelain(e) from e 586 tries = 0 587 for plumbing_item in plumbing_response.history: 588 yield plumbing.convert_account_attachment_history_to_porcelain( 589 plumbing_item) 590 if plumbing_response.meta.next_cursor == '': 591 break 592 req.meta.cursor = plumbing_response.meta.next_cursor 593 594 return generator(self, req)
List gets a list of AccountAttachmentHistory records matching a given set of criteria.
class
AccountGrants:
597class AccountGrants: 598 ''' 599 AccountGrants assign a resource directly to an account, giving the account the permission to connect to that resource. 600 See `strongdm.models.AccountGrant`. 601 ''' 602 def __init__(self, channel, client): 603 self.parent = client 604 self.stub = AccountGrantsStub(channel) 605 606 def create(self, account_grant, timeout=None): 607 ''' 608 Create registers a new AccountGrant. 609 ''' 610 deadline = None if timeout is None else time.time() + timeout 611 req = AccountGrantCreateRequest() 612 613 if account_grant is not None: 614 req.account_grant.CopyFrom( 615 plumbing.convert_account_grant_to_plumbing(account_grant)) 616 tries = 0 617 plumbing_response = None 618 while True: 619 t = None if deadline is None else deadline - time.time() 620 try: 621 plumbing_response = self.stub.Create( 622 req, 623 metadata=self.parent.get_metadata('AccountGrants.Create', 624 req), 625 timeout=t) 626 except Exception as e: 627 if self.parent.shouldRetry(tries, e, deadline): 628 tries += 1 629 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 630 continue 631 raise plumbing.convert_error_to_porcelain(e) from e 632 break 633 634 resp = models.AccountGrantCreateResponse() 635 resp.account_grant = plumbing.convert_account_grant_to_porcelain( 636 plumbing_response.account_grant) 637 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 638 plumbing_response.meta) 639 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 640 plumbing_response.rate_limit) 641 return resp 642 643 def get(self, id, timeout=None): 644 ''' 645 Get reads one AccountGrant by ID. 646 ''' 647 deadline = None if timeout is None else time.time() + timeout 648 req = AccountGrantGetRequest() 649 if self.parent.snapshot_datetime is not None: 650 req.meta.CopyFrom(GetRequestMetadata()) 651 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 652 653 req.id = (id) 654 tries = 0 655 plumbing_response = None 656 while True: 657 t = None if deadline is None else deadline - time.time() 658 try: 659 plumbing_response = self.stub.Get( 660 req, 661 metadata=self.parent.get_metadata('AccountGrants.Get', 662 req), 663 timeout=t) 664 except Exception as e: 665 if self.parent.shouldRetry(tries, e, deadline): 666 tries += 1 667 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 668 continue 669 raise plumbing.convert_error_to_porcelain(e) from e 670 break 671 672 resp = models.AccountGrantGetResponse() 673 resp.account_grant = plumbing.convert_account_grant_to_porcelain( 674 plumbing_response.account_grant) 675 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 676 plumbing_response.meta) 677 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 678 plumbing_response.rate_limit) 679 return resp 680 681 def delete(self, id, timeout=None): 682 ''' 683 Delete removes a AccountGrant by ID. 684 ''' 685 deadline = None if timeout is None else time.time() + timeout 686 req = AccountGrantDeleteRequest() 687 688 req.id = (id) 689 tries = 0 690 plumbing_response = None 691 while True: 692 t = None if deadline is None else deadline - time.time() 693 try: 694 plumbing_response = self.stub.Delete( 695 req, 696 metadata=self.parent.get_metadata('AccountGrants.Delete', 697 req), 698 timeout=t) 699 except Exception as e: 700 if self.parent.shouldRetry(tries, e, deadline): 701 tries += 1 702 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 703 continue 704 raise plumbing.convert_error_to_porcelain(e) from e 705 break 706 707 resp = models.AccountGrantDeleteResponse() 708 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 709 plumbing_response.meta) 710 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 711 plumbing_response.rate_limit) 712 return resp 713 714 def list(self, filter, *args, timeout=None): 715 ''' 716 List gets a list of AccountGrants matching a given set of criteria. 717 ''' 718 deadline = None if timeout is None else time.time() + timeout 719 req = AccountGrantListRequest() 720 req.meta.CopyFrom(ListRequestMetadata()) 721 if self.parent.page_limit > 0: 722 req.meta.limit = self.parent.page_limit 723 if self.parent.snapshot_datetime is not None: 724 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 725 726 req.filter = plumbing.quote_filter_args(filter, *args) 727 728 def generator(svc, req): 729 tries = 0 730 while True: 731 t = None if deadline is None else deadline - time.time() 732 try: 733 plumbing_response = svc.stub.List( 734 req, 735 metadata=svc.parent.get_metadata( 736 'AccountGrants.List', req), 737 timeout=t) 738 except Exception as e: 739 if self.parent.shouldRetry(tries, e, deadline): 740 tries += 1 741 time.sleep( 742 self.parent.exponentialBackoff(tries, deadline)) 743 continue 744 raise plumbing.convert_error_to_porcelain(e) from e 745 tries = 0 746 for plumbing_item in plumbing_response.account_grants: 747 yield plumbing.convert_account_grant_to_porcelain( 748 plumbing_item) 749 if plumbing_response.meta.next_cursor == '': 750 break 751 req.meta.cursor = plumbing_response.meta.next_cursor 752 753 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)
606 def create(self, account_grant, timeout=None): 607 ''' 608 Create registers a new AccountGrant. 609 ''' 610 deadline = None if timeout is None else time.time() + timeout 611 req = AccountGrantCreateRequest() 612 613 if account_grant is not None: 614 req.account_grant.CopyFrom( 615 plumbing.convert_account_grant_to_plumbing(account_grant)) 616 tries = 0 617 plumbing_response = None 618 while True: 619 t = None if deadline is None else deadline - time.time() 620 try: 621 plumbing_response = self.stub.Create( 622 req, 623 metadata=self.parent.get_metadata('AccountGrants.Create', 624 req), 625 timeout=t) 626 except Exception as e: 627 if self.parent.shouldRetry(tries, e, deadline): 628 tries += 1 629 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 630 continue 631 raise plumbing.convert_error_to_porcelain(e) from e 632 break 633 634 resp = models.AccountGrantCreateResponse() 635 resp.account_grant = plumbing.convert_account_grant_to_porcelain( 636 plumbing_response.account_grant) 637 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 638 plumbing_response.meta) 639 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 640 plumbing_response.rate_limit) 641 return resp
Create registers a new AccountGrant.
def
get(self, id, timeout=None)
643 def get(self, id, timeout=None): 644 ''' 645 Get reads one AccountGrant by ID. 646 ''' 647 deadline = None if timeout is None else time.time() + timeout 648 req = AccountGrantGetRequest() 649 if self.parent.snapshot_datetime is not None: 650 req.meta.CopyFrom(GetRequestMetadata()) 651 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 652 653 req.id = (id) 654 tries = 0 655 plumbing_response = None 656 while True: 657 t = None if deadline is None else deadline - time.time() 658 try: 659 plumbing_response = self.stub.Get( 660 req, 661 metadata=self.parent.get_metadata('AccountGrants.Get', 662 req), 663 timeout=t) 664 except Exception as e: 665 if self.parent.shouldRetry(tries, e, deadline): 666 tries += 1 667 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 668 continue 669 raise plumbing.convert_error_to_porcelain(e) from e 670 break 671 672 resp = models.AccountGrantGetResponse() 673 resp.account_grant = plumbing.convert_account_grant_to_porcelain( 674 plumbing_response.account_grant) 675 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 676 plumbing_response.meta) 677 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 678 plumbing_response.rate_limit) 679 return resp
Get reads one AccountGrant by ID.
def
delete(self, id, timeout=None)
681 def delete(self, id, timeout=None): 682 ''' 683 Delete removes a AccountGrant by ID. 684 ''' 685 deadline = None if timeout is None else time.time() + timeout 686 req = AccountGrantDeleteRequest() 687 688 req.id = (id) 689 tries = 0 690 plumbing_response = None 691 while True: 692 t = None if deadline is None else deadline - time.time() 693 try: 694 plumbing_response = self.stub.Delete( 695 req, 696 metadata=self.parent.get_metadata('AccountGrants.Delete', 697 req), 698 timeout=t) 699 except Exception as e: 700 if self.parent.shouldRetry(tries, e, deadline): 701 tries += 1 702 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 703 continue 704 raise plumbing.convert_error_to_porcelain(e) from e 705 break 706 707 resp = models.AccountGrantDeleteResponse() 708 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 709 plumbing_response.meta) 710 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 711 plumbing_response.rate_limit) 712 return resp
Delete removes a AccountGrant by ID.
def
list(self, filter, *args, timeout=None)
714 def list(self, filter, *args, timeout=None): 715 ''' 716 List gets a list of AccountGrants matching a given set of criteria. 717 ''' 718 deadline = None if timeout is None else time.time() + timeout 719 req = AccountGrantListRequest() 720 req.meta.CopyFrom(ListRequestMetadata()) 721 if self.parent.page_limit > 0: 722 req.meta.limit = self.parent.page_limit 723 if self.parent.snapshot_datetime is not None: 724 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 725 726 req.filter = plumbing.quote_filter_args(filter, *args) 727 728 def generator(svc, req): 729 tries = 0 730 while True: 731 t = None if deadline is None else deadline - time.time() 732 try: 733 plumbing_response = svc.stub.List( 734 req, 735 metadata=svc.parent.get_metadata( 736 'AccountGrants.List', req), 737 timeout=t) 738 except Exception as e: 739 if self.parent.shouldRetry(tries, e, deadline): 740 tries += 1 741 time.sleep( 742 self.parent.exponentialBackoff(tries, deadline)) 743 continue 744 raise plumbing.convert_error_to_porcelain(e) from e 745 tries = 0 746 for plumbing_item in plumbing_response.account_grants: 747 yield plumbing.convert_account_grant_to_porcelain( 748 plumbing_item) 749 if plumbing_response.meta.next_cursor == '': 750 break 751 req.meta.cursor = plumbing_response.meta.next_cursor 752 753 return generator(self, req)
List gets a list of AccountGrants matching a given set of criteria.
class
SnapshotAccountGrants:
756class SnapshotAccountGrants: 757 ''' 758 SnapshotAccountGrants exposes the read only methods of the AccountGrants 759 service for historical queries. 760 ''' 761 def __init__(self, account_grants): 762 self.account_grants = account_grants 763 764 def get(self, id, timeout=None): 765 ''' 766 Get reads one AccountGrant by ID. 767 ''' 768 return self.account_grants.get(id, timeout=timeout) 769 770 def list(self, filter, *args, timeout=None): 771 ''' 772 List gets a list of AccountGrants matching a given set of criteria. 773 ''' 774 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)
764 def get(self, id, timeout=None): 765 ''' 766 Get reads one AccountGrant by ID. 767 ''' 768 return self.account_grants.get(id, timeout=timeout)
Get reads one AccountGrant by ID.
def
list(self, filter, *args, timeout=None)
770 def list(self, filter, *args, timeout=None): 771 ''' 772 List gets a list of AccountGrants matching a given set of criteria. 773 ''' 774 return self.account_grants.list(filter, *args, timeout=timeout)
List gets a list of AccountGrants matching a given set of criteria.
class
AccountGrantsHistory:
777class AccountGrantsHistory: 778 ''' 779 AccountGrantsHistory records all changes to the state of an AccountGrant. 780 See `strongdm.models.AccountGrantHistory`. 781 ''' 782 def __init__(self, channel, client): 783 self.parent = client 784 self.stub = AccountGrantsHistoryStub(channel) 785 786 def list(self, filter, *args, timeout=None): 787 ''' 788 List gets a list of AccountGrantHistory records matching a given set of criteria. 789 ''' 790 deadline = None if timeout is None else time.time() + timeout 791 req = AccountGrantHistoryListRequest() 792 req.meta.CopyFrom(ListRequestMetadata()) 793 if self.parent.page_limit > 0: 794 req.meta.limit = self.parent.page_limit 795 if self.parent.snapshot_datetime is not None: 796 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 797 798 req.filter = plumbing.quote_filter_args(filter, *args) 799 800 def generator(svc, req): 801 tries = 0 802 while True: 803 t = None if deadline is None else deadline - time.time() 804 try: 805 plumbing_response = svc.stub.List( 806 req, 807 metadata=svc.parent.get_metadata( 808 'AccountGrantsHistory.List', req), 809 timeout=t) 810 except Exception as e: 811 if self.parent.shouldRetry(tries, e, deadline): 812 tries += 1 813 time.sleep( 814 self.parent.exponentialBackoff(tries, deadline)) 815 continue 816 raise plumbing.convert_error_to_porcelain(e) from e 817 tries = 0 818 for plumbing_item in plumbing_response.history: 819 yield plumbing.convert_account_grant_history_to_porcelain( 820 plumbing_item) 821 if plumbing_response.meta.next_cursor == '': 822 break 823 req.meta.cursor = plumbing_response.meta.next_cursor 824 825 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)
786 def list(self, filter, *args, timeout=None): 787 ''' 788 List gets a list of AccountGrantHistory records matching a given set of criteria. 789 ''' 790 deadline = None if timeout is None else time.time() + timeout 791 req = AccountGrantHistoryListRequest() 792 req.meta.CopyFrom(ListRequestMetadata()) 793 if self.parent.page_limit > 0: 794 req.meta.limit = self.parent.page_limit 795 if self.parent.snapshot_datetime is not None: 796 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 797 798 req.filter = plumbing.quote_filter_args(filter, *args) 799 800 def generator(svc, req): 801 tries = 0 802 while True: 803 t = None if deadline is None else deadline - time.time() 804 try: 805 plumbing_response = svc.stub.List( 806 req, 807 metadata=svc.parent.get_metadata( 808 'AccountGrantsHistory.List', req), 809 timeout=t) 810 except Exception as e: 811 if self.parent.shouldRetry(tries, e, deadline): 812 tries += 1 813 time.sleep( 814 self.parent.exponentialBackoff(tries, deadline)) 815 continue 816 raise plumbing.convert_error_to_porcelain(e) from e 817 tries = 0 818 for plumbing_item in plumbing_response.history: 819 yield plumbing.convert_account_grant_history_to_porcelain( 820 plumbing_item) 821 if plumbing_response.meta.next_cursor == '': 822 break 823 req.meta.cursor = plumbing_response.meta.next_cursor 824 825 return generator(self, req)
List gets a list of AccountGrantHistory records matching a given set of criteria.
class
AccountPermissions:
828class AccountPermissions: 829 ''' 830 AccountPermissions records the granular permissions accounts have, allowing them to execute 831 relevant commands via StrongDM's APIs. 832 See `strongdm.models.AccountPermission`. 833 ''' 834 def __init__(self, channel, client): 835 self.parent = client 836 self.stub = AccountPermissionsStub(channel) 837 838 def list(self, filter, *args, timeout=None): 839 ''' 840 List gets a list of Permission records matching a given set of criteria. 841 ''' 842 deadline = None if timeout is None else time.time() + timeout 843 req = AccountPermissionListRequest() 844 req.meta.CopyFrom(ListRequestMetadata()) 845 if self.parent.page_limit > 0: 846 req.meta.limit = self.parent.page_limit 847 if self.parent.snapshot_datetime is not None: 848 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 849 850 req.filter = plumbing.quote_filter_args(filter, *args) 851 852 def generator(svc, req): 853 tries = 0 854 while True: 855 t = None if deadline is None else deadline - time.time() 856 try: 857 plumbing_response = svc.stub.List( 858 req, 859 metadata=svc.parent.get_metadata( 860 'AccountPermissions.List', req), 861 timeout=t) 862 except Exception as e: 863 if self.parent.shouldRetry(tries, e, deadline): 864 tries += 1 865 time.sleep( 866 self.parent.exponentialBackoff(tries, deadline)) 867 continue 868 raise plumbing.convert_error_to_porcelain(e) from e 869 tries = 0 870 for plumbing_item in plumbing_response.permissions: 871 yield plumbing.convert_account_permission_to_porcelain( 872 plumbing_item) 873 if plumbing_response.meta.next_cursor == '': 874 break 875 req.meta.cursor = plumbing_response.meta.next_cursor 876 877 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)
838 def list(self, filter, *args, timeout=None): 839 ''' 840 List gets a list of Permission records matching a given set of criteria. 841 ''' 842 deadline = None if timeout is None else time.time() + timeout 843 req = AccountPermissionListRequest() 844 req.meta.CopyFrom(ListRequestMetadata()) 845 if self.parent.page_limit > 0: 846 req.meta.limit = self.parent.page_limit 847 if self.parent.snapshot_datetime is not None: 848 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 849 850 req.filter = plumbing.quote_filter_args(filter, *args) 851 852 def generator(svc, req): 853 tries = 0 854 while True: 855 t = None if deadline is None else deadline - time.time() 856 try: 857 plumbing_response = svc.stub.List( 858 req, 859 metadata=svc.parent.get_metadata( 860 'AccountPermissions.List', req), 861 timeout=t) 862 except Exception as e: 863 if self.parent.shouldRetry(tries, e, deadline): 864 tries += 1 865 time.sleep( 866 self.parent.exponentialBackoff(tries, deadline)) 867 continue 868 raise plumbing.convert_error_to_porcelain(e) from e 869 tries = 0 870 for plumbing_item in plumbing_response.permissions: 871 yield plumbing.convert_account_permission_to_porcelain( 872 plumbing_item) 873 if plumbing_response.meta.next_cursor == '': 874 break 875 req.meta.cursor = plumbing_response.meta.next_cursor 876 877 return generator(self, req)
List gets a list of Permission records matching a given set of criteria.
class
SnapshotAccountPermissions:
880class SnapshotAccountPermissions: 881 ''' 882 SnapshotAccountPermissions exposes the read only methods of the AccountPermissions 883 service for historical queries. 884 ''' 885 def __init__(self, account_permissions): 886 self.account_permissions = account_permissions 887 888 def list(self, filter, *args, timeout=None): 889 ''' 890 List gets a list of Permission records matching a given set of criteria. 891 ''' 892 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)
888 def list(self, filter, *args, timeout=None): 889 ''' 890 List gets a list of Permission records matching a given set of criteria. 891 ''' 892 return self.account_permissions.list(filter, *args, timeout=timeout)
List gets a list of Permission records matching a given set of criteria.
class
AccountResources:
895class AccountResources: 896 ''' 897 AccountResources enumerates the resources to which accounts have access. 898 The AccountResources service is read-only. 899 See `strongdm.models.AccountResource`. 900 ''' 901 def __init__(self, channel, client): 902 self.parent = client 903 self.stub = AccountResourcesStub(channel) 904 905 def list(self, filter, *args, timeout=None): 906 ''' 907 List gets a list of AccountResource records matching a given set of criteria. 908 ''' 909 deadline = None if timeout is None else time.time() + timeout 910 req = AccountResourceListRequest() 911 req.meta.CopyFrom(ListRequestMetadata()) 912 if self.parent.page_limit > 0: 913 req.meta.limit = self.parent.page_limit 914 if self.parent.snapshot_datetime is not None: 915 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 916 917 req.filter = plumbing.quote_filter_args(filter, *args) 918 919 def generator(svc, req): 920 tries = 0 921 while True: 922 t = None if deadline is None else deadline - time.time() 923 try: 924 plumbing_response = svc.stub.List( 925 req, 926 metadata=svc.parent.get_metadata( 927 'AccountResources.List', req), 928 timeout=t) 929 except Exception as e: 930 if self.parent.shouldRetry(tries, e, deadline): 931 tries += 1 932 time.sleep( 933 self.parent.exponentialBackoff(tries, deadline)) 934 continue 935 raise plumbing.convert_error_to_porcelain(e) from e 936 tries = 0 937 for plumbing_item in plumbing_response.account_resources: 938 yield plumbing.convert_account_resource_to_porcelain( 939 plumbing_item) 940 if plumbing_response.meta.next_cursor == '': 941 break 942 req.meta.cursor = plumbing_response.meta.next_cursor 943 944 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)
905 def list(self, filter, *args, timeout=None): 906 ''' 907 List gets a list of AccountResource records matching a given set of criteria. 908 ''' 909 deadline = None if timeout is None else time.time() + timeout 910 req = AccountResourceListRequest() 911 req.meta.CopyFrom(ListRequestMetadata()) 912 if self.parent.page_limit > 0: 913 req.meta.limit = self.parent.page_limit 914 if self.parent.snapshot_datetime is not None: 915 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 916 917 req.filter = plumbing.quote_filter_args(filter, *args) 918 919 def generator(svc, req): 920 tries = 0 921 while True: 922 t = None if deadline is None else deadline - time.time() 923 try: 924 plumbing_response = svc.stub.List( 925 req, 926 metadata=svc.parent.get_metadata( 927 'AccountResources.List', req), 928 timeout=t) 929 except Exception as e: 930 if self.parent.shouldRetry(tries, e, deadline): 931 tries += 1 932 time.sleep( 933 self.parent.exponentialBackoff(tries, deadline)) 934 continue 935 raise plumbing.convert_error_to_porcelain(e) from e 936 tries = 0 937 for plumbing_item in plumbing_response.account_resources: 938 yield plumbing.convert_account_resource_to_porcelain( 939 plumbing_item) 940 if plumbing_response.meta.next_cursor == '': 941 break 942 req.meta.cursor = plumbing_response.meta.next_cursor 943 944 return generator(self, req)
List gets a list of AccountResource records matching a given set of criteria.
class
SnapshotAccountResources:
947class SnapshotAccountResources: 948 ''' 949 SnapshotAccountResources exposes the read only methods of the AccountResources 950 service for historical queries. 951 ''' 952 def __init__(self, account_resources): 953 self.account_resources = account_resources 954 955 def list(self, filter, *args, timeout=None): 956 ''' 957 List gets a list of AccountResource records matching a given set of criteria. 958 ''' 959 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)
955 def list(self, filter, *args, timeout=None): 956 ''' 957 List gets a list of AccountResource records matching a given set of criteria. 958 ''' 959 return self.account_resources.list(filter, *args, timeout=timeout)
List gets a list of AccountResource records matching a given set of criteria.
class
AccountResourcesHistory:
962class AccountResourcesHistory: 963 ''' 964 AccountResourcesHistory records all changes to the state of a AccountResource. 965 See `strongdm.models.AccountResourceHistory`. 966 ''' 967 def __init__(self, channel, client): 968 self.parent = client 969 self.stub = AccountResourcesHistoryStub(channel) 970 971 def list(self, filter, *args, timeout=None): 972 ''' 973 List gets a list of AccountResourceHistory records matching a given set of criteria. 974 ''' 975 deadline = None if timeout is None else time.time() + timeout 976 req = AccountResourceHistoryListRequest() 977 req.meta.CopyFrom(ListRequestMetadata()) 978 if self.parent.page_limit > 0: 979 req.meta.limit = self.parent.page_limit 980 if self.parent.snapshot_datetime is not None: 981 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 982 983 req.filter = plumbing.quote_filter_args(filter, *args) 984 985 def generator(svc, req): 986 tries = 0 987 while True: 988 t = None if deadline is None else deadline - time.time() 989 try: 990 plumbing_response = svc.stub.List( 991 req, 992 metadata=svc.parent.get_metadata( 993 'AccountResourcesHistory.List', req), 994 timeout=t) 995 except Exception as e: 996 if self.parent.shouldRetry(tries, e, deadline): 997 tries += 1 998 time.sleep( 999 self.parent.exponentialBackoff(tries, deadline)) 1000 continue 1001 raise plumbing.convert_error_to_porcelain(e) from e 1002 tries = 0 1003 for plumbing_item in plumbing_response.history: 1004 yield plumbing.convert_account_resource_history_to_porcelain( 1005 plumbing_item) 1006 if plumbing_response.meta.next_cursor == '': 1007 break 1008 req.meta.cursor = plumbing_response.meta.next_cursor 1009 1010 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)
971 def list(self, filter, *args, timeout=None): 972 ''' 973 List gets a list of AccountResourceHistory records matching a given set of criteria. 974 ''' 975 deadline = None if timeout is None else time.time() + timeout 976 req = AccountResourceHistoryListRequest() 977 req.meta.CopyFrom(ListRequestMetadata()) 978 if self.parent.page_limit > 0: 979 req.meta.limit = self.parent.page_limit 980 if self.parent.snapshot_datetime is not None: 981 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 982 983 req.filter = plumbing.quote_filter_args(filter, *args) 984 985 def generator(svc, req): 986 tries = 0 987 while True: 988 t = None if deadline is None else deadline - time.time() 989 try: 990 plumbing_response = svc.stub.List( 991 req, 992 metadata=svc.parent.get_metadata( 993 'AccountResourcesHistory.List', req), 994 timeout=t) 995 except Exception as e: 996 if self.parent.shouldRetry(tries, e, deadline): 997 tries += 1 998 time.sleep( 999 self.parent.exponentialBackoff(tries, deadline)) 1000 continue 1001 raise plumbing.convert_error_to_porcelain(e) from e 1002 tries = 0 1003 for plumbing_item in plumbing_response.history: 1004 yield plumbing.convert_account_resource_history_to_porcelain( 1005 plumbing_item) 1006 if plumbing_response.meta.next_cursor == '': 1007 break 1008 req.meta.cursor = plumbing_response.meta.next_cursor 1009 1010 return generator(self, req)
List gets a list of AccountResourceHistory records matching a given set of criteria.
class
Accounts:
1013class Accounts: 1014 ''' 1015 Accounts are users that have access to strongDM. There are two types of accounts: 1016 1. **Users:** humans who are authenticated through username and password or SSO. 1017 2. **Service Accounts:** machines that are authenticated using a service token. 1018 3. **Tokens** are access keys with permissions that can be used for authentication. 1019 See: 1020 `strongdm.models.Service` 1021 `strongdm.models.Token` 1022 `strongdm.models.User` 1023 ''' 1024 def __init__(self, channel, client): 1025 self.parent = client 1026 self.stub = AccountsStub(channel) 1027 1028 def create(self, account, timeout=None): 1029 ''' 1030 Create registers a new Account. 1031 ''' 1032 deadline = None if timeout is None else time.time() + timeout 1033 req = AccountCreateRequest() 1034 1035 if account is not None: 1036 req.account.CopyFrom(plumbing.convert_account_to_plumbing(account)) 1037 tries = 0 1038 plumbing_response = None 1039 while True: 1040 t = None if deadline is None else deadline - time.time() 1041 try: 1042 plumbing_response = self.stub.Create( 1043 req, 1044 metadata=self.parent.get_metadata('Accounts.Create', req), 1045 timeout=t) 1046 except Exception as e: 1047 if self.parent.shouldRetry(tries, e, deadline): 1048 tries += 1 1049 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1050 continue 1051 raise plumbing.convert_error_to_porcelain(e) from e 1052 break 1053 1054 resp = models.AccountCreateResponse() 1055 resp.access_key = (plumbing_response.access_key) 1056 resp.account = plumbing.convert_account_to_porcelain( 1057 plumbing_response.account) 1058 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 1059 plumbing_response.meta) 1060 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1061 plumbing_response.rate_limit) 1062 resp.secret_key = (plumbing_response.secret_key) 1063 resp.token = (plumbing_response.token) 1064 return resp 1065 1066 def get(self, id, timeout=None): 1067 ''' 1068 Get reads one Account by ID. 1069 ''' 1070 deadline = None if timeout is None else time.time() + timeout 1071 req = AccountGetRequest() 1072 if self.parent.snapshot_datetime is not None: 1073 req.meta.CopyFrom(GetRequestMetadata()) 1074 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1075 1076 req.id = (id) 1077 tries = 0 1078 plumbing_response = None 1079 while True: 1080 t = None if deadline is None else deadline - time.time() 1081 try: 1082 plumbing_response = self.stub.Get( 1083 req, 1084 metadata=self.parent.get_metadata('Accounts.Get', req), 1085 timeout=t) 1086 except Exception as e: 1087 if self.parent.shouldRetry(tries, e, deadline): 1088 tries += 1 1089 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1090 continue 1091 raise plumbing.convert_error_to_porcelain(e) from e 1092 break 1093 1094 resp = models.AccountGetResponse() 1095 resp.account = plumbing.convert_account_to_porcelain( 1096 plumbing_response.account) 1097 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1098 plumbing_response.meta) 1099 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1100 plumbing_response.rate_limit) 1101 return resp 1102 1103 def update(self, account, timeout=None): 1104 ''' 1105 Update replaces all the fields of an Account by ID. 1106 ''' 1107 deadline = None if timeout is None else time.time() + timeout 1108 req = AccountUpdateRequest() 1109 1110 if account is not None: 1111 req.account.CopyFrom(plumbing.convert_account_to_plumbing(account)) 1112 tries = 0 1113 plumbing_response = None 1114 while True: 1115 t = None if deadline is None else deadline - time.time() 1116 try: 1117 plumbing_response = self.stub.Update( 1118 req, 1119 metadata=self.parent.get_metadata('Accounts.Update', req), 1120 timeout=t) 1121 except Exception as e: 1122 if self.parent.shouldRetry(tries, e, deadline): 1123 tries += 1 1124 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1125 continue 1126 raise plumbing.convert_error_to_porcelain(e) from e 1127 break 1128 1129 resp = models.AccountUpdateResponse() 1130 resp.account = plumbing.convert_account_to_porcelain( 1131 plumbing_response.account) 1132 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 1133 plumbing_response.meta) 1134 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1135 plumbing_response.rate_limit) 1136 return resp 1137 1138 def delete(self, id, timeout=None): 1139 ''' 1140 Delete removes an Account by ID. 1141 ''' 1142 deadline = None if timeout is None else time.time() + timeout 1143 req = AccountDeleteRequest() 1144 1145 req.id = (id) 1146 tries = 0 1147 plumbing_response = None 1148 while True: 1149 t = None if deadline is None else deadline - time.time() 1150 try: 1151 plumbing_response = self.stub.Delete( 1152 req, 1153 metadata=self.parent.get_metadata('Accounts.Delete', req), 1154 timeout=t) 1155 except Exception as e: 1156 if self.parent.shouldRetry(tries, e, deadline): 1157 tries += 1 1158 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1159 continue 1160 raise plumbing.convert_error_to_porcelain(e) from e 1161 break 1162 1163 resp = models.AccountDeleteResponse() 1164 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 1165 plumbing_response.meta) 1166 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1167 plumbing_response.rate_limit) 1168 return resp 1169 1170 def list(self, filter, *args, timeout=None): 1171 ''' 1172 List gets a list of Accounts matching a given set of criteria. 1173 ''' 1174 deadline = None if timeout is None else time.time() + timeout 1175 req = AccountListRequest() 1176 req.meta.CopyFrom(ListRequestMetadata()) 1177 if self.parent.page_limit > 0: 1178 req.meta.limit = self.parent.page_limit 1179 if self.parent.snapshot_datetime is not None: 1180 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1181 1182 req.filter = plumbing.quote_filter_args(filter, *args) 1183 1184 def generator(svc, req): 1185 tries = 0 1186 while True: 1187 t = None if deadline is None else deadline - time.time() 1188 try: 1189 plumbing_response = svc.stub.List( 1190 req, 1191 metadata=svc.parent.get_metadata('Accounts.List', req), 1192 timeout=t) 1193 except Exception as e: 1194 if self.parent.shouldRetry(tries, e, deadline): 1195 tries += 1 1196 time.sleep( 1197 self.parent.exponentialBackoff(tries, deadline)) 1198 continue 1199 raise plumbing.convert_error_to_porcelain(e) from e 1200 tries = 0 1201 for plumbing_item in plumbing_response.accounts: 1202 yield plumbing.convert_account_to_porcelain(plumbing_item) 1203 if plumbing_response.meta.next_cursor == '': 1204 break 1205 req.meta.cursor = plumbing_response.meta.next_cursor 1206 1207 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)
1028 def create(self, account, timeout=None): 1029 ''' 1030 Create registers a new Account. 1031 ''' 1032 deadline = None if timeout is None else time.time() + timeout 1033 req = AccountCreateRequest() 1034 1035 if account is not None: 1036 req.account.CopyFrom(plumbing.convert_account_to_plumbing(account)) 1037 tries = 0 1038 plumbing_response = None 1039 while True: 1040 t = None if deadline is None else deadline - time.time() 1041 try: 1042 plumbing_response = self.stub.Create( 1043 req, 1044 metadata=self.parent.get_metadata('Accounts.Create', req), 1045 timeout=t) 1046 except Exception as e: 1047 if self.parent.shouldRetry(tries, e, deadline): 1048 tries += 1 1049 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1050 continue 1051 raise plumbing.convert_error_to_porcelain(e) from e 1052 break 1053 1054 resp = models.AccountCreateResponse() 1055 resp.access_key = (plumbing_response.access_key) 1056 resp.account = plumbing.convert_account_to_porcelain( 1057 plumbing_response.account) 1058 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 1059 plumbing_response.meta) 1060 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1061 plumbing_response.rate_limit) 1062 resp.secret_key = (plumbing_response.secret_key) 1063 resp.token = (plumbing_response.token) 1064 return resp
Create registers a new Account.
def
get(self, id, timeout=None)
1066 def get(self, id, timeout=None): 1067 ''' 1068 Get reads one Account by ID. 1069 ''' 1070 deadline = None if timeout is None else time.time() + timeout 1071 req = AccountGetRequest() 1072 if self.parent.snapshot_datetime is not None: 1073 req.meta.CopyFrom(GetRequestMetadata()) 1074 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1075 1076 req.id = (id) 1077 tries = 0 1078 plumbing_response = None 1079 while True: 1080 t = None if deadline is None else deadline - time.time() 1081 try: 1082 plumbing_response = self.stub.Get( 1083 req, 1084 metadata=self.parent.get_metadata('Accounts.Get', req), 1085 timeout=t) 1086 except Exception as e: 1087 if self.parent.shouldRetry(tries, e, deadline): 1088 tries += 1 1089 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1090 continue 1091 raise plumbing.convert_error_to_porcelain(e) from e 1092 break 1093 1094 resp = models.AccountGetResponse() 1095 resp.account = plumbing.convert_account_to_porcelain( 1096 plumbing_response.account) 1097 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1098 plumbing_response.meta) 1099 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1100 plumbing_response.rate_limit) 1101 return resp
Get reads one Account by ID.
def
update(self, account, timeout=None)
1103 def update(self, account, timeout=None): 1104 ''' 1105 Update replaces all the fields of an Account by ID. 1106 ''' 1107 deadline = None if timeout is None else time.time() + timeout 1108 req = AccountUpdateRequest() 1109 1110 if account is not None: 1111 req.account.CopyFrom(plumbing.convert_account_to_plumbing(account)) 1112 tries = 0 1113 plumbing_response = None 1114 while True: 1115 t = None if deadline is None else deadline - time.time() 1116 try: 1117 plumbing_response = self.stub.Update( 1118 req, 1119 metadata=self.parent.get_metadata('Accounts.Update', req), 1120 timeout=t) 1121 except Exception as e: 1122 if self.parent.shouldRetry(tries, e, deadline): 1123 tries += 1 1124 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1125 continue 1126 raise plumbing.convert_error_to_porcelain(e) from e 1127 break 1128 1129 resp = models.AccountUpdateResponse() 1130 resp.account = plumbing.convert_account_to_porcelain( 1131 plumbing_response.account) 1132 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 1133 plumbing_response.meta) 1134 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1135 plumbing_response.rate_limit) 1136 return resp
Update replaces all the fields of an Account by ID.
def
delete(self, id, timeout=None)
1138 def delete(self, id, timeout=None): 1139 ''' 1140 Delete removes an Account by ID. 1141 ''' 1142 deadline = None if timeout is None else time.time() + timeout 1143 req = AccountDeleteRequest() 1144 1145 req.id = (id) 1146 tries = 0 1147 plumbing_response = None 1148 while True: 1149 t = None if deadline is None else deadline - time.time() 1150 try: 1151 plumbing_response = self.stub.Delete( 1152 req, 1153 metadata=self.parent.get_metadata('Accounts.Delete', req), 1154 timeout=t) 1155 except Exception as e: 1156 if self.parent.shouldRetry(tries, e, deadline): 1157 tries += 1 1158 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1159 continue 1160 raise plumbing.convert_error_to_porcelain(e) from e 1161 break 1162 1163 resp = models.AccountDeleteResponse() 1164 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 1165 plumbing_response.meta) 1166 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1167 plumbing_response.rate_limit) 1168 return resp
Delete removes an Account by ID.
def
list(self, filter, *args, timeout=None)
1170 def list(self, filter, *args, timeout=None): 1171 ''' 1172 List gets a list of Accounts matching a given set of criteria. 1173 ''' 1174 deadline = None if timeout is None else time.time() + timeout 1175 req = AccountListRequest() 1176 req.meta.CopyFrom(ListRequestMetadata()) 1177 if self.parent.page_limit > 0: 1178 req.meta.limit = self.parent.page_limit 1179 if self.parent.snapshot_datetime is not None: 1180 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1181 1182 req.filter = plumbing.quote_filter_args(filter, *args) 1183 1184 def generator(svc, req): 1185 tries = 0 1186 while True: 1187 t = None if deadline is None else deadline - time.time() 1188 try: 1189 plumbing_response = svc.stub.List( 1190 req, 1191 metadata=svc.parent.get_metadata('Accounts.List', req), 1192 timeout=t) 1193 except Exception as e: 1194 if self.parent.shouldRetry(tries, e, deadline): 1195 tries += 1 1196 time.sleep( 1197 self.parent.exponentialBackoff(tries, deadline)) 1198 continue 1199 raise plumbing.convert_error_to_porcelain(e) from e 1200 tries = 0 1201 for plumbing_item in plumbing_response.accounts: 1202 yield plumbing.convert_account_to_porcelain(plumbing_item) 1203 if plumbing_response.meta.next_cursor == '': 1204 break 1205 req.meta.cursor = plumbing_response.meta.next_cursor 1206 1207 return generator(self, req)
List gets a list of Accounts matching a given set of criteria.
class
SnapshotAccounts:
1210class SnapshotAccounts: 1211 ''' 1212 SnapshotAccounts exposes the read only methods of the Accounts 1213 service for historical queries. 1214 ''' 1215 def __init__(self, accounts): 1216 self.accounts = accounts 1217 1218 def get(self, id, timeout=None): 1219 ''' 1220 Get reads one Account by ID. 1221 ''' 1222 return self.accounts.get(id, timeout=timeout) 1223 1224 def list(self, filter, *args, timeout=None): 1225 ''' 1226 List gets a list of Accounts matching a given set of criteria. 1227 ''' 1228 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)
1218 def get(self, id, timeout=None): 1219 ''' 1220 Get reads one Account by ID. 1221 ''' 1222 return self.accounts.get(id, timeout=timeout)
Get reads one Account by ID.
def
list(self, filter, *args, timeout=None)
1224 def list(self, filter, *args, timeout=None): 1225 ''' 1226 List gets a list of Accounts matching a given set of criteria. 1227 ''' 1228 return self.accounts.list(filter, *args, timeout=timeout)
List gets a list of Accounts matching a given set of criteria.
class
AccountsGroups:
1231class AccountsGroups: 1232 ''' 1233 An AccountGroup links an account and a group. 1234 See `strongdm.models.AccountGroup`. 1235 ''' 1236 def __init__(self, channel, client): 1237 self.parent = client 1238 self.stub = AccountsGroupsStub(channel) 1239 1240 def create(self, account_group, timeout=None): 1241 ''' 1242 Create create a new AccountGroup. 1243 ''' 1244 deadline = None if timeout is None else time.time() + timeout 1245 req = AccountGroupCreateRequest() 1246 1247 if account_group is not None: 1248 req.account_group.CopyFrom( 1249 plumbing.convert_account_group_to_plumbing(account_group)) 1250 tries = 0 1251 plumbing_response = None 1252 while True: 1253 t = None if deadline is None else deadline - time.time() 1254 try: 1255 plumbing_response = self.stub.Create( 1256 req, 1257 metadata=self.parent.get_metadata('AccountsGroups.Create', 1258 req), 1259 timeout=t) 1260 except Exception as e: 1261 if self.parent.shouldRetry(tries, e, deadline): 1262 tries += 1 1263 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1264 continue 1265 raise plumbing.convert_error_to_porcelain(e) from e 1266 break 1267 1268 resp = models.AccountGroupCreateResponse() 1269 resp.account_group = plumbing.convert_account_group_to_porcelain( 1270 plumbing_response.account_group) 1271 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1272 plumbing_response.rate_limit) 1273 return resp 1274 1275 def get(self, id, timeout=None): 1276 ''' 1277 Get reads one AccountGroup by ID. 1278 ''' 1279 deadline = None if timeout is None else time.time() + timeout 1280 req = AccountGroupGetRequest() 1281 if self.parent.snapshot_datetime is not None: 1282 req.meta.CopyFrom(GetRequestMetadata()) 1283 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1284 1285 req.id = (id) 1286 tries = 0 1287 plumbing_response = None 1288 while True: 1289 t = None if deadline is None else deadline - time.time() 1290 try: 1291 plumbing_response = self.stub.Get( 1292 req, 1293 metadata=self.parent.get_metadata('AccountsGroups.Get', 1294 req), 1295 timeout=t) 1296 except Exception as e: 1297 if self.parent.shouldRetry(tries, e, deadline): 1298 tries += 1 1299 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1300 continue 1301 raise plumbing.convert_error_to_porcelain(e) from e 1302 break 1303 1304 resp = models.AccountGroupGetResponse() 1305 resp.account_group = plumbing.convert_account_group_to_porcelain( 1306 plumbing_response.account_group) 1307 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1308 plumbing_response.meta) 1309 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1310 plumbing_response.rate_limit) 1311 return resp 1312 1313 def delete(self, id, timeout=None): 1314 ''' 1315 Delete removes an AccountGroup by ID. 1316 ''' 1317 deadline = None if timeout is None else time.time() + timeout 1318 req = AccountGroupDeleteRequest() 1319 1320 req.id = (id) 1321 tries = 0 1322 plumbing_response = None 1323 while True: 1324 t = None if deadline is None else deadline - time.time() 1325 try: 1326 plumbing_response = self.stub.Delete( 1327 req, 1328 metadata=self.parent.get_metadata('AccountsGroups.Delete', 1329 req), 1330 timeout=t) 1331 except Exception as e: 1332 if self.parent.shouldRetry(tries, e, deadline): 1333 tries += 1 1334 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1335 continue 1336 raise plumbing.convert_error_to_porcelain(e) from e 1337 break 1338 1339 resp = models.AccountGroupDeleteResponse() 1340 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 1341 plumbing_response.meta) 1342 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1343 plumbing_response.rate_limit) 1344 return resp 1345 1346 def list(self, filter, *args, timeout=None): 1347 ''' 1348 List gets a list of AccountGroups matching a given set of criteria. 1349 ''' 1350 deadline = None if timeout is None else time.time() + timeout 1351 req = AccountGroupListRequest() 1352 req.meta.CopyFrom(ListRequestMetadata()) 1353 if self.parent.page_limit > 0: 1354 req.meta.limit = self.parent.page_limit 1355 if self.parent.snapshot_datetime is not None: 1356 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1357 1358 req.filter = plumbing.quote_filter_args(filter, *args) 1359 1360 def generator(svc, req): 1361 tries = 0 1362 while True: 1363 t = None if deadline is None else deadline - time.time() 1364 try: 1365 plumbing_response = svc.stub.List( 1366 req, 1367 metadata=svc.parent.get_metadata( 1368 'AccountsGroups.List', req), 1369 timeout=t) 1370 except Exception as e: 1371 if self.parent.shouldRetry(tries, e, deadline): 1372 tries += 1 1373 time.sleep( 1374 self.parent.exponentialBackoff(tries, deadline)) 1375 continue 1376 raise plumbing.convert_error_to_porcelain(e) from e 1377 tries = 0 1378 for plumbing_item in plumbing_response.account_groups: 1379 yield plumbing.convert_account_group_to_porcelain( 1380 plumbing_item) 1381 if plumbing_response.meta.next_cursor == '': 1382 break 1383 req.meta.cursor = plumbing_response.meta.next_cursor 1384 1385 return generator(self, req)
An AccountGroup links an account and a group.
See strongdm.models.AccountGroup.
def
create(self, account_group, timeout=None)
1240 def create(self, account_group, timeout=None): 1241 ''' 1242 Create create a new AccountGroup. 1243 ''' 1244 deadline = None if timeout is None else time.time() + timeout 1245 req = AccountGroupCreateRequest() 1246 1247 if account_group is not None: 1248 req.account_group.CopyFrom( 1249 plumbing.convert_account_group_to_plumbing(account_group)) 1250 tries = 0 1251 plumbing_response = None 1252 while True: 1253 t = None if deadline is None else deadline - time.time() 1254 try: 1255 plumbing_response = self.stub.Create( 1256 req, 1257 metadata=self.parent.get_metadata('AccountsGroups.Create', 1258 req), 1259 timeout=t) 1260 except Exception as e: 1261 if self.parent.shouldRetry(tries, e, deadline): 1262 tries += 1 1263 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1264 continue 1265 raise plumbing.convert_error_to_porcelain(e) from e 1266 break 1267 1268 resp = models.AccountGroupCreateResponse() 1269 resp.account_group = plumbing.convert_account_group_to_porcelain( 1270 plumbing_response.account_group) 1271 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1272 plumbing_response.rate_limit) 1273 return resp
Create create a new AccountGroup.
def
get(self, id, timeout=None)
1275 def get(self, id, timeout=None): 1276 ''' 1277 Get reads one AccountGroup by ID. 1278 ''' 1279 deadline = None if timeout is None else time.time() + timeout 1280 req = AccountGroupGetRequest() 1281 if self.parent.snapshot_datetime is not None: 1282 req.meta.CopyFrom(GetRequestMetadata()) 1283 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1284 1285 req.id = (id) 1286 tries = 0 1287 plumbing_response = None 1288 while True: 1289 t = None if deadline is None else deadline - time.time() 1290 try: 1291 plumbing_response = self.stub.Get( 1292 req, 1293 metadata=self.parent.get_metadata('AccountsGroups.Get', 1294 req), 1295 timeout=t) 1296 except Exception as e: 1297 if self.parent.shouldRetry(tries, e, deadline): 1298 tries += 1 1299 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1300 continue 1301 raise plumbing.convert_error_to_porcelain(e) from e 1302 break 1303 1304 resp = models.AccountGroupGetResponse() 1305 resp.account_group = plumbing.convert_account_group_to_porcelain( 1306 plumbing_response.account_group) 1307 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1308 plumbing_response.meta) 1309 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1310 plumbing_response.rate_limit) 1311 return resp
Get reads one AccountGroup by ID.
def
delete(self, id, timeout=None)
1313 def delete(self, id, timeout=None): 1314 ''' 1315 Delete removes an AccountGroup by ID. 1316 ''' 1317 deadline = None if timeout is None else time.time() + timeout 1318 req = AccountGroupDeleteRequest() 1319 1320 req.id = (id) 1321 tries = 0 1322 plumbing_response = None 1323 while True: 1324 t = None if deadline is None else deadline - time.time() 1325 try: 1326 plumbing_response = self.stub.Delete( 1327 req, 1328 metadata=self.parent.get_metadata('AccountsGroups.Delete', 1329 req), 1330 timeout=t) 1331 except Exception as e: 1332 if self.parent.shouldRetry(tries, e, deadline): 1333 tries += 1 1334 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1335 continue 1336 raise plumbing.convert_error_to_porcelain(e) from e 1337 break 1338 1339 resp = models.AccountGroupDeleteResponse() 1340 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 1341 plumbing_response.meta) 1342 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1343 plumbing_response.rate_limit) 1344 return resp
Delete removes an AccountGroup by ID.
def
list(self, filter, *args, timeout=None)
1346 def list(self, filter, *args, timeout=None): 1347 ''' 1348 List gets a list of AccountGroups matching a given set of criteria. 1349 ''' 1350 deadline = None if timeout is None else time.time() + timeout 1351 req = AccountGroupListRequest() 1352 req.meta.CopyFrom(ListRequestMetadata()) 1353 if self.parent.page_limit > 0: 1354 req.meta.limit = self.parent.page_limit 1355 if self.parent.snapshot_datetime is not None: 1356 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1357 1358 req.filter = plumbing.quote_filter_args(filter, *args) 1359 1360 def generator(svc, req): 1361 tries = 0 1362 while True: 1363 t = None if deadline is None else deadline - time.time() 1364 try: 1365 plumbing_response = svc.stub.List( 1366 req, 1367 metadata=svc.parent.get_metadata( 1368 'AccountsGroups.List', req), 1369 timeout=t) 1370 except Exception as e: 1371 if self.parent.shouldRetry(tries, e, deadline): 1372 tries += 1 1373 time.sleep( 1374 self.parent.exponentialBackoff(tries, deadline)) 1375 continue 1376 raise plumbing.convert_error_to_porcelain(e) from e 1377 tries = 0 1378 for plumbing_item in plumbing_response.account_groups: 1379 yield plumbing.convert_account_group_to_porcelain( 1380 plumbing_item) 1381 if plumbing_response.meta.next_cursor == '': 1382 break 1383 req.meta.cursor = plumbing_response.meta.next_cursor 1384 1385 return generator(self, req)
List gets a list of AccountGroups matching a given set of criteria.
class
SnapshotAccountsGroups:
1388class SnapshotAccountsGroups: 1389 ''' 1390 SnapshotAccountsGroups exposes the read only methods of the AccountsGroups 1391 service for historical queries. 1392 ''' 1393 def __init__(self, accounts_groups): 1394 self.accounts_groups = accounts_groups 1395 1396 def get(self, id, timeout=None): 1397 ''' 1398 Get reads one AccountGroup by ID. 1399 ''' 1400 return self.accounts_groups.get(id, timeout=timeout) 1401 1402 def list(self, filter, *args, timeout=None): 1403 ''' 1404 List gets a list of AccountGroups matching a given set of criteria. 1405 ''' 1406 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)
1396 def get(self, id, timeout=None): 1397 ''' 1398 Get reads one AccountGroup by ID. 1399 ''' 1400 return self.accounts_groups.get(id, timeout=timeout)
Get reads one AccountGroup by ID.
def
list(self, filter, *args, timeout=None)
1402 def list(self, filter, *args, timeout=None): 1403 ''' 1404 List gets a list of AccountGroups matching a given set of criteria. 1405 ''' 1406 return self.accounts_groups.list(filter, *args, timeout=timeout)
List gets a list of AccountGroups matching a given set of criteria.
class
AccountsGroupsHistory:
1409class AccountsGroupsHistory: 1410 ''' 1411 AccountsGroupsHistory records all changes to the state of an AccountGroup. 1412 See `strongdm.models.AccountGroupHistory`. 1413 ''' 1414 def __init__(self, channel, client): 1415 self.parent = client 1416 self.stub = AccountsGroupsHistoryStub(channel) 1417 1418 def list(self, filter, *args, timeout=None): 1419 ''' 1420 List gets a list of AccountGroupHistory records matching a given set of criteria. 1421 ''' 1422 deadline = None if timeout is None else time.time() + timeout 1423 req = AccountGroupHistoryListRequest() 1424 req.meta.CopyFrom(ListRequestMetadata()) 1425 if self.parent.page_limit > 0: 1426 req.meta.limit = self.parent.page_limit 1427 if self.parent.snapshot_datetime is not None: 1428 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1429 1430 req.filter = plumbing.quote_filter_args(filter, *args) 1431 1432 def generator(svc, req): 1433 tries = 0 1434 while True: 1435 t = None if deadline is None else deadline - time.time() 1436 try: 1437 plumbing_response = svc.stub.List( 1438 req, 1439 metadata=svc.parent.get_metadata( 1440 'AccountsGroupsHistory.List', req), 1441 timeout=t) 1442 except Exception as e: 1443 if self.parent.shouldRetry(tries, e, deadline): 1444 tries += 1 1445 time.sleep( 1446 self.parent.exponentialBackoff(tries, deadline)) 1447 continue 1448 raise plumbing.convert_error_to_porcelain(e) from e 1449 tries = 0 1450 for plumbing_item in plumbing_response.history: 1451 yield plumbing.convert_account_group_history_to_porcelain( 1452 plumbing_item) 1453 if plumbing_response.meta.next_cursor == '': 1454 break 1455 req.meta.cursor = plumbing_response.meta.next_cursor 1456 1457 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)
1418 def list(self, filter, *args, timeout=None): 1419 ''' 1420 List gets a list of AccountGroupHistory records matching a given set of criteria. 1421 ''' 1422 deadline = None if timeout is None else time.time() + timeout 1423 req = AccountGroupHistoryListRequest() 1424 req.meta.CopyFrom(ListRequestMetadata()) 1425 if self.parent.page_limit > 0: 1426 req.meta.limit = self.parent.page_limit 1427 if self.parent.snapshot_datetime is not None: 1428 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1429 1430 req.filter = plumbing.quote_filter_args(filter, *args) 1431 1432 def generator(svc, req): 1433 tries = 0 1434 while True: 1435 t = None if deadline is None else deadline - time.time() 1436 try: 1437 plumbing_response = svc.stub.List( 1438 req, 1439 metadata=svc.parent.get_metadata( 1440 'AccountsGroupsHistory.List', req), 1441 timeout=t) 1442 except Exception as e: 1443 if self.parent.shouldRetry(tries, e, deadline): 1444 tries += 1 1445 time.sleep( 1446 self.parent.exponentialBackoff(tries, deadline)) 1447 continue 1448 raise plumbing.convert_error_to_porcelain(e) from e 1449 tries = 0 1450 for plumbing_item in plumbing_response.history: 1451 yield plumbing.convert_account_group_history_to_porcelain( 1452 plumbing_item) 1453 if plumbing_response.meta.next_cursor == '': 1454 break 1455 req.meta.cursor = plumbing_response.meta.next_cursor 1456 1457 return generator(self, req)
List gets a list of AccountGroupHistory records matching a given set of criteria.
class
AccountsHistory:
1460class AccountsHistory: 1461 ''' 1462 AccountsHistory records all changes to the state of an Account. 1463 See `strongdm.models.AccountHistory`. 1464 ''' 1465 def __init__(self, channel, client): 1466 self.parent = client 1467 self.stub = AccountsHistoryStub(channel) 1468 1469 def list(self, filter, *args, timeout=None): 1470 ''' 1471 List gets a list of AccountHistory records matching a given set of criteria. 1472 ''' 1473 deadline = None if timeout is None else time.time() + timeout 1474 req = AccountHistoryListRequest() 1475 req.meta.CopyFrom(ListRequestMetadata()) 1476 if self.parent.page_limit > 0: 1477 req.meta.limit = self.parent.page_limit 1478 if self.parent.snapshot_datetime is not None: 1479 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1480 1481 req.filter = plumbing.quote_filter_args(filter, *args) 1482 1483 def generator(svc, req): 1484 tries = 0 1485 while True: 1486 t = None if deadline is None else deadline - time.time() 1487 try: 1488 plumbing_response = svc.stub.List( 1489 req, 1490 metadata=svc.parent.get_metadata( 1491 'AccountsHistory.List', req), 1492 timeout=t) 1493 except Exception as e: 1494 if self.parent.shouldRetry(tries, e, deadline): 1495 tries += 1 1496 time.sleep( 1497 self.parent.exponentialBackoff(tries, deadline)) 1498 continue 1499 raise plumbing.convert_error_to_porcelain(e) from e 1500 tries = 0 1501 for plumbing_item in plumbing_response.history: 1502 yield plumbing.convert_account_history_to_porcelain( 1503 plumbing_item) 1504 if plumbing_response.meta.next_cursor == '': 1505 break 1506 req.meta.cursor = plumbing_response.meta.next_cursor 1507 1508 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)
1469 def list(self, filter, *args, timeout=None): 1470 ''' 1471 List gets a list of AccountHistory records matching a given set of criteria. 1472 ''' 1473 deadline = None if timeout is None else time.time() + timeout 1474 req = AccountHistoryListRequest() 1475 req.meta.CopyFrom(ListRequestMetadata()) 1476 if self.parent.page_limit > 0: 1477 req.meta.limit = self.parent.page_limit 1478 if self.parent.snapshot_datetime is not None: 1479 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1480 1481 req.filter = plumbing.quote_filter_args(filter, *args) 1482 1483 def generator(svc, req): 1484 tries = 0 1485 while True: 1486 t = None if deadline is None else deadline - time.time() 1487 try: 1488 plumbing_response = svc.stub.List( 1489 req, 1490 metadata=svc.parent.get_metadata( 1491 'AccountsHistory.List', req), 1492 timeout=t) 1493 except Exception as e: 1494 if self.parent.shouldRetry(tries, e, deadline): 1495 tries += 1 1496 time.sleep( 1497 self.parent.exponentialBackoff(tries, deadline)) 1498 continue 1499 raise plumbing.convert_error_to_porcelain(e) from e 1500 tries = 0 1501 for plumbing_item in plumbing_response.history: 1502 yield plumbing.convert_account_history_to_porcelain( 1503 plumbing_item) 1504 if plumbing_response.meta.next_cursor == '': 1505 break 1506 req.meta.cursor = plumbing_response.meta.next_cursor 1507 1508 return generator(self, req)
List gets a list of AccountHistory records matching a given set of criteria.
class
Activities:
1511class Activities: 1512 ''' 1513 An Activity is a record of an action taken against a strongDM deployment, e.g. 1514 a user creation, resource deletion, sso configuration change, etc. The Activities 1515 service is read-only. 1516 See `strongdm.models.Activity`. 1517 ''' 1518 def __init__(self, channel, client): 1519 self.parent = client 1520 self.stub = ActivitiesStub(channel) 1521 1522 def get(self, id, timeout=None): 1523 ''' 1524 Get reads one Activity by ID. 1525 ''' 1526 deadline = None if timeout is None else time.time() + timeout 1527 req = ActivityGetRequest() 1528 if self.parent.snapshot_datetime is not None: 1529 req.meta.CopyFrom(GetRequestMetadata()) 1530 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1531 1532 req.id = (id) 1533 tries = 0 1534 plumbing_response = None 1535 while True: 1536 t = None if deadline is None else deadline - time.time() 1537 try: 1538 plumbing_response = self.stub.Get( 1539 req, 1540 metadata=self.parent.get_metadata('Activities.Get', req), 1541 timeout=t) 1542 except Exception as e: 1543 if self.parent.shouldRetry(tries, e, deadline): 1544 tries += 1 1545 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1546 continue 1547 raise plumbing.convert_error_to_porcelain(e) from e 1548 break 1549 1550 resp = models.ActivityGetResponse() 1551 resp.activity = plumbing.convert_activity_to_porcelain( 1552 plumbing_response.activity) 1553 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1554 plumbing_response.meta) 1555 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1556 plumbing_response.rate_limit) 1557 return resp 1558 1559 def list(self, filter, *args, timeout=None): 1560 ''' 1561 List gets a list of Activities matching a given set of criteria. 1562 The 'before' and 'after' filters can be used to control the time 1563 range of the output activities. If not provided, one week of back 1564 of activities will be returned. 1565 ''' 1566 deadline = None if timeout is None else time.time() + timeout 1567 req = ActivityListRequest() 1568 req.meta.CopyFrom(ListRequestMetadata()) 1569 if self.parent.page_limit > 0: 1570 req.meta.limit = self.parent.page_limit 1571 if self.parent.snapshot_datetime is not None: 1572 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1573 1574 req.filter = plumbing.quote_filter_args(filter, *args) 1575 1576 def generator(svc, req): 1577 tries = 0 1578 while True: 1579 t = None if deadline is None else deadline - time.time() 1580 try: 1581 plumbing_response = svc.stub.List( 1582 req, 1583 metadata=svc.parent.get_metadata( 1584 'Activities.List', req), 1585 timeout=t) 1586 except Exception as e: 1587 if self.parent.shouldRetry(tries, e, deadline): 1588 tries += 1 1589 time.sleep( 1590 self.parent.exponentialBackoff(tries, deadline)) 1591 continue 1592 raise plumbing.convert_error_to_porcelain(e) from e 1593 tries = 0 1594 for plumbing_item in plumbing_response.activities: 1595 yield plumbing.convert_activity_to_porcelain(plumbing_item) 1596 if plumbing_response.meta.next_cursor == '': 1597 break 1598 req.meta.cursor = plumbing_response.meta.next_cursor 1599 1600 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)
1522 def get(self, id, timeout=None): 1523 ''' 1524 Get reads one Activity by ID. 1525 ''' 1526 deadline = None if timeout is None else time.time() + timeout 1527 req = ActivityGetRequest() 1528 if self.parent.snapshot_datetime is not None: 1529 req.meta.CopyFrom(GetRequestMetadata()) 1530 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1531 1532 req.id = (id) 1533 tries = 0 1534 plumbing_response = None 1535 while True: 1536 t = None if deadline is None else deadline - time.time() 1537 try: 1538 plumbing_response = self.stub.Get( 1539 req, 1540 metadata=self.parent.get_metadata('Activities.Get', req), 1541 timeout=t) 1542 except Exception as e: 1543 if self.parent.shouldRetry(tries, e, deadline): 1544 tries += 1 1545 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1546 continue 1547 raise plumbing.convert_error_to_porcelain(e) from e 1548 break 1549 1550 resp = models.ActivityGetResponse() 1551 resp.activity = plumbing.convert_activity_to_porcelain( 1552 plumbing_response.activity) 1553 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1554 plumbing_response.meta) 1555 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1556 plumbing_response.rate_limit) 1557 return resp
Get reads one Activity by ID.
def
list(self, filter, *args, timeout=None)
1559 def list(self, filter, *args, timeout=None): 1560 ''' 1561 List gets a list of Activities matching a given set of criteria. 1562 The 'before' and 'after' filters can be used to control the time 1563 range of the output activities. If not provided, one week of back 1564 of activities will be returned. 1565 ''' 1566 deadline = None if timeout is None else time.time() + timeout 1567 req = ActivityListRequest() 1568 req.meta.CopyFrom(ListRequestMetadata()) 1569 if self.parent.page_limit > 0: 1570 req.meta.limit = self.parent.page_limit 1571 if self.parent.snapshot_datetime is not None: 1572 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1573 1574 req.filter = plumbing.quote_filter_args(filter, *args) 1575 1576 def generator(svc, req): 1577 tries = 0 1578 while True: 1579 t = None if deadline is None else deadline - time.time() 1580 try: 1581 plumbing_response = svc.stub.List( 1582 req, 1583 metadata=svc.parent.get_metadata( 1584 'Activities.List', req), 1585 timeout=t) 1586 except Exception as e: 1587 if self.parent.shouldRetry(tries, e, deadline): 1588 tries += 1 1589 time.sleep( 1590 self.parent.exponentialBackoff(tries, deadline)) 1591 continue 1592 raise plumbing.convert_error_to_porcelain(e) from e 1593 tries = 0 1594 for plumbing_item in plumbing_response.activities: 1595 yield plumbing.convert_activity_to_porcelain(plumbing_item) 1596 if plumbing_response.meta.next_cursor == '': 1597 break 1598 req.meta.cursor = plumbing_response.meta.next_cursor 1599 1600 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:
1603class ApprovalWorkflowApprovers: 1604 ''' 1605 ApprovalWorkflowApprovers link approval workflow approvers to an ApprovalWorkflowStep 1606 See `strongdm.models.ApprovalWorkflowApprover`. 1607 ''' 1608 def __init__(self, channel, client): 1609 self.parent = client 1610 self.stub = ApprovalWorkflowApproversStub(channel) 1611 1612 def create(self, approval_workflow_approver, timeout=None): 1613 ''' 1614 Deprecated: Create creates a new approval workflow approver. 1615 ''' 1616 deadline = None if timeout is None else time.time() + timeout 1617 req = ApprovalWorkflowApproverCreateRequest() 1618 1619 if approval_workflow_approver is not None: 1620 req.approval_workflow_approver.CopyFrom( 1621 plumbing.convert_approval_workflow_approver_to_plumbing( 1622 approval_workflow_approver)) 1623 tries = 0 1624 plumbing_response = None 1625 while True: 1626 t = None if deadline is None else deadline - time.time() 1627 try: 1628 plumbing_response = self.stub.Create( 1629 req, 1630 metadata=self.parent.get_metadata( 1631 'ApprovalWorkflowApprovers.Create', req), 1632 timeout=t) 1633 except Exception as e: 1634 if self.parent.shouldRetry(tries, e, deadline): 1635 tries += 1 1636 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1637 continue 1638 raise plumbing.convert_error_to_porcelain(e) from e 1639 break 1640 1641 resp = models.ApprovalWorkflowApproverCreateResponse() 1642 resp.approval_workflow_approver = plumbing.convert_approval_workflow_approver_to_porcelain( 1643 plumbing_response.approval_workflow_approver) 1644 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1645 plumbing_response.rate_limit) 1646 return resp 1647 1648 def get(self, id, timeout=None): 1649 ''' 1650 Deprecated: Get reads one approval workflow approver by ID. 1651 ''' 1652 deadline = None if timeout is None else time.time() + timeout 1653 req = ApprovalWorkflowApproverGetRequest() 1654 if self.parent.snapshot_datetime is not None: 1655 req.meta.CopyFrom(GetRequestMetadata()) 1656 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1657 1658 req.id = (id) 1659 tries = 0 1660 plumbing_response = None 1661 while True: 1662 t = None if deadline is None else deadline - time.time() 1663 try: 1664 plumbing_response = self.stub.Get( 1665 req, 1666 metadata=self.parent.get_metadata( 1667 'ApprovalWorkflowApprovers.Get', req), 1668 timeout=t) 1669 except Exception as e: 1670 if self.parent.shouldRetry(tries, e, deadline): 1671 tries += 1 1672 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1673 continue 1674 raise plumbing.convert_error_to_porcelain(e) from e 1675 break 1676 1677 resp = models.ApprovalWorkflowApproverGetResponse() 1678 resp.approval_workflow_approver = plumbing.convert_approval_workflow_approver_to_porcelain( 1679 plumbing_response.approval_workflow_approver) 1680 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1681 plumbing_response.meta) 1682 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1683 plumbing_response.rate_limit) 1684 return resp 1685 1686 def delete(self, id, timeout=None): 1687 ''' 1688 Deprecated: Delete deletes an existing approval workflow approver. 1689 ''' 1690 deadline = None if timeout is None else time.time() + timeout 1691 req = ApprovalWorkflowApproverDeleteRequest() 1692 1693 req.id = (id) 1694 tries = 0 1695 plumbing_response = None 1696 while True: 1697 t = None if deadline is None else deadline - time.time() 1698 try: 1699 plumbing_response = self.stub.Delete( 1700 req, 1701 metadata=self.parent.get_metadata( 1702 'ApprovalWorkflowApprovers.Delete', req), 1703 timeout=t) 1704 except Exception as e: 1705 if self.parent.shouldRetry(tries, e, deadline): 1706 tries += 1 1707 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1708 continue 1709 raise plumbing.convert_error_to_porcelain(e) from e 1710 break 1711 1712 resp = models.ApprovalWorkflowApproverDeleteResponse() 1713 resp.id = (plumbing_response.id) 1714 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1715 plumbing_response.rate_limit) 1716 return resp 1717 1718 def list(self, filter, *args, timeout=None): 1719 ''' 1720 Deprecated: Lists existing approval workflow approvers. 1721 ''' 1722 deadline = None if timeout is None else time.time() + timeout 1723 req = ApprovalWorkflowApproverListRequest() 1724 req.meta.CopyFrom(ListRequestMetadata()) 1725 if self.parent.page_limit > 0: 1726 req.meta.limit = self.parent.page_limit 1727 if self.parent.snapshot_datetime is not None: 1728 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1729 1730 req.filter = plumbing.quote_filter_args(filter, *args) 1731 1732 def generator(svc, req): 1733 tries = 0 1734 while True: 1735 t = None if deadline is None else deadline - time.time() 1736 try: 1737 plumbing_response = svc.stub.List( 1738 req, 1739 metadata=svc.parent.get_metadata( 1740 'ApprovalWorkflowApprovers.List', req), 1741 timeout=t) 1742 except Exception as e: 1743 if self.parent.shouldRetry(tries, e, deadline): 1744 tries += 1 1745 time.sleep( 1746 self.parent.exponentialBackoff(tries, deadline)) 1747 continue 1748 raise plumbing.convert_error_to_porcelain(e) from e 1749 tries = 0 1750 for plumbing_item in plumbing_response.approval_workflow_approvers: 1751 yield plumbing.convert_approval_workflow_approver_to_porcelain( 1752 plumbing_item) 1753 if plumbing_response.meta.next_cursor == '': 1754 break 1755 req.meta.cursor = plumbing_response.meta.next_cursor 1756 1757 return generator(self, req)
ApprovalWorkflowApprovers link approval workflow approvers to an ApprovalWorkflowStep
See strongdm.models.ApprovalWorkflowApprover.
def
create(self, approval_workflow_approver, timeout=None)
1612 def create(self, approval_workflow_approver, timeout=None): 1613 ''' 1614 Deprecated: Create creates a new approval workflow approver. 1615 ''' 1616 deadline = None if timeout is None else time.time() + timeout 1617 req = ApprovalWorkflowApproverCreateRequest() 1618 1619 if approval_workflow_approver is not None: 1620 req.approval_workflow_approver.CopyFrom( 1621 plumbing.convert_approval_workflow_approver_to_plumbing( 1622 approval_workflow_approver)) 1623 tries = 0 1624 plumbing_response = None 1625 while True: 1626 t = None if deadline is None else deadline - time.time() 1627 try: 1628 plumbing_response = self.stub.Create( 1629 req, 1630 metadata=self.parent.get_metadata( 1631 'ApprovalWorkflowApprovers.Create', req), 1632 timeout=t) 1633 except Exception as e: 1634 if self.parent.shouldRetry(tries, e, deadline): 1635 tries += 1 1636 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1637 continue 1638 raise plumbing.convert_error_to_porcelain(e) from e 1639 break 1640 1641 resp = models.ApprovalWorkflowApproverCreateResponse() 1642 resp.approval_workflow_approver = plumbing.convert_approval_workflow_approver_to_porcelain( 1643 plumbing_response.approval_workflow_approver) 1644 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1645 plumbing_response.rate_limit) 1646 return resp
Deprecated: Create creates a new approval workflow approver.
def
get(self, id, timeout=None)
1648 def get(self, id, timeout=None): 1649 ''' 1650 Deprecated: Get reads one approval workflow approver by ID. 1651 ''' 1652 deadline = None if timeout is None else time.time() + timeout 1653 req = ApprovalWorkflowApproverGetRequest() 1654 if self.parent.snapshot_datetime is not None: 1655 req.meta.CopyFrom(GetRequestMetadata()) 1656 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1657 1658 req.id = (id) 1659 tries = 0 1660 plumbing_response = None 1661 while True: 1662 t = None if deadline is None else deadline - time.time() 1663 try: 1664 plumbing_response = self.stub.Get( 1665 req, 1666 metadata=self.parent.get_metadata( 1667 'ApprovalWorkflowApprovers.Get', req), 1668 timeout=t) 1669 except Exception as e: 1670 if self.parent.shouldRetry(tries, e, deadline): 1671 tries += 1 1672 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1673 continue 1674 raise plumbing.convert_error_to_porcelain(e) from e 1675 break 1676 1677 resp = models.ApprovalWorkflowApproverGetResponse() 1678 resp.approval_workflow_approver = plumbing.convert_approval_workflow_approver_to_porcelain( 1679 plumbing_response.approval_workflow_approver) 1680 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1681 plumbing_response.meta) 1682 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1683 plumbing_response.rate_limit) 1684 return resp
Deprecated: Get reads one approval workflow approver by ID.
def
delete(self, id, timeout=None)
1686 def delete(self, id, timeout=None): 1687 ''' 1688 Deprecated: Delete deletes an existing approval workflow approver. 1689 ''' 1690 deadline = None if timeout is None else time.time() + timeout 1691 req = ApprovalWorkflowApproverDeleteRequest() 1692 1693 req.id = (id) 1694 tries = 0 1695 plumbing_response = None 1696 while True: 1697 t = None if deadline is None else deadline - time.time() 1698 try: 1699 plumbing_response = self.stub.Delete( 1700 req, 1701 metadata=self.parent.get_metadata( 1702 'ApprovalWorkflowApprovers.Delete', req), 1703 timeout=t) 1704 except Exception as e: 1705 if self.parent.shouldRetry(tries, e, deadline): 1706 tries += 1 1707 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1708 continue 1709 raise plumbing.convert_error_to_porcelain(e) from e 1710 break 1711 1712 resp = models.ApprovalWorkflowApproverDeleteResponse() 1713 resp.id = (plumbing_response.id) 1714 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1715 plumbing_response.rate_limit) 1716 return resp
Deprecated: Delete deletes an existing approval workflow approver.
def
list(self, filter, *args, timeout=None)
1718 def list(self, filter, *args, timeout=None): 1719 ''' 1720 Deprecated: Lists existing approval workflow approvers. 1721 ''' 1722 deadline = None if timeout is None else time.time() + timeout 1723 req = ApprovalWorkflowApproverListRequest() 1724 req.meta.CopyFrom(ListRequestMetadata()) 1725 if self.parent.page_limit > 0: 1726 req.meta.limit = self.parent.page_limit 1727 if self.parent.snapshot_datetime is not None: 1728 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1729 1730 req.filter = plumbing.quote_filter_args(filter, *args) 1731 1732 def generator(svc, req): 1733 tries = 0 1734 while True: 1735 t = None if deadline is None else deadline - time.time() 1736 try: 1737 plumbing_response = svc.stub.List( 1738 req, 1739 metadata=svc.parent.get_metadata( 1740 'ApprovalWorkflowApprovers.List', req), 1741 timeout=t) 1742 except Exception as e: 1743 if self.parent.shouldRetry(tries, e, deadline): 1744 tries += 1 1745 time.sleep( 1746 self.parent.exponentialBackoff(tries, deadline)) 1747 continue 1748 raise plumbing.convert_error_to_porcelain(e) from e 1749 tries = 0 1750 for plumbing_item in plumbing_response.approval_workflow_approvers: 1751 yield plumbing.convert_approval_workflow_approver_to_porcelain( 1752 plumbing_item) 1753 if plumbing_response.meta.next_cursor == '': 1754 break 1755 req.meta.cursor = plumbing_response.meta.next_cursor 1756 1757 return generator(self, req)
Deprecated: Lists existing approval workflow approvers.
class
SnapshotApprovalWorkflowApprovers:
1760class SnapshotApprovalWorkflowApprovers: 1761 ''' 1762 SnapshotApprovalWorkflowApprovers exposes the read only methods of the ApprovalWorkflowApprovers 1763 service for historical queries. 1764 ''' 1765 def __init__(self, approval_workflow_approvers): 1766 self.approval_workflow_approvers = approval_workflow_approvers 1767 1768 def get(self, id, timeout=None): 1769 ''' 1770 Deprecated: Get reads one approval workflow approver by ID. 1771 ''' 1772 return self.approval_workflow_approvers.get(id, timeout=timeout) 1773 1774 def list(self, filter, *args, timeout=None): 1775 ''' 1776 Deprecated: Lists existing approval workflow approvers. 1777 ''' 1778 return self.approval_workflow_approvers.list(filter, 1779 *args, 1780 timeout=timeout)
SnapshotApprovalWorkflowApprovers exposes the read only methods of the ApprovalWorkflowApprovers service for historical queries.
def
get(self, id, timeout=None)
1768 def get(self, id, timeout=None): 1769 ''' 1770 Deprecated: Get reads one approval workflow approver by ID. 1771 ''' 1772 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)
1774 def list(self, filter, *args, timeout=None): 1775 ''' 1776 Deprecated: Lists existing approval workflow approvers. 1777 ''' 1778 return self.approval_workflow_approvers.list(filter, 1779 *args, 1780 timeout=timeout)
Deprecated: Lists existing approval workflow approvers.
class
ApprovalWorkflowApproversHistory:
1783class ApprovalWorkflowApproversHistory: 1784 ''' 1785 ApprovalWorkflowApproversHistory records all changes to the state of an ApprovalWorkflowApprover. 1786 See `strongdm.models.ApprovalWorkflowApproverHistory`. 1787 ''' 1788 def __init__(self, channel, client): 1789 self.parent = client 1790 self.stub = ApprovalWorkflowApproversHistoryStub(channel) 1791 1792 def list(self, filter, *args, timeout=None): 1793 ''' 1794 List gets a list of ApprovalWorkflowApproverHistory records matching a given set of criteria. 1795 ''' 1796 deadline = None if timeout is None else time.time() + timeout 1797 req = ApprovalWorkflowApproverHistoryListRequest() 1798 req.meta.CopyFrom(ListRequestMetadata()) 1799 if self.parent.page_limit > 0: 1800 req.meta.limit = self.parent.page_limit 1801 if self.parent.snapshot_datetime is not None: 1802 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1803 1804 req.filter = plumbing.quote_filter_args(filter, *args) 1805 1806 def generator(svc, req): 1807 tries = 0 1808 while True: 1809 t = None if deadline is None else deadline - time.time() 1810 try: 1811 plumbing_response = svc.stub.List( 1812 req, 1813 metadata=svc.parent.get_metadata( 1814 'ApprovalWorkflowApproversHistory.List', req), 1815 timeout=t) 1816 except Exception as e: 1817 if self.parent.shouldRetry(tries, e, deadline): 1818 tries += 1 1819 time.sleep( 1820 self.parent.exponentialBackoff(tries, deadline)) 1821 continue 1822 raise plumbing.convert_error_to_porcelain(e) from e 1823 tries = 0 1824 for plumbing_item in plumbing_response.history: 1825 yield plumbing.convert_approval_workflow_approver_history_to_porcelain( 1826 plumbing_item) 1827 if plumbing_response.meta.next_cursor == '': 1828 break 1829 req.meta.cursor = plumbing_response.meta.next_cursor 1830 1831 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)
1792 def list(self, filter, *args, timeout=None): 1793 ''' 1794 List gets a list of ApprovalWorkflowApproverHistory records matching a given set of criteria. 1795 ''' 1796 deadline = None if timeout is None else time.time() + timeout 1797 req = ApprovalWorkflowApproverHistoryListRequest() 1798 req.meta.CopyFrom(ListRequestMetadata()) 1799 if self.parent.page_limit > 0: 1800 req.meta.limit = self.parent.page_limit 1801 if self.parent.snapshot_datetime is not None: 1802 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1803 1804 req.filter = plumbing.quote_filter_args(filter, *args) 1805 1806 def generator(svc, req): 1807 tries = 0 1808 while True: 1809 t = None if deadline is None else deadline - time.time() 1810 try: 1811 plumbing_response = svc.stub.List( 1812 req, 1813 metadata=svc.parent.get_metadata( 1814 'ApprovalWorkflowApproversHistory.List', req), 1815 timeout=t) 1816 except Exception as e: 1817 if self.parent.shouldRetry(tries, e, deadline): 1818 tries += 1 1819 time.sleep( 1820 self.parent.exponentialBackoff(tries, deadline)) 1821 continue 1822 raise plumbing.convert_error_to_porcelain(e) from e 1823 tries = 0 1824 for plumbing_item in plumbing_response.history: 1825 yield plumbing.convert_approval_workflow_approver_history_to_porcelain( 1826 plumbing_item) 1827 if plumbing_response.meta.next_cursor == '': 1828 break 1829 req.meta.cursor = plumbing_response.meta.next_cursor 1830 1831 return generator(self, req)
List gets a list of ApprovalWorkflowApproverHistory records matching a given set of criteria.
class
ApprovalWorkflowSteps:
1834class ApprovalWorkflowSteps: 1835 ''' 1836 ApprovalWorkflowSteps link approval workflow steps to an ApprovalWorkflow 1837 See `strongdm.models.ApprovalWorkflowStep`. 1838 ''' 1839 def __init__(self, channel, client): 1840 self.parent = client 1841 self.stub = ApprovalWorkflowStepsStub(channel) 1842 1843 def create(self, approval_workflow_step, timeout=None): 1844 ''' 1845 Deprecated: Create creates a new approval workflow step. 1846 ''' 1847 deadline = None if timeout is None else time.time() + timeout 1848 req = ApprovalWorkflowStepCreateRequest() 1849 1850 if approval_workflow_step is not None: 1851 req.approval_workflow_step.CopyFrom( 1852 plumbing.convert_approval_workflow_step_to_plumbing( 1853 approval_workflow_step)) 1854 tries = 0 1855 plumbing_response = None 1856 while True: 1857 t = None if deadline is None else deadline - time.time() 1858 try: 1859 plumbing_response = self.stub.Create( 1860 req, 1861 metadata=self.parent.get_metadata( 1862 'ApprovalWorkflowSteps.Create', req), 1863 timeout=t) 1864 except Exception as e: 1865 if self.parent.shouldRetry(tries, e, deadline): 1866 tries += 1 1867 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1868 continue 1869 raise plumbing.convert_error_to_porcelain(e) from e 1870 break 1871 1872 resp = models.ApprovalWorkflowStepCreateResponse() 1873 resp.approval_workflow_step = plumbing.convert_approval_workflow_step_to_porcelain( 1874 plumbing_response.approval_workflow_step) 1875 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1876 plumbing_response.rate_limit) 1877 return resp 1878 1879 def get(self, id, timeout=None): 1880 ''' 1881 Deprecated: Get reads one approval workflow step by ID. 1882 ''' 1883 deadline = None if timeout is None else time.time() + timeout 1884 req = ApprovalWorkflowStepGetRequest() 1885 if self.parent.snapshot_datetime is not None: 1886 req.meta.CopyFrom(GetRequestMetadata()) 1887 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1888 1889 req.id = (id) 1890 tries = 0 1891 plumbing_response = None 1892 while True: 1893 t = None if deadline is None else deadline - time.time() 1894 try: 1895 plumbing_response = self.stub.Get( 1896 req, 1897 metadata=self.parent.get_metadata( 1898 'ApprovalWorkflowSteps.Get', req), 1899 timeout=t) 1900 except Exception as e: 1901 if self.parent.shouldRetry(tries, e, deadline): 1902 tries += 1 1903 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1904 continue 1905 raise plumbing.convert_error_to_porcelain(e) from e 1906 break 1907 1908 resp = models.ApprovalWorkflowStepGetResponse() 1909 resp.approval_workflow_step = plumbing.convert_approval_workflow_step_to_porcelain( 1910 plumbing_response.approval_workflow_step) 1911 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1912 plumbing_response.meta) 1913 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1914 plumbing_response.rate_limit) 1915 return resp 1916 1917 def delete(self, id, timeout=None): 1918 ''' 1919 Deprecated: Delete deletes an existing approval workflow step. 1920 ''' 1921 deadline = None if timeout is None else time.time() + timeout 1922 req = ApprovalWorkflowStepDeleteRequest() 1923 1924 req.id = (id) 1925 tries = 0 1926 plumbing_response = None 1927 while True: 1928 t = None if deadline is None else deadline - time.time() 1929 try: 1930 plumbing_response = self.stub.Delete( 1931 req, 1932 metadata=self.parent.get_metadata( 1933 'ApprovalWorkflowSteps.Delete', req), 1934 timeout=t) 1935 except Exception as e: 1936 if self.parent.shouldRetry(tries, e, deadline): 1937 tries += 1 1938 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1939 continue 1940 raise plumbing.convert_error_to_porcelain(e) from e 1941 break 1942 1943 resp = models.ApprovalWorkflowStepDeleteResponse() 1944 resp.id = (plumbing_response.id) 1945 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1946 plumbing_response.rate_limit) 1947 return resp 1948 1949 def list(self, filter, *args, timeout=None): 1950 ''' 1951 Deprecated: Lists existing approval workflow steps. 1952 ''' 1953 deadline = None if timeout is None else time.time() + timeout 1954 req = ApprovalWorkflowStepListRequest() 1955 req.meta.CopyFrom(ListRequestMetadata()) 1956 if self.parent.page_limit > 0: 1957 req.meta.limit = self.parent.page_limit 1958 if self.parent.snapshot_datetime is not None: 1959 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1960 1961 req.filter = plumbing.quote_filter_args(filter, *args) 1962 1963 def generator(svc, req): 1964 tries = 0 1965 while True: 1966 t = None if deadline is None else deadline - time.time() 1967 try: 1968 plumbing_response = svc.stub.List( 1969 req, 1970 metadata=svc.parent.get_metadata( 1971 'ApprovalWorkflowSteps.List', req), 1972 timeout=t) 1973 except Exception as e: 1974 if self.parent.shouldRetry(tries, e, deadline): 1975 tries += 1 1976 time.sleep( 1977 self.parent.exponentialBackoff(tries, deadline)) 1978 continue 1979 raise plumbing.convert_error_to_porcelain(e) from e 1980 tries = 0 1981 for plumbing_item in plumbing_response.approval_workflow_steps: 1982 yield plumbing.convert_approval_workflow_step_to_porcelain( 1983 plumbing_item) 1984 if plumbing_response.meta.next_cursor == '': 1985 break 1986 req.meta.cursor = plumbing_response.meta.next_cursor 1987 1988 return generator(self, req)
ApprovalWorkflowSteps link approval workflow steps to an ApprovalWorkflow
See strongdm.models.ApprovalWorkflowStep.
def
create(self, approval_workflow_step, timeout=None)
1843 def create(self, approval_workflow_step, timeout=None): 1844 ''' 1845 Deprecated: Create creates a new approval workflow step. 1846 ''' 1847 deadline = None if timeout is None else time.time() + timeout 1848 req = ApprovalWorkflowStepCreateRequest() 1849 1850 if approval_workflow_step is not None: 1851 req.approval_workflow_step.CopyFrom( 1852 plumbing.convert_approval_workflow_step_to_plumbing( 1853 approval_workflow_step)) 1854 tries = 0 1855 plumbing_response = None 1856 while True: 1857 t = None if deadline is None else deadline - time.time() 1858 try: 1859 plumbing_response = self.stub.Create( 1860 req, 1861 metadata=self.parent.get_metadata( 1862 'ApprovalWorkflowSteps.Create', req), 1863 timeout=t) 1864 except Exception as e: 1865 if self.parent.shouldRetry(tries, e, deadline): 1866 tries += 1 1867 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1868 continue 1869 raise plumbing.convert_error_to_porcelain(e) from e 1870 break 1871 1872 resp = models.ApprovalWorkflowStepCreateResponse() 1873 resp.approval_workflow_step = plumbing.convert_approval_workflow_step_to_porcelain( 1874 plumbing_response.approval_workflow_step) 1875 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1876 plumbing_response.rate_limit) 1877 return resp
Deprecated: Create creates a new approval workflow step.
def
get(self, id, timeout=None)
1879 def get(self, id, timeout=None): 1880 ''' 1881 Deprecated: Get reads one approval workflow step by ID. 1882 ''' 1883 deadline = None if timeout is None else time.time() + timeout 1884 req = ApprovalWorkflowStepGetRequest() 1885 if self.parent.snapshot_datetime is not None: 1886 req.meta.CopyFrom(GetRequestMetadata()) 1887 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1888 1889 req.id = (id) 1890 tries = 0 1891 plumbing_response = None 1892 while True: 1893 t = None if deadline is None else deadline - time.time() 1894 try: 1895 plumbing_response = self.stub.Get( 1896 req, 1897 metadata=self.parent.get_metadata( 1898 'ApprovalWorkflowSteps.Get', req), 1899 timeout=t) 1900 except Exception as e: 1901 if self.parent.shouldRetry(tries, e, deadline): 1902 tries += 1 1903 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1904 continue 1905 raise plumbing.convert_error_to_porcelain(e) from e 1906 break 1907 1908 resp = models.ApprovalWorkflowStepGetResponse() 1909 resp.approval_workflow_step = plumbing.convert_approval_workflow_step_to_porcelain( 1910 plumbing_response.approval_workflow_step) 1911 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1912 plumbing_response.meta) 1913 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1914 plumbing_response.rate_limit) 1915 return resp
Deprecated: Get reads one approval workflow step by ID.
def
delete(self, id, timeout=None)
1917 def delete(self, id, timeout=None): 1918 ''' 1919 Deprecated: Delete deletes an existing approval workflow step. 1920 ''' 1921 deadline = None if timeout is None else time.time() + timeout 1922 req = ApprovalWorkflowStepDeleteRequest() 1923 1924 req.id = (id) 1925 tries = 0 1926 plumbing_response = None 1927 while True: 1928 t = None if deadline is None else deadline - time.time() 1929 try: 1930 plumbing_response = self.stub.Delete( 1931 req, 1932 metadata=self.parent.get_metadata( 1933 'ApprovalWorkflowSteps.Delete', req), 1934 timeout=t) 1935 except Exception as e: 1936 if self.parent.shouldRetry(tries, e, deadline): 1937 tries += 1 1938 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1939 continue 1940 raise plumbing.convert_error_to_porcelain(e) from e 1941 break 1942 1943 resp = models.ApprovalWorkflowStepDeleteResponse() 1944 resp.id = (plumbing_response.id) 1945 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1946 plumbing_response.rate_limit) 1947 return resp
Deprecated: Delete deletes an existing approval workflow step.
def
list(self, filter, *args, timeout=None)
1949 def list(self, filter, *args, timeout=None): 1950 ''' 1951 Deprecated: Lists existing approval workflow steps. 1952 ''' 1953 deadline = None if timeout is None else time.time() + timeout 1954 req = ApprovalWorkflowStepListRequest() 1955 req.meta.CopyFrom(ListRequestMetadata()) 1956 if self.parent.page_limit > 0: 1957 req.meta.limit = self.parent.page_limit 1958 if self.parent.snapshot_datetime is not None: 1959 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1960 1961 req.filter = plumbing.quote_filter_args(filter, *args) 1962 1963 def generator(svc, req): 1964 tries = 0 1965 while True: 1966 t = None if deadline is None else deadline - time.time() 1967 try: 1968 plumbing_response = svc.stub.List( 1969 req, 1970 metadata=svc.parent.get_metadata( 1971 'ApprovalWorkflowSteps.List', req), 1972 timeout=t) 1973 except Exception as e: 1974 if self.parent.shouldRetry(tries, e, deadline): 1975 tries += 1 1976 time.sleep( 1977 self.parent.exponentialBackoff(tries, deadline)) 1978 continue 1979 raise plumbing.convert_error_to_porcelain(e) from e 1980 tries = 0 1981 for plumbing_item in plumbing_response.approval_workflow_steps: 1982 yield plumbing.convert_approval_workflow_step_to_porcelain( 1983 plumbing_item) 1984 if plumbing_response.meta.next_cursor == '': 1985 break 1986 req.meta.cursor = plumbing_response.meta.next_cursor 1987 1988 return generator(self, req)
Deprecated: Lists existing approval workflow steps.
class
SnapshotApprovalWorkflowSteps:
1991class SnapshotApprovalWorkflowSteps: 1992 ''' 1993 SnapshotApprovalWorkflowSteps exposes the read only methods of the ApprovalWorkflowSteps 1994 service for historical queries. 1995 ''' 1996 def __init__(self, approval_workflow_steps): 1997 self.approval_workflow_steps = approval_workflow_steps 1998 1999 def get(self, id, timeout=None): 2000 ''' 2001 Deprecated: Get reads one approval workflow step by ID. 2002 ''' 2003 return self.approval_workflow_steps.get(id, timeout=timeout) 2004 2005 def list(self, filter, *args, timeout=None): 2006 ''' 2007 Deprecated: Lists existing approval workflow steps. 2008 ''' 2009 return self.approval_workflow_steps.list(filter, 2010 *args, 2011 timeout=timeout)
SnapshotApprovalWorkflowSteps exposes the read only methods of the ApprovalWorkflowSteps service for historical queries.
def
get(self, id, timeout=None)
1999 def get(self, id, timeout=None): 2000 ''' 2001 Deprecated: Get reads one approval workflow step by ID. 2002 ''' 2003 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)
2005 def list(self, filter, *args, timeout=None): 2006 ''' 2007 Deprecated: Lists existing approval workflow steps. 2008 ''' 2009 return self.approval_workflow_steps.list(filter, 2010 *args, 2011 timeout=timeout)
Deprecated: Lists existing approval workflow steps.
class
ApprovalWorkflowStepsHistory:
2014class ApprovalWorkflowStepsHistory: 2015 ''' 2016 ApprovalWorkflowStepsHistory records all changes to the state of an ApprovalWorkflowStep. 2017 See `strongdm.models.ApprovalWorkflowStepHistory`. 2018 ''' 2019 def __init__(self, channel, client): 2020 self.parent = client 2021 self.stub = ApprovalWorkflowStepsHistoryStub(channel) 2022 2023 def list(self, filter, *args, timeout=None): 2024 ''' 2025 List gets a list of ApprovalWorkflowStepHistory records matching a given set of criteria. 2026 ''' 2027 deadline = None if timeout is None else time.time() + timeout 2028 req = ApprovalWorkflowStepHistoryListRequest() 2029 req.meta.CopyFrom(ListRequestMetadata()) 2030 if self.parent.page_limit > 0: 2031 req.meta.limit = self.parent.page_limit 2032 if self.parent.snapshot_datetime is not None: 2033 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2034 2035 req.filter = plumbing.quote_filter_args(filter, *args) 2036 2037 def generator(svc, req): 2038 tries = 0 2039 while True: 2040 t = None if deadline is None else deadline - time.time() 2041 try: 2042 plumbing_response = svc.stub.List( 2043 req, 2044 metadata=svc.parent.get_metadata( 2045 'ApprovalWorkflowStepsHistory.List', req), 2046 timeout=t) 2047 except Exception as e: 2048 if self.parent.shouldRetry(tries, e, deadline): 2049 tries += 1 2050 time.sleep( 2051 self.parent.exponentialBackoff(tries, deadline)) 2052 continue 2053 raise plumbing.convert_error_to_porcelain(e) from e 2054 tries = 0 2055 for plumbing_item in plumbing_response.history: 2056 yield plumbing.convert_approval_workflow_step_history_to_porcelain( 2057 plumbing_item) 2058 if plumbing_response.meta.next_cursor == '': 2059 break 2060 req.meta.cursor = plumbing_response.meta.next_cursor 2061 2062 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)
2023 def list(self, filter, *args, timeout=None): 2024 ''' 2025 List gets a list of ApprovalWorkflowStepHistory records matching a given set of criteria. 2026 ''' 2027 deadline = None if timeout is None else time.time() + timeout 2028 req = ApprovalWorkflowStepHistoryListRequest() 2029 req.meta.CopyFrom(ListRequestMetadata()) 2030 if self.parent.page_limit > 0: 2031 req.meta.limit = self.parent.page_limit 2032 if self.parent.snapshot_datetime is not None: 2033 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2034 2035 req.filter = plumbing.quote_filter_args(filter, *args) 2036 2037 def generator(svc, req): 2038 tries = 0 2039 while True: 2040 t = None if deadline is None else deadline - time.time() 2041 try: 2042 plumbing_response = svc.stub.List( 2043 req, 2044 metadata=svc.parent.get_metadata( 2045 'ApprovalWorkflowStepsHistory.List', req), 2046 timeout=t) 2047 except Exception as e: 2048 if self.parent.shouldRetry(tries, e, deadline): 2049 tries += 1 2050 time.sleep( 2051 self.parent.exponentialBackoff(tries, deadline)) 2052 continue 2053 raise plumbing.convert_error_to_porcelain(e) from e 2054 tries = 0 2055 for plumbing_item in plumbing_response.history: 2056 yield plumbing.convert_approval_workflow_step_history_to_porcelain( 2057 plumbing_item) 2058 if plumbing_response.meta.next_cursor == '': 2059 break 2060 req.meta.cursor = plumbing_response.meta.next_cursor 2061 2062 return generator(self, req)
List gets a list of ApprovalWorkflowStepHistory records matching a given set of criteria.
class
ApprovalWorkflows:
2065class ApprovalWorkflows: 2066 ''' 2067 ApprovalWorkflows are the mechanism by which requests for access can be viewed by authorized 2068 approvers and be approved or denied. 2069 See `strongdm.models.ApprovalWorkflow`. 2070 ''' 2071 def __init__(self, channel, client): 2072 self.parent = client 2073 self.stub = ApprovalWorkflowsStub(channel) 2074 2075 def create(self, approval_workflow, timeout=None): 2076 ''' 2077 Create creates a new approval workflow and requires a name and approval mode for the approval workflow. 2078 ''' 2079 deadline = None if timeout is None else time.time() + timeout 2080 req = ApprovalWorkflowCreateRequest() 2081 2082 if approval_workflow is not None: 2083 req.approval_workflow.CopyFrom( 2084 plumbing.convert_approval_workflow_to_plumbing( 2085 approval_workflow)) 2086 tries = 0 2087 plumbing_response = None 2088 while True: 2089 t = None if deadline is None else deadline - time.time() 2090 try: 2091 plumbing_response = self.stub.Create( 2092 req, 2093 metadata=self.parent.get_metadata( 2094 'ApprovalWorkflows.Create', req), 2095 timeout=t) 2096 except Exception as e: 2097 if self.parent.shouldRetry(tries, e, deadline): 2098 tries += 1 2099 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2100 continue 2101 raise plumbing.convert_error_to_porcelain(e) from e 2102 break 2103 2104 resp = models.ApprovalWorkflowCreateResponse() 2105 resp.approval_workflow = plumbing.convert_approval_workflow_to_porcelain( 2106 plumbing_response.approval_workflow) 2107 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2108 plumbing_response.rate_limit) 2109 return resp 2110 2111 def get(self, id, timeout=None): 2112 ''' 2113 Get reads one approval workflow by ID. 2114 ''' 2115 deadline = None if timeout is None else time.time() + timeout 2116 req = ApprovalWorkflowGetRequest() 2117 if self.parent.snapshot_datetime is not None: 2118 req.meta.CopyFrom(GetRequestMetadata()) 2119 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2120 2121 req.id = (id) 2122 tries = 0 2123 plumbing_response = None 2124 while True: 2125 t = None if deadline is None else deadline - time.time() 2126 try: 2127 plumbing_response = self.stub.Get( 2128 req, 2129 metadata=self.parent.get_metadata('ApprovalWorkflows.Get', 2130 req), 2131 timeout=t) 2132 except Exception as e: 2133 if self.parent.shouldRetry(tries, e, deadline): 2134 tries += 1 2135 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2136 continue 2137 raise plumbing.convert_error_to_porcelain(e) from e 2138 break 2139 2140 resp = models.ApprovalWorkflowGetResponse() 2141 resp.approval_workflow = plumbing.convert_approval_workflow_to_porcelain( 2142 plumbing_response.approval_workflow) 2143 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2144 plumbing_response.meta) 2145 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2146 plumbing_response.rate_limit) 2147 return resp 2148 2149 def delete(self, id, timeout=None): 2150 ''' 2151 Delete deletes an existing approval workflow. 2152 ''' 2153 deadline = None if timeout is None else time.time() + timeout 2154 req = ApprovalWorkflowDeleteRequest() 2155 2156 req.id = (id) 2157 tries = 0 2158 plumbing_response = None 2159 while True: 2160 t = None if deadline is None else deadline - time.time() 2161 try: 2162 plumbing_response = self.stub.Delete( 2163 req, 2164 metadata=self.parent.get_metadata( 2165 'ApprovalWorkflows.Delete', req), 2166 timeout=t) 2167 except Exception as e: 2168 if self.parent.shouldRetry(tries, e, deadline): 2169 tries += 1 2170 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2171 continue 2172 raise plumbing.convert_error_to_porcelain(e) from e 2173 break 2174 2175 resp = models.ApprovalWorkflowDeleteResponse() 2176 resp.id = (plumbing_response.id) 2177 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2178 plumbing_response.rate_limit) 2179 return resp 2180 2181 def update(self, approval_workflow, timeout=None): 2182 ''' 2183 Update updates an existing approval workflow. 2184 ''' 2185 deadline = None if timeout is None else time.time() + timeout 2186 req = ApprovalWorkflowUpdateRequest() 2187 2188 if approval_workflow is not None: 2189 req.approval_workflow.CopyFrom( 2190 plumbing.convert_approval_workflow_to_plumbing( 2191 approval_workflow)) 2192 tries = 0 2193 plumbing_response = None 2194 while True: 2195 t = None if deadline is None else deadline - time.time() 2196 try: 2197 plumbing_response = self.stub.Update( 2198 req, 2199 metadata=self.parent.get_metadata( 2200 'ApprovalWorkflows.Update', req), 2201 timeout=t) 2202 except Exception as e: 2203 if self.parent.shouldRetry(tries, e, deadline): 2204 tries += 1 2205 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2206 continue 2207 raise plumbing.convert_error_to_porcelain(e) from e 2208 break 2209 2210 resp = models.ApprovalWorkflowUpdateResponse() 2211 resp.approval_workflow = plumbing.convert_approval_workflow_to_porcelain( 2212 plumbing_response.approval_workflow) 2213 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2214 plumbing_response.rate_limit) 2215 return resp 2216 2217 def list(self, filter, *args, timeout=None): 2218 ''' 2219 Lists existing approval workflows. 2220 ''' 2221 deadline = None if timeout is None else time.time() + timeout 2222 req = ApprovalWorkflowListRequest() 2223 req.meta.CopyFrom(ListRequestMetadata()) 2224 if self.parent.page_limit > 0: 2225 req.meta.limit = self.parent.page_limit 2226 if self.parent.snapshot_datetime is not None: 2227 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2228 2229 req.filter = plumbing.quote_filter_args(filter, *args) 2230 2231 def generator(svc, req): 2232 tries = 0 2233 while True: 2234 t = None if deadline is None else deadline - time.time() 2235 try: 2236 plumbing_response = svc.stub.List( 2237 req, 2238 metadata=svc.parent.get_metadata( 2239 'ApprovalWorkflows.List', req), 2240 timeout=t) 2241 except Exception as e: 2242 if self.parent.shouldRetry(tries, e, deadline): 2243 tries += 1 2244 time.sleep( 2245 self.parent.exponentialBackoff(tries, deadline)) 2246 continue 2247 raise plumbing.convert_error_to_porcelain(e) from e 2248 tries = 0 2249 for plumbing_item in plumbing_response.approval_workflows: 2250 yield plumbing.convert_approval_workflow_to_porcelain( 2251 plumbing_item) 2252 if plumbing_response.meta.next_cursor == '': 2253 break 2254 req.meta.cursor = plumbing_response.meta.next_cursor 2255 2256 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)
2075 def create(self, approval_workflow, timeout=None): 2076 ''' 2077 Create creates a new approval workflow and requires a name and approval mode for the approval workflow. 2078 ''' 2079 deadline = None if timeout is None else time.time() + timeout 2080 req = ApprovalWorkflowCreateRequest() 2081 2082 if approval_workflow is not None: 2083 req.approval_workflow.CopyFrom( 2084 plumbing.convert_approval_workflow_to_plumbing( 2085 approval_workflow)) 2086 tries = 0 2087 plumbing_response = None 2088 while True: 2089 t = None if deadline is None else deadline - time.time() 2090 try: 2091 plumbing_response = self.stub.Create( 2092 req, 2093 metadata=self.parent.get_metadata( 2094 'ApprovalWorkflows.Create', req), 2095 timeout=t) 2096 except Exception as e: 2097 if self.parent.shouldRetry(tries, e, deadline): 2098 tries += 1 2099 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2100 continue 2101 raise plumbing.convert_error_to_porcelain(e) from e 2102 break 2103 2104 resp = models.ApprovalWorkflowCreateResponse() 2105 resp.approval_workflow = plumbing.convert_approval_workflow_to_porcelain( 2106 plumbing_response.approval_workflow) 2107 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2108 plumbing_response.rate_limit) 2109 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)
2111 def get(self, id, timeout=None): 2112 ''' 2113 Get reads one approval workflow by ID. 2114 ''' 2115 deadline = None if timeout is None else time.time() + timeout 2116 req = ApprovalWorkflowGetRequest() 2117 if self.parent.snapshot_datetime is not None: 2118 req.meta.CopyFrom(GetRequestMetadata()) 2119 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2120 2121 req.id = (id) 2122 tries = 0 2123 plumbing_response = None 2124 while True: 2125 t = None if deadline is None else deadline - time.time() 2126 try: 2127 plumbing_response = self.stub.Get( 2128 req, 2129 metadata=self.parent.get_metadata('ApprovalWorkflows.Get', 2130 req), 2131 timeout=t) 2132 except Exception as e: 2133 if self.parent.shouldRetry(tries, e, deadline): 2134 tries += 1 2135 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2136 continue 2137 raise plumbing.convert_error_to_porcelain(e) from e 2138 break 2139 2140 resp = models.ApprovalWorkflowGetResponse() 2141 resp.approval_workflow = plumbing.convert_approval_workflow_to_porcelain( 2142 plumbing_response.approval_workflow) 2143 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2144 plumbing_response.meta) 2145 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2146 plumbing_response.rate_limit) 2147 return resp
Get reads one approval workflow by ID.
def
delete(self, id, timeout=None)
2149 def delete(self, id, timeout=None): 2150 ''' 2151 Delete deletes an existing approval workflow. 2152 ''' 2153 deadline = None if timeout is None else time.time() + timeout 2154 req = ApprovalWorkflowDeleteRequest() 2155 2156 req.id = (id) 2157 tries = 0 2158 plumbing_response = None 2159 while True: 2160 t = None if deadline is None else deadline - time.time() 2161 try: 2162 plumbing_response = self.stub.Delete( 2163 req, 2164 metadata=self.parent.get_metadata( 2165 'ApprovalWorkflows.Delete', req), 2166 timeout=t) 2167 except Exception as e: 2168 if self.parent.shouldRetry(tries, e, deadline): 2169 tries += 1 2170 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2171 continue 2172 raise plumbing.convert_error_to_porcelain(e) from e 2173 break 2174 2175 resp = models.ApprovalWorkflowDeleteResponse() 2176 resp.id = (plumbing_response.id) 2177 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2178 plumbing_response.rate_limit) 2179 return resp
Delete deletes an existing approval workflow.
def
update(self, approval_workflow, timeout=None)
2181 def update(self, approval_workflow, timeout=None): 2182 ''' 2183 Update updates an existing approval workflow. 2184 ''' 2185 deadline = None if timeout is None else time.time() + timeout 2186 req = ApprovalWorkflowUpdateRequest() 2187 2188 if approval_workflow is not None: 2189 req.approval_workflow.CopyFrom( 2190 plumbing.convert_approval_workflow_to_plumbing( 2191 approval_workflow)) 2192 tries = 0 2193 plumbing_response = None 2194 while True: 2195 t = None if deadline is None else deadline - time.time() 2196 try: 2197 plumbing_response = self.stub.Update( 2198 req, 2199 metadata=self.parent.get_metadata( 2200 'ApprovalWorkflows.Update', req), 2201 timeout=t) 2202 except Exception as e: 2203 if self.parent.shouldRetry(tries, e, deadline): 2204 tries += 1 2205 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2206 continue 2207 raise plumbing.convert_error_to_porcelain(e) from e 2208 break 2209 2210 resp = models.ApprovalWorkflowUpdateResponse() 2211 resp.approval_workflow = plumbing.convert_approval_workflow_to_porcelain( 2212 plumbing_response.approval_workflow) 2213 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2214 plumbing_response.rate_limit) 2215 return resp
Update updates an existing approval workflow.
def
list(self, filter, *args, timeout=None)
2217 def list(self, filter, *args, timeout=None): 2218 ''' 2219 Lists existing approval workflows. 2220 ''' 2221 deadline = None if timeout is None else time.time() + timeout 2222 req = ApprovalWorkflowListRequest() 2223 req.meta.CopyFrom(ListRequestMetadata()) 2224 if self.parent.page_limit > 0: 2225 req.meta.limit = self.parent.page_limit 2226 if self.parent.snapshot_datetime is not None: 2227 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2228 2229 req.filter = plumbing.quote_filter_args(filter, *args) 2230 2231 def generator(svc, req): 2232 tries = 0 2233 while True: 2234 t = None if deadline is None else deadline - time.time() 2235 try: 2236 plumbing_response = svc.stub.List( 2237 req, 2238 metadata=svc.parent.get_metadata( 2239 'ApprovalWorkflows.List', req), 2240 timeout=t) 2241 except Exception as e: 2242 if self.parent.shouldRetry(tries, e, deadline): 2243 tries += 1 2244 time.sleep( 2245 self.parent.exponentialBackoff(tries, deadline)) 2246 continue 2247 raise plumbing.convert_error_to_porcelain(e) from e 2248 tries = 0 2249 for plumbing_item in plumbing_response.approval_workflows: 2250 yield plumbing.convert_approval_workflow_to_porcelain( 2251 plumbing_item) 2252 if plumbing_response.meta.next_cursor == '': 2253 break 2254 req.meta.cursor = plumbing_response.meta.next_cursor 2255 2256 return generator(self, req)
Lists existing approval workflows.
class
SnapshotApprovalWorkflows:
2259class SnapshotApprovalWorkflows: 2260 ''' 2261 SnapshotApprovalWorkflows exposes the read only methods of the ApprovalWorkflows 2262 service for historical queries. 2263 ''' 2264 def __init__(self, approval_workflows): 2265 self.approval_workflows = approval_workflows 2266 2267 def get(self, id, timeout=None): 2268 ''' 2269 Get reads one approval workflow by ID. 2270 ''' 2271 return self.approval_workflows.get(id, timeout=timeout) 2272 2273 def list(self, filter, *args, timeout=None): 2274 ''' 2275 Lists existing approval workflows. 2276 ''' 2277 return self.approval_workflows.list(filter, *args, timeout=timeout)
SnapshotApprovalWorkflows exposes the read only methods of the ApprovalWorkflows service for historical queries.
class
ApprovalWorkflowsHistory:
2280class ApprovalWorkflowsHistory: 2281 ''' 2282 ApprovalWorkflowsHistory records all changes to the state of an ApprovalWorkflow. 2283 See `strongdm.models.ApprovalWorkflowHistory`. 2284 ''' 2285 def __init__(self, channel, client): 2286 self.parent = client 2287 self.stub = ApprovalWorkflowsHistoryStub(channel) 2288 2289 def list(self, filter, *args, timeout=None): 2290 ''' 2291 List gets a list of ApprovalWorkflowHistory records matching a given set of criteria. 2292 ''' 2293 deadline = None if timeout is None else time.time() + timeout 2294 req = ApprovalWorkflowHistoryListRequest() 2295 req.meta.CopyFrom(ListRequestMetadata()) 2296 if self.parent.page_limit > 0: 2297 req.meta.limit = self.parent.page_limit 2298 if self.parent.snapshot_datetime is not None: 2299 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2300 2301 req.filter = plumbing.quote_filter_args(filter, *args) 2302 2303 def generator(svc, req): 2304 tries = 0 2305 while True: 2306 t = None if deadline is None else deadline - time.time() 2307 try: 2308 plumbing_response = svc.stub.List( 2309 req, 2310 metadata=svc.parent.get_metadata( 2311 'ApprovalWorkflowsHistory.List', req), 2312 timeout=t) 2313 except Exception as e: 2314 if self.parent.shouldRetry(tries, e, deadline): 2315 tries += 1 2316 time.sleep( 2317 self.parent.exponentialBackoff(tries, deadline)) 2318 continue 2319 raise plumbing.convert_error_to_porcelain(e) from e 2320 tries = 0 2321 for plumbing_item in plumbing_response.history: 2322 yield plumbing.convert_approval_workflow_history_to_porcelain( 2323 plumbing_item) 2324 if plumbing_response.meta.next_cursor == '': 2325 break 2326 req.meta.cursor = plumbing_response.meta.next_cursor 2327 2328 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)
2289 def list(self, filter, *args, timeout=None): 2290 ''' 2291 List gets a list of ApprovalWorkflowHistory records matching a given set of criteria. 2292 ''' 2293 deadline = None if timeout is None else time.time() + timeout 2294 req = ApprovalWorkflowHistoryListRequest() 2295 req.meta.CopyFrom(ListRequestMetadata()) 2296 if self.parent.page_limit > 0: 2297 req.meta.limit = self.parent.page_limit 2298 if self.parent.snapshot_datetime is not None: 2299 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2300 2301 req.filter = plumbing.quote_filter_args(filter, *args) 2302 2303 def generator(svc, req): 2304 tries = 0 2305 while True: 2306 t = None if deadline is None else deadline - time.time() 2307 try: 2308 plumbing_response = svc.stub.List( 2309 req, 2310 metadata=svc.parent.get_metadata( 2311 'ApprovalWorkflowsHistory.List', req), 2312 timeout=t) 2313 except Exception as e: 2314 if self.parent.shouldRetry(tries, e, deadline): 2315 tries += 1 2316 time.sleep( 2317 self.parent.exponentialBackoff(tries, deadline)) 2318 continue 2319 raise plumbing.convert_error_to_porcelain(e) from e 2320 tries = 0 2321 for plumbing_item in plumbing_response.history: 2322 yield plumbing.convert_approval_workflow_history_to_porcelain( 2323 plumbing_item) 2324 if plumbing_response.meta.next_cursor == '': 2325 break 2326 req.meta.cursor = plumbing_response.meta.next_cursor 2327 2328 return generator(self, req)
List gets a list of ApprovalWorkflowHistory records matching a given set of criteria.
class
ControlPanel:
2331class ControlPanel: 2332 ''' 2333 ControlPanel contains all administrative controls. 2334 ''' 2335 def __init__(self, channel, client): 2336 self.parent = client 2337 self.stub = ControlPanelStub(channel) 2338 2339 def get_sshca_public_key(self, timeout=None): 2340 ''' 2341 GetSSHCAPublicKey retrieves the SSH CA public key. 2342 ''' 2343 deadline = None if timeout is None else time.time() + timeout 2344 req = ControlPanelGetSSHCAPublicKeyRequest() 2345 2346 tries = 0 2347 plumbing_response = None 2348 while True: 2349 t = None if deadline is None else deadline - time.time() 2350 try: 2351 plumbing_response = self.stub.GetSSHCAPublicKey( 2352 req, 2353 metadata=self.parent.get_metadata( 2354 'ControlPanel.GetSSHCAPublicKey', req), 2355 timeout=t) 2356 except Exception as e: 2357 if self.parent.shouldRetry(tries, e, deadline): 2358 tries += 1 2359 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2360 continue 2361 raise plumbing.convert_error_to_porcelain(e) from e 2362 break 2363 2364 resp = models.ControlPanelGetSSHCAPublicKeyResponse() 2365 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2366 plumbing_response.meta) 2367 resp.public_key = (plumbing_response.public_key) 2368 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2369 plumbing_response.rate_limit) 2370 return resp 2371 2372 def get_rdpca_public_key(self, timeout=None): 2373 ''' 2374 GetRDPCAPublicKey retrieves the RDP CA public key. 2375 ''' 2376 deadline = None if timeout is None else time.time() + timeout 2377 req = ControlPanelGetRDPCAPublicKeyRequest() 2378 2379 tries = 0 2380 plumbing_response = None 2381 while True: 2382 t = None if deadline is None else deadline - time.time() 2383 try: 2384 plumbing_response = self.stub.GetRDPCAPublicKey( 2385 req, 2386 metadata=self.parent.get_metadata( 2387 'ControlPanel.GetRDPCAPublicKey', req), 2388 timeout=t) 2389 except Exception as e: 2390 if self.parent.shouldRetry(tries, e, deadline): 2391 tries += 1 2392 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2393 continue 2394 raise plumbing.convert_error_to_porcelain(e) from e 2395 break 2396 2397 resp = models.ControlPanelGetRDPCAPublicKeyResponse() 2398 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2399 plumbing_response.meta) 2400 resp.public_key = (plumbing_response.public_key) 2401 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2402 plumbing_response.rate_limit) 2403 return resp 2404 2405 def get_org_url_info(self, timeout=None): 2406 ''' 2407 GetOrgURLInfo retrieves URL configuration for the organization. 2408 This includes the base URL, website subdomain, OIDC issuer URL, and SAML metadata URL. 2409 ''' 2410 deadline = None if timeout is None else time.time() + timeout 2411 req = ControlPanelGetOrgURLInfoRequest() 2412 2413 tries = 0 2414 plumbing_response = None 2415 while True: 2416 t = None if deadline is None else deadline - time.time() 2417 try: 2418 plumbing_response = self.stub.GetOrgURLInfo( 2419 req, 2420 metadata=self.parent.get_metadata( 2421 'ControlPanel.GetOrgURLInfo', req), 2422 timeout=t) 2423 except Exception as e: 2424 if self.parent.shouldRetry(tries, e, deadline): 2425 tries += 1 2426 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2427 continue 2428 raise plumbing.convert_error_to_porcelain(e) from e 2429 break 2430 2431 resp = models.ControlPanelGetOrgURLInfoResponse() 2432 resp.base_url = (plumbing_response.base_url) 2433 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2434 plumbing_response.meta) 2435 resp.oidc_issuer_url = (plumbing_response.oidc_issuer_url) 2436 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2437 plumbing_response.rate_limit) 2438 resp.saml_metadata_url = (plumbing_response.saml_metadata_url) 2439 resp.websites_subdomain = (plumbing_response.websites_subdomain) 2440 return resp 2441 2442 def verify_jwt(self, token, timeout=None): 2443 ''' 2444 VerifyJWT reports whether the given JWT token (x-sdm-token) is valid. 2445 ''' 2446 deadline = None if timeout is None else time.time() + timeout 2447 req = ControlPanelVerifyJWTRequest() 2448 2449 req.token = (token) 2450 tries = 0 2451 plumbing_response = None 2452 while True: 2453 t = None if deadline is None else deadline - time.time() 2454 try: 2455 plumbing_response = self.stub.VerifyJWT( 2456 req, 2457 metadata=self.parent.get_metadata('ControlPanel.VerifyJWT', 2458 req), 2459 timeout=t) 2460 except Exception as e: 2461 if self.parent.shouldRetry(tries, e, deadline): 2462 tries += 1 2463 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2464 continue 2465 raise plumbing.convert_error_to_porcelain(e) from e 2466 break 2467 2468 resp = models.ControlPanelVerifyJWTResponse() 2469 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2470 plumbing_response.meta) 2471 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2472 plumbing_response.rate_limit) 2473 resp.valid = (plumbing_response.valid) 2474 return resp
ControlPanel contains all administrative controls.
def
get_sshca_public_key(self, timeout=None)
2339 def get_sshca_public_key(self, timeout=None): 2340 ''' 2341 GetSSHCAPublicKey retrieves the SSH CA public key. 2342 ''' 2343 deadline = None if timeout is None else time.time() + timeout 2344 req = ControlPanelGetSSHCAPublicKeyRequest() 2345 2346 tries = 0 2347 plumbing_response = None 2348 while True: 2349 t = None if deadline is None else deadline - time.time() 2350 try: 2351 plumbing_response = self.stub.GetSSHCAPublicKey( 2352 req, 2353 metadata=self.parent.get_metadata( 2354 'ControlPanel.GetSSHCAPublicKey', req), 2355 timeout=t) 2356 except Exception as e: 2357 if self.parent.shouldRetry(tries, e, deadline): 2358 tries += 1 2359 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2360 continue 2361 raise plumbing.convert_error_to_porcelain(e) from e 2362 break 2363 2364 resp = models.ControlPanelGetSSHCAPublicKeyResponse() 2365 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2366 plumbing_response.meta) 2367 resp.public_key = (plumbing_response.public_key) 2368 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2369 plumbing_response.rate_limit) 2370 return resp
GetSSHCAPublicKey retrieves the SSH CA public key.
def
get_rdpca_public_key(self, timeout=None)
2372 def get_rdpca_public_key(self, timeout=None): 2373 ''' 2374 GetRDPCAPublicKey retrieves the RDP CA public key. 2375 ''' 2376 deadline = None if timeout is None else time.time() + timeout 2377 req = ControlPanelGetRDPCAPublicKeyRequest() 2378 2379 tries = 0 2380 plumbing_response = None 2381 while True: 2382 t = None if deadline is None else deadline - time.time() 2383 try: 2384 plumbing_response = self.stub.GetRDPCAPublicKey( 2385 req, 2386 metadata=self.parent.get_metadata( 2387 'ControlPanel.GetRDPCAPublicKey', req), 2388 timeout=t) 2389 except Exception as e: 2390 if self.parent.shouldRetry(tries, e, deadline): 2391 tries += 1 2392 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2393 continue 2394 raise plumbing.convert_error_to_porcelain(e) from e 2395 break 2396 2397 resp = models.ControlPanelGetRDPCAPublicKeyResponse() 2398 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2399 plumbing_response.meta) 2400 resp.public_key = (plumbing_response.public_key) 2401 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2402 plumbing_response.rate_limit) 2403 return resp
GetRDPCAPublicKey retrieves the RDP CA public key.
def
get_org_url_info(self, timeout=None)
2405 def get_org_url_info(self, timeout=None): 2406 ''' 2407 GetOrgURLInfo retrieves URL configuration for the organization. 2408 This includes the base URL, website subdomain, OIDC issuer URL, and SAML metadata URL. 2409 ''' 2410 deadline = None if timeout is None else time.time() + timeout 2411 req = ControlPanelGetOrgURLInfoRequest() 2412 2413 tries = 0 2414 plumbing_response = None 2415 while True: 2416 t = None if deadline is None else deadline - time.time() 2417 try: 2418 plumbing_response = self.stub.GetOrgURLInfo( 2419 req, 2420 metadata=self.parent.get_metadata( 2421 'ControlPanel.GetOrgURLInfo', req), 2422 timeout=t) 2423 except Exception as e: 2424 if self.parent.shouldRetry(tries, e, deadline): 2425 tries += 1 2426 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2427 continue 2428 raise plumbing.convert_error_to_porcelain(e) from e 2429 break 2430 2431 resp = models.ControlPanelGetOrgURLInfoResponse() 2432 resp.base_url = (plumbing_response.base_url) 2433 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2434 plumbing_response.meta) 2435 resp.oidc_issuer_url = (plumbing_response.oidc_issuer_url) 2436 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2437 plumbing_response.rate_limit) 2438 resp.saml_metadata_url = (plumbing_response.saml_metadata_url) 2439 resp.websites_subdomain = (plumbing_response.websites_subdomain) 2440 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)
2442 def verify_jwt(self, token, timeout=None): 2443 ''' 2444 VerifyJWT reports whether the given JWT token (x-sdm-token) is valid. 2445 ''' 2446 deadline = None if timeout is None else time.time() + timeout 2447 req = ControlPanelVerifyJWTRequest() 2448 2449 req.token = (token) 2450 tries = 0 2451 plumbing_response = None 2452 while True: 2453 t = None if deadline is None else deadline - time.time() 2454 try: 2455 plumbing_response = self.stub.VerifyJWT( 2456 req, 2457 metadata=self.parent.get_metadata('ControlPanel.VerifyJWT', 2458 req), 2459 timeout=t) 2460 except Exception as e: 2461 if self.parent.shouldRetry(tries, e, deadline): 2462 tries += 1 2463 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2464 continue 2465 raise plumbing.convert_error_to_porcelain(e) from e 2466 break 2467 2468 resp = models.ControlPanelVerifyJWTResponse() 2469 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2470 plumbing_response.meta) 2471 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2472 plumbing_response.rate_limit) 2473 resp.valid = (plumbing_response.valid) 2474 return resp
VerifyJWT reports whether the given JWT token (x-sdm-token) is valid.
class
DiscoveryConnectors:
2477class DiscoveryConnectors: 2478 ''' 2479 A Discovery Connector is a configuration object for performing Resource 2480 Scans in remote systems such as AWS, GCP, Azure, and other systems. 2481 See: 2482 `strongdm.models.AWSConnector` 2483 `strongdm.models.AzureConnector` 2484 `strongdm.models.GCPConnector` 2485 ''' 2486 def __init__(self, channel, client): 2487 self.parent = client 2488 self.stub = DiscoveryConnectorsStub(channel) 2489 2490 def create(self, connector, timeout=None): 2491 ''' 2492 Create adds a new Connector. 2493 ''' 2494 deadline = None if timeout is None else time.time() + timeout 2495 req = ConnectorCreateRequest() 2496 2497 if connector is not None: 2498 req.connector.CopyFrom( 2499 plumbing.convert_connector_to_plumbing(connector)) 2500 tries = 0 2501 plumbing_response = None 2502 while True: 2503 t = None if deadline is None else deadline - time.time() 2504 try: 2505 plumbing_response = self.stub.Create( 2506 req, 2507 metadata=self.parent.get_metadata( 2508 'DiscoveryConnectors.Create', req), 2509 timeout=t) 2510 except Exception as e: 2511 if self.parent.shouldRetry(tries, e, deadline): 2512 tries += 1 2513 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2514 continue 2515 raise plumbing.convert_error_to_porcelain(e) from e 2516 break 2517 2518 resp = models.ConnectorCreateResponse() 2519 resp.connector = plumbing.convert_connector_to_porcelain( 2520 plumbing_response.connector) 2521 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2522 plumbing_response.rate_limit) 2523 return resp 2524 2525 def get(self, id, timeout=None): 2526 ''' 2527 Get reads one Connector by ID 2528 ''' 2529 deadline = None if timeout is None else time.time() + timeout 2530 req = ConnectorGetRequest() 2531 if self.parent.snapshot_datetime is not None: 2532 req.meta.CopyFrom(GetRequestMetadata()) 2533 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2534 2535 req.id = (id) 2536 tries = 0 2537 plumbing_response = None 2538 while True: 2539 t = None if deadline is None else deadline - time.time() 2540 try: 2541 plumbing_response = self.stub.Get( 2542 req, 2543 metadata=self.parent.get_metadata( 2544 'DiscoveryConnectors.Get', req), 2545 timeout=t) 2546 except Exception as e: 2547 if self.parent.shouldRetry(tries, e, deadline): 2548 tries += 1 2549 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2550 continue 2551 raise plumbing.convert_error_to_porcelain(e) from e 2552 break 2553 2554 resp = models.ConnectorGetResponse() 2555 resp.connector = plumbing.convert_connector_to_porcelain( 2556 plumbing_response.connector) 2557 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2558 plumbing_response.meta) 2559 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2560 plumbing_response.rate_limit) 2561 return resp 2562 2563 def update(self, connector, timeout=None): 2564 ''' 2565 Update replaces all the fields of a Connector by ID. 2566 ''' 2567 deadline = None if timeout is None else time.time() + timeout 2568 req = ConnectorUpdateRequest() 2569 2570 if connector is not None: 2571 req.connector.CopyFrom( 2572 plumbing.convert_connector_to_plumbing(connector)) 2573 tries = 0 2574 plumbing_response = None 2575 while True: 2576 t = None if deadline is None else deadline - time.time() 2577 try: 2578 plumbing_response = self.stub.Update( 2579 req, 2580 metadata=self.parent.get_metadata( 2581 'DiscoveryConnectors.Update', req), 2582 timeout=t) 2583 except Exception as e: 2584 if self.parent.shouldRetry(tries, e, deadline): 2585 tries += 1 2586 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2587 continue 2588 raise plumbing.convert_error_to_porcelain(e) from e 2589 break 2590 2591 resp = models.ConnectorUpdateResponse() 2592 resp.connector = plumbing.convert_connector_to_porcelain( 2593 plumbing_response.connector) 2594 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2595 plumbing_response.rate_limit) 2596 return resp 2597 2598 def delete(self, id, timeout=None): 2599 ''' 2600 Delete removes a Connector by ID. 2601 ''' 2602 deadline = None if timeout is None else time.time() + timeout 2603 req = ConnectorDeleteRequest() 2604 2605 req.id = (id) 2606 tries = 0 2607 plumbing_response = None 2608 while True: 2609 t = None if deadline is None else deadline - time.time() 2610 try: 2611 plumbing_response = self.stub.Delete( 2612 req, 2613 metadata=self.parent.get_metadata( 2614 'DiscoveryConnectors.Delete', req), 2615 timeout=t) 2616 except Exception as e: 2617 if self.parent.shouldRetry(tries, e, deadline): 2618 tries += 1 2619 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2620 continue 2621 raise plumbing.convert_error_to_porcelain(e) from e 2622 break 2623 2624 resp = models.ConnectorDeleteResponse() 2625 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 2626 plumbing_response.meta) 2627 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2628 plumbing_response.rate_limit) 2629 return resp 2630 2631 def list(self, filter, *args, timeout=None): 2632 ''' 2633 List gets a list of Connectors matching a given set of criteria. 2634 ''' 2635 deadline = None if timeout is None else time.time() + timeout 2636 req = ConnectorListRequest() 2637 req.meta.CopyFrom(ListRequestMetadata()) 2638 if self.parent.page_limit > 0: 2639 req.meta.limit = self.parent.page_limit 2640 if self.parent.snapshot_datetime is not None: 2641 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2642 2643 req.filter = plumbing.quote_filter_args(filter, *args) 2644 2645 def generator(svc, req): 2646 tries = 0 2647 while True: 2648 t = None if deadline is None else deadline - time.time() 2649 try: 2650 plumbing_response = svc.stub.List( 2651 req, 2652 metadata=svc.parent.get_metadata( 2653 'DiscoveryConnectors.List', req), 2654 timeout=t) 2655 except Exception as e: 2656 if self.parent.shouldRetry(tries, e, deadline): 2657 tries += 1 2658 time.sleep( 2659 self.parent.exponentialBackoff(tries, deadline)) 2660 continue 2661 raise plumbing.convert_error_to_porcelain(e) from e 2662 tries = 0 2663 for plumbing_item in plumbing_response.connectors: 2664 yield plumbing.convert_connector_to_porcelain( 2665 plumbing_item) 2666 if plumbing_response.meta.next_cursor == '': 2667 break 2668 req.meta.cursor = plumbing_response.meta.next_cursor 2669 2670 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)
2490 def create(self, connector, timeout=None): 2491 ''' 2492 Create adds a new Connector. 2493 ''' 2494 deadline = None if timeout is None else time.time() + timeout 2495 req = ConnectorCreateRequest() 2496 2497 if connector is not None: 2498 req.connector.CopyFrom( 2499 plumbing.convert_connector_to_plumbing(connector)) 2500 tries = 0 2501 plumbing_response = None 2502 while True: 2503 t = None if deadline is None else deadline - time.time() 2504 try: 2505 plumbing_response = self.stub.Create( 2506 req, 2507 metadata=self.parent.get_metadata( 2508 'DiscoveryConnectors.Create', req), 2509 timeout=t) 2510 except Exception as e: 2511 if self.parent.shouldRetry(tries, e, deadline): 2512 tries += 1 2513 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2514 continue 2515 raise plumbing.convert_error_to_porcelain(e) from e 2516 break 2517 2518 resp = models.ConnectorCreateResponse() 2519 resp.connector = plumbing.convert_connector_to_porcelain( 2520 plumbing_response.connector) 2521 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2522 plumbing_response.rate_limit) 2523 return resp
Create adds a new Connector.
def
get(self, id, timeout=None)
2525 def get(self, id, timeout=None): 2526 ''' 2527 Get reads one Connector by ID 2528 ''' 2529 deadline = None if timeout is None else time.time() + timeout 2530 req = ConnectorGetRequest() 2531 if self.parent.snapshot_datetime is not None: 2532 req.meta.CopyFrom(GetRequestMetadata()) 2533 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2534 2535 req.id = (id) 2536 tries = 0 2537 plumbing_response = None 2538 while True: 2539 t = None if deadline is None else deadline - time.time() 2540 try: 2541 plumbing_response = self.stub.Get( 2542 req, 2543 metadata=self.parent.get_metadata( 2544 'DiscoveryConnectors.Get', req), 2545 timeout=t) 2546 except Exception as e: 2547 if self.parent.shouldRetry(tries, e, deadline): 2548 tries += 1 2549 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2550 continue 2551 raise plumbing.convert_error_to_porcelain(e) from e 2552 break 2553 2554 resp = models.ConnectorGetResponse() 2555 resp.connector = plumbing.convert_connector_to_porcelain( 2556 plumbing_response.connector) 2557 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2558 plumbing_response.meta) 2559 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2560 plumbing_response.rate_limit) 2561 return resp
Get reads one Connector by ID
def
update(self, connector, timeout=None)
2563 def update(self, connector, timeout=None): 2564 ''' 2565 Update replaces all the fields of a Connector by ID. 2566 ''' 2567 deadline = None if timeout is None else time.time() + timeout 2568 req = ConnectorUpdateRequest() 2569 2570 if connector is not None: 2571 req.connector.CopyFrom( 2572 plumbing.convert_connector_to_plumbing(connector)) 2573 tries = 0 2574 plumbing_response = None 2575 while True: 2576 t = None if deadline is None else deadline - time.time() 2577 try: 2578 plumbing_response = self.stub.Update( 2579 req, 2580 metadata=self.parent.get_metadata( 2581 'DiscoveryConnectors.Update', req), 2582 timeout=t) 2583 except Exception as e: 2584 if self.parent.shouldRetry(tries, e, deadline): 2585 tries += 1 2586 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2587 continue 2588 raise plumbing.convert_error_to_porcelain(e) from e 2589 break 2590 2591 resp = models.ConnectorUpdateResponse() 2592 resp.connector = plumbing.convert_connector_to_porcelain( 2593 plumbing_response.connector) 2594 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2595 plumbing_response.rate_limit) 2596 return resp
Update replaces all the fields of a Connector by ID.
def
delete(self, id, timeout=None)
2598 def delete(self, id, timeout=None): 2599 ''' 2600 Delete removes a Connector by ID. 2601 ''' 2602 deadline = None if timeout is None else time.time() + timeout 2603 req = ConnectorDeleteRequest() 2604 2605 req.id = (id) 2606 tries = 0 2607 plumbing_response = None 2608 while True: 2609 t = None if deadline is None else deadline - time.time() 2610 try: 2611 plumbing_response = self.stub.Delete( 2612 req, 2613 metadata=self.parent.get_metadata( 2614 'DiscoveryConnectors.Delete', req), 2615 timeout=t) 2616 except Exception as e: 2617 if self.parent.shouldRetry(tries, e, deadline): 2618 tries += 1 2619 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2620 continue 2621 raise plumbing.convert_error_to_porcelain(e) from e 2622 break 2623 2624 resp = models.ConnectorDeleteResponse() 2625 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 2626 plumbing_response.meta) 2627 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2628 plumbing_response.rate_limit) 2629 return resp
Delete removes a Connector by ID.
def
list(self, filter, *args, timeout=None)
2631 def list(self, filter, *args, timeout=None): 2632 ''' 2633 List gets a list of Connectors matching a given set of criteria. 2634 ''' 2635 deadline = None if timeout is None else time.time() + timeout 2636 req = ConnectorListRequest() 2637 req.meta.CopyFrom(ListRequestMetadata()) 2638 if self.parent.page_limit > 0: 2639 req.meta.limit = self.parent.page_limit 2640 if self.parent.snapshot_datetime is not None: 2641 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2642 2643 req.filter = plumbing.quote_filter_args(filter, *args) 2644 2645 def generator(svc, req): 2646 tries = 0 2647 while True: 2648 t = None if deadline is None else deadline - time.time() 2649 try: 2650 plumbing_response = svc.stub.List( 2651 req, 2652 metadata=svc.parent.get_metadata( 2653 'DiscoveryConnectors.List', req), 2654 timeout=t) 2655 except Exception as e: 2656 if self.parent.shouldRetry(tries, e, deadline): 2657 tries += 1 2658 time.sleep( 2659 self.parent.exponentialBackoff(tries, deadline)) 2660 continue 2661 raise plumbing.convert_error_to_porcelain(e) from e 2662 tries = 0 2663 for plumbing_item in plumbing_response.connectors: 2664 yield plumbing.convert_connector_to_porcelain( 2665 plumbing_item) 2666 if plumbing_response.meta.next_cursor == '': 2667 break 2668 req.meta.cursor = plumbing_response.meta.next_cursor 2669 2670 return generator(self, req)
List gets a list of Connectors matching a given set of criteria.
class
SnapshotDiscoveryConnectors:
2673class SnapshotDiscoveryConnectors: 2674 ''' 2675 SnapshotDiscoveryConnectors exposes the read only methods of the DiscoveryConnectors 2676 service for historical queries. 2677 ''' 2678 def __init__(self, discovery_connectors): 2679 self.discovery_connectors = discovery_connectors 2680 2681 def get(self, id, timeout=None): 2682 ''' 2683 Get reads one Connector by ID 2684 ''' 2685 return self.discovery_connectors.get(id, timeout=timeout) 2686 2687 def list(self, filter, *args, timeout=None): 2688 ''' 2689 List gets a list of Connectors matching a given set of criteria. 2690 ''' 2691 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)
2681 def get(self, id, timeout=None): 2682 ''' 2683 Get reads one Connector by ID 2684 ''' 2685 return self.discovery_connectors.get(id, timeout=timeout)
Get reads one Connector by ID
def
list(self, filter, *args, timeout=None)
2687 def list(self, filter, *args, timeout=None): 2688 ''' 2689 List gets a list of Connectors matching a given set of criteria. 2690 ''' 2691 return self.discovery_connectors.list(filter, *args, timeout=timeout)
List gets a list of Connectors matching a given set of criteria.
class
GrantedAccountEntitlements:
2694class GrantedAccountEntitlements: 2695 ''' 2696 GrantedAccountEntitlements enumerates the resources to which an account has been granted access. 2697 The GrantedAccountEntitlements service is read-only. 2698 See `strongdm.models.GrantedAccountEntitlement`. 2699 ''' 2700 def __init__(self, channel, client): 2701 self.parent = client 2702 self.stub = GrantedAccountEntitlementsStub(channel) 2703 2704 def list(self, account_id, filter, *args, timeout=None): 2705 ''' 2706 List gets a list of GrantedAccountEntitlement records matching a given set of criteria. 2707 ''' 2708 deadline = None if timeout is None else time.time() + timeout 2709 req = GrantedAccountEntitlementListRequest() 2710 req.meta.CopyFrom(ListRequestMetadata()) 2711 if self.parent.page_limit > 0: 2712 req.meta.limit = self.parent.page_limit 2713 if self.parent.snapshot_datetime is not None: 2714 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2715 2716 req.account_id = (account_id) 2717 req.filter = plumbing.quote_filter_args(filter, *args) 2718 2719 def generator(svc, req): 2720 tries = 0 2721 while True: 2722 t = None if deadline is None else deadline - time.time() 2723 try: 2724 plumbing_response = svc.stub.List( 2725 req, 2726 metadata=svc.parent.get_metadata( 2727 'GrantedAccountEntitlements.List', req), 2728 timeout=t) 2729 except Exception as e: 2730 if self.parent.shouldRetry(tries, e, deadline): 2731 tries += 1 2732 time.sleep( 2733 self.parent.exponentialBackoff(tries, deadline)) 2734 continue 2735 raise plumbing.convert_error_to_porcelain(e) from e 2736 tries = 0 2737 for plumbing_item in plumbing_response.granted_account_entitlements: 2738 yield plumbing.convert_granted_account_entitlement_to_porcelain( 2739 plumbing_item) 2740 if plumbing_response.meta.next_cursor == '': 2741 break 2742 req.meta.cursor = plumbing_response.meta.next_cursor 2743 2744 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)
2704 def list(self, account_id, filter, *args, timeout=None): 2705 ''' 2706 List gets a list of GrantedAccountEntitlement records matching a given set of criteria. 2707 ''' 2708 deadline = None if timeout is None else time.time() + timeout 2709 req = GrantedAccountEntitlementListRequest() 2710 req.meta.CopyFrom(ListRequestMetadata()) 2711 if self.parent.page_limit > 0: 2712 req.meta.limit = self.parent.page_limit 2713 if self.parent.snapshot_datetime is not None: 2714 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2715 2716 req.account_id = (account_id) 2717 req.filter = plumbing.quote_filter_args(filter, *args) 2718 2719 def generator(svc, req): 2720 tries = 0 2721 while True: 2722 t = None if deadline is None else deadline - time.time() 2723 try: 2724 plumbing_response = svc.stub.List( 2725 req, 2726 metadata=svc.parent.get_metadata( 2727 'GrantedAccountEntitlements.List', req), 2728 timeout=t) 2729 except Exception as e: 2730 if self.parent.shouldRetry(tries, e, deadline): 2731 tries += 1 2732 time.sleep( 2733 self.parent.exponentialBackoff(tries, deadline)) 2734 continue 2735 raise plumbing.convert_error_to_porcelain(e) from e 2736 tries = 0 2737 for plumbing_item in plumbing_response.granted_account_entitlements: 2738 yield plumbing.convert_granted_account_entitlement_to_porcelain( 2739 plumbing_item) 2740 if plumbing_response.meta.next_cursor == '': 2741 break 2742 req.meta.cursor = plumbing_response.meta.next_cursor 2743 2744 return generator(self, req)
List gets a list of GrantedAccountEntitlement records matching a given set of criteria.
class
SnapshotGrantedAccountEntitlements:
2747class SnapshotGrantedAccountEntitlements: 2748 ''' 2749 SnapshotGrantedAccountEntitlements exposes the read only methods of the GrantedAccountEntitlements 2750 service for historical queries. 2751 ''' 2752 def __init__(self, granted_account_entitlements): 2753 self.granted_account_entitlements = granted_account_entitlements 2754 2755 def list(self, account_id, filter, *args, timeout=None): 2756 ''' 2757 List gets a list of GrantedAccountEntitlement records matching a given set of criteria. 2758 ''' 2759 return self.granted_account_entitlements.list(account_id, 2760 filter, 2761 *args, 2762 timeout=timeout)
SnapshotGrantedAccountEntitlements exposes the read only methods of the GrantedAccountEntitlements service for historical queries.
def
list(self, account_id, filter, *args, timeout=None)
2755 def list(self, account_id, filter, *args, timeout=None): 2756 ''' 2757 List gets a list of GrantedAccountEntitlement records matching a given set of criteria. 2758 ''' 2759 return self.granted_account_entitlements.list(account_id, 2760 filter, 2761 *args, 2762 timeout=timeout)
List gets a list of GrantedAccountEntitlement records matching a given set of criteria.
class
GrantedResourceEntitlements:
2765class GrantedResourceEntitlements: 2766 ''' 2767 GrantedResourceEntitlements enumerates the accounts that have been granted access to a given resource. 2768 The GrantedResourceEntitlements service is read-only. 2769 See `strongdm.models.GrantedResourceEntitlement`. 2770 ''' 2771 def __init__(self, channel, client): 2772 self.parent = client 2773 self.stub = GrantedResourceEntitlementsStub(channel) 2774 2775 def list(self, resource_id, filter, *args, timeout=None): 2776 ''' 2777 List gets a list of GrantedResourceEntitlement records matching a given set of criteria. 2778 ''' 2779 deadline = None if timeout is None else time.time() + timeout 2780 req = GrantedResourceEntitlementListRequest() 2781 req.meta.CopyFrom(ListRequestMetadata()) 2782 if self.parent.page_limit > 0: 2783 req.meta.limit = self.parent.page_limit 2784 if self.parent.snapshot_datetime is not None: 2785 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2786 2787 req.resource_id = (resource_id) 2788 req.filter = plumbing.quote_filter_args(filter, *args) 2789 2790 def generator(svc, req): 2791 tries = 0 2792 while True: 2793 t = None if deadline is None else deadline - time.time() 2794 try: 2795 plumbing_response = svc.stub.List( 2796 req, 2797 metadata=svc.parent.get_metadata( 2798 'GrantedResourceEntitlements.List', req), 2799 timeout=t) 2800 except Exception as e: 2801 if self.parent.shouldRetry(tries, e, deadline): 2802 tries += 1 2803 time.sleep( 2804 self.parent.exponentialBackoff(tries, deadline)) 2805 continue 2806 raise plumbing.convert_error_to_porcelain(e) from e 2807 tries = 0 2808 for plumbing_item in plumbing_response.granted_resource_entitlements: 2809 yield plumbing.convert_granted_resource_entitlement_to_porcelain( 2810 plumbing_item) 2811 if plumbing_response.meta.next_cursor == '': 2812 break 2813 req.meta.cursor = plumbing_response.meta.next_cursor 2814 2815 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)
2775 def list(self, resource_id, filter, *args, timeout=None): 2776 ''' 2777 List gets a list of GrantedResourceEntitlement records matching a given set of criteria. 2778 ''' 2779 deadline = None if timeout is None else time.time() + timeout 2780 req = GrantedResourceEntitlementListRequest() 2781 req.meta.CopyFrom(ListRequestMetadata()) 2782 if self.parent.page_limit > 0: 2783 req.meta.limit = self.parent.page_limit 2784 if self.parent.snapshot_datetime is not None: 2785 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2786 2787 req.resource_id = (resource_id) 2788 req.filter = plumbing.quote_filter_args(filter, *args) 2789 2790 def generator(svc, req): 2791 tries = 0 2792 while True: 2793 t = None if deadline is None else deadline - time.time() 2794 try: 2795 plumbing_response = svc.stub.List( 2796 req, 2797 metadata=svc.parent.get_metadata( 2798 'GrantedResourceEntitlements.List', req), 2799 timeout=t) 2800 except Exception as e: 2801 if self.parent.shouldRetry(tries, e, deadline): 2802 tries += 1 2803 time.sleep( 2804 self.parent.exponentialBackoff(tries, deadline)) 2805 continue 2806 raise plumbing.convert_error_to_porcelain(e) from e 2807 tries = 0 2808 for plumbing_item in plumbing_response.granted_resource_entitlements: 2809 yield plumbing.convert_granted_resource_entitlement_to_porcelain( 2810 plumbing_item) 2811 if plumbing_response.meta.next_cursor == '': 2812 break 2813 req.meta.cursor = plumbing_response.meta.next_cursor 2814 2815 return generator(self, req)
List gets a list of GrantedResourceEntitlement records matching a given set of criteria.
class
SnapshotGrantedResourceEntitlements:
2818class SnapshotGrantedResourceEntitlements: 2819 ''' 2820 SnapshotGrantedResourceEntitlements exposes the read only methods of the GrantedResourceEntitlements 2821 service for historical queries. 2822 ''' 2823 def __init__(self, granted_resource_entitlements): 2824 self.granted_resource_entitlements = granted_resource_entitlements 2825 2826 def list(self, resource_id, filter, *args, timeout=None): 2827 ''' 2828 List gets a list of GrantedResourceEntitlement records matching a given set of criteria. 2829 ''' 2830 return self.granted_resource_entitlements.list(resource_id, 2831 filter, 2832 *args, 2833 timeout=timeout)
SnapshotGrantedResourceEntitlements exposes the read only methods of the GrantedResourceEntitlements service for historical queries.
def
list(self, resource_id, filter, *args, timeout=None)
2826 def list(self, resource_id, filter, *args, timeout=None): 2827 ''' 2828 List gets a list of GrantedResourceEntitlement records matching a given set of criteria. 2829 ''' 2830 return self.granted_resource_entitlements.list(resource_id, 2831 filter, 2832 *args, 2833 timeout=timeout)
List gets a list of GrantedResourceEntitlement records matching a given set of criteria.
class
GrantedRoleEntitlements:
2836class GrantedRoleEntitlements: 2837 ''' 2838 GrantedRoleEntitlements enumerates the resources to which a role grants access. 2839 The GrantedRoleEntitlements service is read-only. 2840 See `strongdm.models.GrantedRoleEntitlement`. 2841 ''' 2842 def __init__(self, channel, client): 2843 self.parent = client 2844 self.stub = GrantedRoleEntitlementsStub(channel) 2845 2846 def list(self, role_id, filter, *args, timeout=None): 2847 ''' 2848 List gets a list of GrantedRoleEntitlement records matching a given set of criteria. 2849 ''' 2850 deadline = None if timeout is None else time.time() + timeout 2851 req = GrantedRoleEntitlementListRequest() 2852 req.meta.CopyFrom(ListRequestMetadata()) 2853 if self.parent.page_limit > 0: 2854 req.meta.limit = self.parent.page_limit 2855 if self.parent.snapshot_datetime is not None: 2856 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2857 2858 req.role_id = (role_id) 2859 req.filter = plumbing.quote_filter_args(filter, *args) 2860 2861 def generator(svc, req): 2862 tries = 0 2863 while True: 2864 t = None if deadline is None else deadline - time.time() 2865 try: 2866 plumbing_response = svc.stub.List( 2867 req, 2868 metadata=svc.parent.get_metadata( 2869 'GrantedRoleEntitlements.List', req), 2870 timeout=t) 2871 except Exception as e: 2872 if self.parent.shouldRetry(tries, e, deadline): 2873 tries += 1 2874 time.sleep( 2875 self.parent.exponentialBackoff(tries, deadline)) 2876 continue 2877 raise plumbing.convert_error_to_porcelain(e) from e 2878 tries = 0 2879 for plumbing_item in plumbing_response.granted_role_entitlements: 2880 yield plumbing.convert_granted_role_entitlement_to_porcelain( 2881 plumbing_item) 2882 if plumbing_response.meta.next_cursor == '': 2883 break 2884 req.meta.cursor = plumbing_response.meta.next_cursor 2885 2886 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)
2846 def list(self, role_id, filter, *args, timeout=None): 2847 ''' 2848 List gets a list of GrantedRoleEntitlement records matching a given set of criteria. 2849 ''' 2850 deadline = None if timeout is None else time.time() + timeout 2851 req = GrantedRoleEntitlementListRequest() 2852 req.meta.CopyFrom(ListRequestMetadata()) 2853 if self.parent.page_limit > 0: 2854 req.meta.limit = self.parent.page_limit 2855 if self.parent.snapshot_datetime is not None: 2856 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2857 2858 req.role_id = (role_id) 2859 req.filter = plumbing.quote_filter_args(filter, *args) 2860 2861 def generator(svc, req): 2862 tries = 0 2863 while True: 2864 t = None if deadline is None else deadline - time.time() 2865 try: 2866 plumbing_response = svc.stub.List( 2867 req, 2868 metadata=svc.parent.get_metadata( 2869 'GrantedRoleEntitlements.List', req), 2870 timeout=t) 2871 except Exception as e: 2872 if self.parent.shouldRetry(tries, e, deadline): 2873 tries += 1 2874 time.sleep( 2875 self.parent.exponentialBackoff(tries, deadline)) 2876 continue 2877 raise plumbing.convert_error_to_porcelain(e) from e 2878 tries = 0 2879 for plumbing_item in plumbing_response.granted_role_entitlements: 2880 yield plumbing.convert_granted_role_entitlement_to_porcelain( 2881 plumbing_item) 2882 if plumbing_response.meta.next_cursor == '': 2883 break 2884 req.meta.cursor = plumbing_response.meta.next_cursor 2885 2886 return generator(self, req)
List gets a list of GrantedRoleEntitlement records matching a given set of criteria.
class
SnapshotGrantedRoleEntitlements:
2889class SnapshotGrantedRoleEntitlements: 2890 ''' 2891 SnapshotGrantedRoleEntitlements exposes the read only methods of the GrantedRoleEntitlements 2892 service for historical queries. 2893 ''' 2894 def __init__(self, granted_role_entitlements): 2895 self.granted_role_entitlements = granted_role_entitlements 2896 2897 def list(self, role_id, filter, *args, timeout=None): 2898 ''' 2899 List gets a list of GrantedRoleEntitlement records matching a given set of criteria. 2900 ''' 2901 return self.granted_role_entitlements.list(role_id, 2902 filter, 2903 *args, 2904 timeout=timeout)
SnapshotGrantedRoleEntitlements exposes the read only methods of the GrantedRoleEntitlements service for historical queries.
def
list(self, role_id, filter, *args, timeout=None)
2897 def list(self, role_id, filter, *args, timeout=None): 2898 ''' 2899 List gets a list of GrantedRoleEntitlement records matching a given set of criteria. 2900 ''' 2901 return self.granted_role_entitlements.list(role_id, 2902 filter, 2903 *args, 2904 timeout=timeout)
List gets a list of GrantedRoleEntitlement records matching a given set of criteria.
class
Roles:
2907class Roles: 2908 ''' 2909 A Role has a list of access rules which determine which Resources the members 2910 of the Role have access to. An Account can be a member of multiple Roles via 2911 AccountAttachments. 2912 See `strongdm.models.Role`. 2913 ''' 2914 def __init__(self, channel, client): 2915 self.parent = client 2916 self.stub = RolesStub(channel) 2917 2918 def create(self, role, timeout=None): 2919 ''' 2920 Create registers a new Role. 2921 ''' 2922 deadline = None if timeout is None else time.time() + timeout 2923 req = RoleCreateRequest() 2924 2925 if role is not None: 2926 req.role.CopyFrom(plumbing.convert_role_to_plumbing(role)) 2927 tries = 0 2928 plumbing_response = None 2929 while True: 2930 t = None if deadline is None else deadline - time.time() 2931 try: 2932 plumbing_response = self.stub.Create( 2933 req, 2934 metadata=self.parent.get_metadata('Roles.Create', req), 2935 timeout=t) 2936 except Exception as e: 2937 if self.parent.shouldRetry(tries, e, deadline): 2938 tries += 1 2939 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2940 continue 2941 raise plumbing.convert_error_to_porcelain(e) from e 2942 break 2943 2944 resp = models.RoleCreateResponse() 2945 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 2946 plumbing_response.meta) 2947 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2948 plumbing_response.rate_limit) 2949 resp.role = plumbing.convert_role_to_porcelain(plumbing_response.role) 2950 return resp 2951 2952 def get(self, id, timeout=None): 2953 ''' 2954 Get reads one Role by ID. 2955 ''' 2956 deadline = None if timeout is None else time.time() + timeout 2957 req = RoleGetRequest() 2958 if self.parent.snapshot_datetime is not None: 2959 req.meta.CopyFrom(GetRequestMetadata()) 2960 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2961 2962 req.id = (id) 2963 tries = 0 2964 plumbing_response = None 2965 while True: 2966 t = None if deadline is None else deadline - time.time() 2967 try: 2968 plumbing_response = self.stub.Get( 2969 req, 2970 metadata=self.parent.get_metadata('Roles.Get', req), 2971 timeout=t) 2972 except Exception as e: 2973 if self.parent.shouldRetry(tries, e, deadline): 2974 tries += 1 2975 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2976 continue 2977 raise plumbing.convert_error_to_porcelain(e) from e 2978 break 2979 2980 resp = models.RoleGetResponse() 2981 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2982 plumbing_response.meta) 2983 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2984 plumbing_response.rate_limit) 2985 resp.role = plumbing.convert_role_to_porcelain(plumbing_response.role) 2986 return resp 2987 2988 def update(self, role, timeout=None): 2989 ''' 2990 Update replaces all the fields of a Role by ID. 2991 ''' 2992 deadline = None if timeout is None else time.time() + timeout 2993 req = RoleUpdateRequest() 2994 2995 if role is not None: 2996 req.role.CopyFrom(plumbing.convert_role_to_plumbing(role)) 2997 tries = 0 2998 plumbing_response = None 2999 while True: 3000 t = None if deadline is None else deadline - time.time() 3001 try: 3002 plumbing_response = self.stub.Update( 3003 req, 3004 metadata=self.parent.get_metadata('Roles.Update', req), 3005 timeout=t) 3006 except Exception as e: 3007 if self.parent.shouldRetry(tries, e, deadline): 3008 tries += 1 3009 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3010 continue 3011 raise plumbing.convert_error_to_porcelain(e) from e 3012 break 3013 3014 resp = models.RoleUpdateResponse() 3015 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 3016 plumbing_response.meta) 3017 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3018 plumbing_response.rate_limit) 3019 resp.role = plumbing.convert_role_to_porcelain(plumbing_response.role) 3020 return resp 3021 3022 def delete(self, id, timeout=None): 3023 ''' 3024 Delete removes a Role by ID. 3025 ''' 3026 deadline = None if timeout is None else time.time() + timeout 3027 req = RoleDeleteRequest() 3028 3029 req.id = (id) 3030 tries = 0 3031 plumbing_response = None 3032 while True: 3033 t = None if deadline is None else deadline - time.time() 3034 try: 3035 plumbing_response = self.stub.Delete( 3036 req, 3037 metadata=self.parent.get_metadata('Roles.Delete', req), 3038 timeout=t) 3039 except Exception as e: 3040 if self.parent.shouldRetry(tries, e, deadline): 3041 tries += 1 3042 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3043 continue 3044 raise plumbing.convert_error_to_porcelain(e) from e 3045 break 3046 3047 resp = models.RoleDeleteResponse() 3048 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3049 plumbing_response.meta) 3050 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3051 plumbing_response.rate_limit) 3052 return resp 3053 3054 def list(self, filter, *args, timeout=None): 3055 ''' 3056 List gets a list of Roles matching a given set of criteria. 3057 ''' 3058 deadline = None if timeout is None else time.time() + timeout 3059 req = RoleListRequest() 3060 req.meta.CopyFrom(ListRequestMetadata()) 3061 if self.parent.page_limit > 0: 3062 req.meta.limit = self.parent.page_limit 3063 if self.parent.snapshot_datetime is not None: 3064 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3065 3066 req.filter = plumbing.quote_filter_args(filter, *args) 3067 3068 def generator(svc, req): 3069 tries = 0 3070 while True: 3071 t = None if deadline is None else deadline - time.time() 3072 try: 3073 plumbing_response = svc.stub.List( 3074 req, 3075 metadata=svc.parent.get_metadata('Roles.List', req), 3076 timeout=t) 3077 except Exception as e: 3078 if self.parent.shouldRetry(tries, e, deadline): 3079 tries += 1 3080 time.sleep( 3081 self.parent.exponentialBackoff(tries, deadline)) 3082 continue 3083 raise plumbing.convert_error_to_porcelain(e) from e 3084 tries = 0 3085 for plumbing_item in plumbing_response.roles: 3086 yield plumbing.convert_role_to_porcelain(plumbing_item) 3087 if plumbing_response.meta.next_cursor == '': 3088 break 3089 req.meta.cursor = plumbing_response.meta.next_cursor 3090 3091 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)
2918 def create(self, role, timeout=None): 2919 ''' 2920 Create registers a new Role. 2921 ''' 2922 deadline = None if timeout is None else time.time() + timeout 2923 req = RoleCreateRequest() 2924 2925 if role is not None: 2926 req.role.CopyFrom(plumbing.convert_role_to_plumbing(role)) 2927 tries = 0 2928 plumbing_response = None 2929 while True: 2930 t = None if deadline is None else deadline - time.time() 2931 try: 2932 plumbing_response = self.stub.Create( 2933 req, 2934 metadata=self.parent.get_metadata('Roles.Create', req), 2935 timeout=t) 2936 except Exception as e: 2937 if self.parent.shouldRetry(tries, e, deadline): 2938 tries += 1 2939 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2940 continue 2941 raise plumbing.convert_error_to_porcelain(e) from e 2942 break 2943 2944 resp = models.RoleCreateResponse() 2945 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 2946 plumbing_response.meta) 2947 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2948 plumbing_response.rate_limit) 2949 resp.role = plumbing.convert_role_to_porcelain(plumbing_response.role) 2950 return resp
Create registers a new Role.
def
get(self, id, timeout=None)
2952 def get(self, id, timeout=None): 2953 ''' 2954 Get reads one Role by ID. 2955 ''' 2956 deadline = None if timeout is None else time.time() + timeout 2957 req = RoleGetRequest() 2958 if self.parent.snapshot_datetime is not None: 2959 req.meta.CopyFrom(GetRequestMetadata()) 2960 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2961 2962 req.id = (id) 2963 tries = 0 2964 plumbing_response = None 2965 while True: 2966 t = None if deadline is None else deadline - time.time() 2967 try: 2968 plumbing_response = self.stub.Get( 2969 req, 2970 metadata=self.parent.get_metadata('Roles.Get', req), 2971 timeout=t) 2972 except Exception as e: 2973 if self.parent.shouldRetry(tries, e, deadline): 2974 tries += 1 2975 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2976 continue 2977 raise plumbing.convert_error_to_porcelain(e) from e 2978 break 2979 2980 resp = models.RoleGetResponse() 2981 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2982 plumbing_response.meta) 2983 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2984 plumbing_response.rate_limit) 2985 resp.role = plumbing.convert_role_to_porcelain(plumbing_response.role) 2986 return resp
Get reads one Role by ID.
def
update(self, role, timeout=None)
2988 def update(self, role, timeout=None): 2989 ''' 2990 Update replaces all the fields of a Role by ID. 2991 ''' 2992 deadline = None if timeout is None else time.time() + timeout 2993 req = RoleUpdateRequest() 2994 2995 if role is not None: 2996 req.role.CopyFrom(plumbing.convert_role_to_plumbing(role)) 2997 tries = 0 2998 plumbing_response = None 2999 while True: 3000 t = None if deadline is None else deadline - time.time() 3001 try: 3002 plumbing_response = self.stub.Update( 3003 req, 3004 metadata=self.parent.get_metadata('Roles.Update', req), 3005 timeout=t) 3006 except Exception as e: 3007 if self.parent.shouldRetry(tries, e, deadline): 3008 tries += 1 3009 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3010 continue 3011 raise plumbing.convert_error_to_porcelain(e) from e 3012 break 3013 3014 resp = models.RoleUpdateResponse() 3015 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 3016 plumbing_response.meta) 3017 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3018 plumbing_response.rate_limit) 3019 resp.role = plumbing.convert_role_to_porcelain(plumbing_response.role) 3020 return resp
Update replaces all the fields of a Role by ID.
def
delete(self, id, timeout=None)
3022 def delete(self, id, timeout=None): 3023 ''' 3024 Delete removes a Role by ID. 3025 ''' 3026 deadline = None if timeout is None else time.time() + timeout 3027 req = RoleDeleteRequest() 3028 3029 req.id = (id) 3030 tries = 0 3031 plumbing_response = None 3032 while True: 3033 t = None if deadline is None else deadline - time.time() 3034 try: 3035 plumbing_response = self.stub.Delete( 3036 req, 3037 metadata=self.parent.get_metadata('Roles.Delete', req), 3038 timeout=t) 3039 except Exception as e: 3040 if self.parent.shouldRetry(tries, e, deadline): 3041 tries += 1 3042 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3043 continue 3044 raise plumbing.convert_error_to_porcelain(e) from e 3045 break 3046 3047 resp = models.RoleDeleteResponse() 3048 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3049 plumbing_response.meta) 3050 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3051 plumbing_response.rate_limit) 3052 return resp
Delete removes a Role by ID.
def
list(self, filter, *args, timeout=None)
3054 def list(self, filter, *args, timeout=None): 3055 ''' 3056 List gets a list of Roles matching a given set of criteria. 3057 ''' 3058 deadline = None if timeout is None else time.time() + timeout 3059 req = RoleListRequest() 3060 req.meta.CopyFrom(ListRequestMetadata()) 3061 if self.parent.page_limit > 0: 3062 req.meta.limit = self.parent.page_limit 3063 if self.parent.snapshot_datetime is not None: 3064 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3065 3066 req.filter = plumbing.quote_filter_args(filter, *args) 3067 3068 def generator(svc, req): 3069 tries = 0 3070 while True: 3071 t = None if deadline is None else deadline - time.time() 3072 try: 3073 plumbing_response = svc.stub.List( 3074 req, 3075 metadata=svc.parent.get_metadata('Roles.List', req), 3076 timeout=t) 3077 except Exception as e: 3078 if self.parent.shouldRetry(tries, e, deadline): 3079 tries += 1 3080 time.sleep( 3081 self.parent.exponentialBackoff(tries, deadline)) 3082 continue 3083 raise plumbing.convert_error_to_porcelain(e) from e 3084 tries = 0 3085 for plumbing_item in plumbing_response.roles: 3086 yield plumbing.convert_role_to_porcelain(plumbing_item) 3087 if plumbing_response.meta.next_cursor == '': 3088 break 3089 req.meta.cursor = plumbing_response.meta.next_cursor 3090 3091 return generator(self, req)
List gets a list of Roles matching a given set of criteria.
class
SnapshotRoles:
3094class SnapshotRoles: 3095 ''' 3096 SnapshotRoles exposes the read only methods of the Roles 3097 service for historical queries. 3098 ''' 3099 def __init__(self, roles): 3100 self.roles = roles 3101 3102 def get(self, id, timeout=None): 3103 ''' 3104 Get reads one Role by ID. 3105 ''' 3106 return self.roles.get(id, timeout=timeout) 3107 3108 def list(self, filter, *args, timeout=None): 3109 ''' 3110 List gets a list of Roles matching a given set of criteria. 3111 ''' 3112 return self.roles.list(filter, *args, timeout=timeout)
SnapshotRoles exposes the read only methods of the Roles service for historical queries.
class
Groups:
3115class Groups: 3116 ''' 3117 A Group is a set of principals. 3118 See `strongdm.models.Group`. 3119 ''' 3120 def __init__(self, channel, client): 3121 self.parent = client 3122 self.stub = GroupsStub(channel) 3123 3124 def create(self, group, timeout=None): 3125 ''' 3126 Create registers a new Group. 3127 ''' 3128 deadline = None if timeout is None else time.time() + timeout 3129 req = GroupCreateRequest() 3130 3131 if group is not None: 3132 req.group.CopyFrom(plumbing.convert_group_to_plumbing(group)) 3133 tries = 0 3134 plumbing_response = None 3135 while True: 3136 t = None if deadline is None else deadline - time.time() 3137 try: 3138 plumbing_response = self.stub.Create( 3139 req, 3140 metadata=self.parent.get_metadata('Groups.Create', req), 3141 timeout=t) 3142 except Exception as e: 3143 if self.parent.shouldRetry(tries, e, deadline): 3144 tries += 1 3145 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3146 continue 3147 raise plumbing.convert_error_to_porcelain(e) from e 3148 break 3149 3150 resp = models.GroupCreateResponse() 3151 resp.group = plumbing.convert_group_to_porcelain( 3152 plumbing_response.group) 3153 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3154 plumbing_response.rate_limit) 3155 return resp 3156 3157 def create_from_roles(self, role_ids, commit, timeout=None): 3158 deadline = None if timeout is None else time.time() + timeout 3159 req = GroupCreateFromRolesRequest() 3160 3161 req.role_ids.extend((role_ids)) 3162 req.commit = (commit) 3163 tries = 0 3164 plumbing_response = None 3165 while True: 3166 t = None if deadline is None else deadline - time.time() 3167 try: 3168 plumbing_response = self.stub.CreateFromRoles( 3169 req, 3170 metadata=self.parent.get_metadata('Groups.CreateFromRoles', 3171 req), 3172 timeout=t) 3173 except Exception as e: 3174 if self.parent.shouldRetry(tries, e, deadline): 3175 tries += 1 3176 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3177 continue 3178 raise plumbing.convert_error_to_porcelain(e) from e 3179 break 3180 3181 resp = models.GroupCreateFromRolesResponse() 3182 resp.group_from_role = plumbing.convert_repeated_group_from_role_to_porcelain( 3183 plumbing_response.group_from_role) 3184 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3185 plumbing_response.rate_limit) 3186 return resp 3187 3188 def get(self, id, timeout=None): 3189 ''' 3190 Get reads one Group by ID. 3191 ''' 3192 deadline = None if timeout is None else time.time() + timeout 3193 req = GroupGetRequest() 3194 if self.parent.snapshot_datetime is not None: 3195 req.meta.CopyFrom(GetRequestMetadata()) 3196 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3197 3198 req.id = (id) 3199 tries = 0 3200 plumbing_response = None 3201 while True: 3202 t = None if deadline is None else deadline - time.time() 3203 try: 3204 plumbing_response = self.stub.Get( 3205 req, 3206 metadata=self.parent.get_metadata('Groups.Get', req), 3207 timeout=t) 3208 except Exception as e: 3209 if self.parent.shouldRetry(tries, e, deadline): 3210 tries += 1 3211 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3212 continue 3213 raise plumbing.convert_error_to_porcelain(e) from e 3214 break 3215 3216 resp = models.GroupGetResponse() 3217 resp.group = plumbing.convert_group_to_porcelain( 3218 plumbing_response.group) 3219 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3220 plumbing_response.meta) 3221 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3222 plumbing_response.rate_limit) 3223 return resp 3224 3225 def update(self, group, timeout=None): 3226 ''' 3227 Update replaces all the fields of a Group by ID. 3228 ''' 3229 deadline = None if timeout is None else time.time() + timeout 3230 req = GroupUpdateRequest() 3231 3232 if group is not None: 3233 req.group.CopyFrom(plumbing.convert_group_to_plumbing(group)) 3234 tries = 0 3235 plumbing_response = None 3236 while True: 3237 t = None if deadline is None else deadline - time.time() 3238 try: 3239 plumbing_response = self.stub.Update( 3240 req, 3241 metadata=self.parent.get_metadata('Groups.Update', req), 3242 timeout=t) 3243 except Exception as e: 3244 if self.parent.shouldRetry(tries, e, deadline): 3245 tries += 1 3246 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3247 continue 3248 raise plumbing.convert_error_to_porcelain(e) from e 3249 break 3250 3251 resp = models.GroupUpdateResponse() 3252 resp.group = plumbing.convert_group_to_porcelain( 3253 plumbing_response.group) 3254 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3255 plumbing_response.rate_limit) 3256 return resp 3257 3258 def delete(self, id, timeout=None): 3259 ''' 3260 Delete removes a Group by ID. 3261 ''' 3262 deadline = None if timeout is None else time.time() + timeout 3263 req = GroupDeleteRequest() 3264 3265 req.id = (id) 3266 tries = 0 3267 plumbing_response = None 3268 while True: 3269 t = None if deadline is None else deadline - time.time() 3270 try: 3271 plumbing_response = self.stub.Delete( 3272 req, 3273 metadata=self.parent.get_metadata('Groups.Delete', req), 3274 timeout=t) 3275 except Exception as e: 3276 if self.parent.shouldRetry(tries, e, deadline): 3277 tries += 1 3278 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3279 continue 3280 raise plumbing.convert_error_to_porcelain(e) from e 3281 break 3282 3283 resp = models.GroupDeleteResponse() 3284 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3285 plumbing_response.meta) 3286 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3287 plumbing_response.rate_limit) 3288 return resp 3289 3290 def list(self, filter, *args, timeout=None): 3291 ''' 3292 List gets a list of Groups matching a given set of criteria. 3293 ''' 3294 deadline = None if timeout is None else time.time() + timeout 3295 req = GroupListRequest() 3296 req.meta.CopyFrom(ListRequestMetadata()) 3297 if self.parent.page_limit > 0: 3298 req.meta.limit = self.parent.page_limit 3299 if self.parent.snapshot_datetime is not None: 3300 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3301 3302 req.filter = plumbing.quote_filter_args(filter, *args) 3303 3304 def generator(svc, req): 3305 tries = 0 3306 while True: 3307 t = None if deadline is None else deadline - time.time() 3308 try: 3309 plumbing_response = svc.stub.List( 3310 req, 3311 metadata=svc.parent.get_metadata('Groups.List', req), 3312 timeout=t) 3313 except Exception as e: 3314 if self.parent.shouldRetry(tries, e, deadline): 3315 tries += 1 3316 time.sleep( 3317 self.parent.exponentialBackoff(tries, deadline)) 3318 continue 3319 raise plumbing.convert_error_to_porcelain(e) from e 3320 tries = 0 3321 for plumbing_item in plumbing_response.groups: 3322 yield plumbing.convert_group_to_porcelain(plumbing_item) 3323 if plumbing_response.meta.next_cursor == '': 3324 break 3325 req.meta.cursor = plumbing_response.meta.next_cursor 3326 3327 return generator(self, req)
A Group is a set of principals.
See strongdm.models.Group.
def
create(self, group, timeout=None)
3124 def create(self, group, timeout=None): 3125 ''' 3126 Create registers a new Group. 3127 ''' 3128 deadline = None if timeout is None else time.time() + timeout 3129 req = GroupCreateRequest() 3130 3131 if group is not None: 3132 req.group.CopyFrom(plumbing.convert_group_to_plumbing(group)) 3133 tries = 0 3134 plumbing_response = None 3135 while True: 3136 t = None if deadline is None else deadline - time.time() 3137 try: 3138 plumbing_response = self.stub.Create( 3139 req, 3140 metadata=self.parent.get_metadata('Groups.Create', req), 3141 timeout=t) 3142 except Exception as e: 3143 if self.parent.shouldRetry(tries, e, deadline): 3144 tries += 1 3145 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3146 continue 3147 raise plumbing.convert_error_to_porcelain(e) from e 3148 break 3149 3150 resp = models.GroupCreateResponse() 3151 resp.group = plumbing.convert_group_to_porcelain( 3152 plumbing_response.group) 3153 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3154 plumbing_response.rate_limit) 3155 return resp
Create registers a new Group.
def
create_from_roles(self, role_ids, commit, timeout=None)
3157 def create_from_roles(self, role_ids, commit, timeout=None): 3158 deadline = None if timeout is None else time.time() + timeout 3159 req = GroupCreateFromRolesRequest() 3160 3161 req.role_ids.extend((role_ids)) 3162 req.commit = (commit) 3163 tries = 0 3164 plumbing_response = None 3165 while True: 3166 t = None if deadline is None else deadline - time.time() 3167 try: 3168 plumbing_response = self.stub.CreateFromRoles( 3169 req, 3170 metadata=self.parent.get_metadata('Groups.CreateFromRoles', 3171 req), 3172 timeout=t) 3173 except Exception as e: 3174 if self.parent.shouldRetry(tries, e, deadline): 3175 tries += 1 3176 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3177 continue 3178 raise plumbing.convert_error_to_porcelain(e) from e 3179 break 3180 3181 resp = models.GroupCreateFromRolesResponse() 3182 resp.group_from_role = plumbing.convert_repeated_group_from_role_to_porcelain( 3183 plumbing_response.group_from_role) 3184 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3185 plumbing_response.rate_limit) 3186 return resp
def
get(self, id, timeout=None)
3188 def get(self, id, timeout=None): 3189 ''' 3190 Get reads one Group by ID. 3191 ''' 3192 deadline = None if timeout is None else time.time() + timeout 3193 req = GroupGetRequest() 3194 if self.parent.snapshot_datetime is not None: 3195 req.meta.CopyFrom(GetRequestMetadata()) 3196 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3197 3198 req.id = (id) 3199 tries = 0 3200 plumbing_response = None 3201 while True: 3202 t = None if deadline is None else deadline - time.time() 3203 try: 3204 plumbing_response = self.stub.Get( 3205 req, 3206 metadata=self.parent.get_metadata('Groups.Get', req), 3207 timeout=t) 3208 except Exception as e: 3209 if self.parent.shouldRetry(tries, e, deadline): 3210 tries += 1 3211 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3212 continue 3213 raise plumbing.convert_error_to_porcelain(e) from e 3214 break 3215 3216 resp = models.GroupGetResponse() 3217 resp.group = plumbing.convert_group_to_porcelain( 3218 plumbing_response.group) 3219 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3220 plumbing_response.meta) 3221 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3222 plumbing_response.rate_limit) 3223 return resp
Get reads one Group by ID.
def
update(self, group, timeout=None)
3225 def update(self, group, timeout=None): 3226 ''' 3227 Update replaces all the fields of a Group by ID. 3228 ''' 3229 deadline = None if timeout is None else time.time() + timeout 3230 req = GroupUpdateRequest() 3231 3232 if group is not None: 3233 req.group.CopyFrom(plumbing.convert_group_to_plumbing(group)) 3234 tries = 0 3235 plumbing_response = None 3236 while True: 3237 t = None if deadline is None else deadline - time.time() 3238 try: 3239 plumbing_response = self.stub.Update( 3240 req, 3241 metadata=self.parent.get_metadata('Groups.Update', req), 3242 timeout=t) 3243 except Exception as e: 3244 if self.parent.shouldRetry(tries, e, deadline): 3245 tries += 1 3246 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3247 continue 3248 raise plumbing.convert_error_to_porcelain(e) from e 3249 break 3250 3251 resp = models.GroupUpdateResponse() 3252 resp.group = plumbing.convert_group_to_porcelain( 3253 plumbing_response.group) 3254 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3255 plumbing_response.rate_limit) 3256 return resp
Update replaces all the fields of a Group by ID.
def
delete(self, id, timeout=None)
3258 def delete(self, id, timeout=None): 3259 ''' 3260 Delete removes a Group by ID. 3261 ''' 3262 deadline = None if timeout is None else time.time() + timeout 3263 req = GroupDeleteRequest() 3264 3265 req.id = (id) 3266 tries = 0 3267 plumbing_response = None 3268 while True: 3269 t = None if deadline is None else deadline - time.time() 3270 try: 3271 plumbing_response = self.stub.Delete( 3272 req, 3273 metadata=self.parent.get_metadata('Groups.Delete', req), 3274 timeout=t) 3275 except Exception as e: 3276 if self.parent.shouldRetry(tries, e, deadline): 3277 tries += 1 3278 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3279 continue 3280 raise plumbing.convert_error_to_porcelain(e) from e 3281 break 3282 3283 resp = models.GroupDeleteResponse() 3284 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3285 plumbing_response.meta) 3286 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3287 plumbing_response.rate_limit) 3288 return resp
Delete removes a Group by ID.
def
list(self, filter, *args, timeout=None)
3290 def list(self, filter, *args, timeout=None): 3291 ''' 3292 List gets a list of Groups matching a given set of criteria. 3293 ''' 3294 deadline = None if timeout is None else time.time() + timeout 3295 req = GroupListRequest() 3296 req.meta.CopyFrom(ListRequestMetadata()) 3297 if self.parent.page_limit > 0: 3298 req.meta.limit = self.parent.page_limit 3299 if self.parent.snapshot_datetime is not None: 3300 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3301 3302 req.filter = plumbing.quote_filter_args(filter, *args) 3303 3304 def generator(svc, req): 3305 tries = 0 3306 while True: 3307 t = None if deadline is None else deadline - time.time() 3308 try: 3309 plumbing_response = svc.stub.List( 3310 req, 3311 metadata=svc.parent.get_metadata('Groups.List', req), 3312 timeout=t) 3313 except Exception as e: 3314 if self.parent.shouldRetry(tries, e, deadline): 3315 tries += 1 3316 time.sleep( 3317 self.parent.exponentialBackoff(tries, deadline)) 3318 continue 3319 raise plumbing.convert_error_to_porcelain(e) from e 3320 tries = 0 3321 for plumbing_item in plumbing_response.groups: 3322 yield plumbing.convert_group_to_porcelain(plumbing_item) 3323 if plumbing_response.meta.next_cursor == '': 3324 break 3325 req.meta.cursor = plumbing_response.meta.next_cursor 3326 3327 return generator(self, req)
List gets a list of Groups matching a given set of criteria.
class
SnapshotGroups:
3330class SnapshotGroups: 3331 ''' 3332 SnapshotGroups exposes the read only methods of the Groups 3333 service for historical queries. 3334 ''' 3335 def __init__(self, groups): 3336 self.groups = groups 3337 3338 def get(self, id, timeout=None): 3339 ''' 3340 Get reads one Group by ID. 3341 ''' 3342 return self.groups.get(id, timeout=timeout) 3343 3344 def list(self, filter, *args, timeout=None): 3345 ''' 3346 List gets a list of Groups matching a given set of criteria. 3347 ''' 3348 return self.groups.list(filter, *args, timeout=timeout)
SnapshotGroups exposes the read only methods of the Groups service for historical queries.
class
GroupsHistory:
3351class GroupsHistory: 3352 ''' 3353 GroupsHistory records all changes to the state of a Group. 3354 See `strongdm.models.GroupHistory`. 3355 ''' 3356 def __init__(self, channel, client): 3357 self.parent = client 3358 self.stub = GroupsHistoryStub(channel) 3359 3360 def list(self, filter, *args, timeout=None): 3361 ''' 3362 List gets a list of GroupHistory records matching a given set of criteria. 3363 ''' 3364 deadline = None if timeout is None else time.time() + timeout 3365 req = GroupHistoryListRequest() 3366 req.meta.CopyFrom(ListRequestMetadata()) 3367 if self.parent.page_limit > 0: 3368 req.meta.limit = self.parent.page_limit 3369 if self.parent.snapshot_datetime is not None: 3370 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3371 3372 req.filter = plumbing.quote_filter_args(filter, *args) 3373 3374 def generator(svc, req): 3375 tries = 0 3376 while True: 3377 t = None if deadline is None else deadline - time.time() 3378 try: 3379 plumbing_response = svc.stub.List( 3380 req, 3381 metadata=svc.parent.get_metadata( 3382 'GroupsHistory.List', req), 3383 timeout=t) 3384 except Exception as e: 3385 if self.parent.shouldRetry(tries, e, deadline): 3386 tries += 1 3387 time.sleep( 3388 self.parent.exponentialBackoff(tries, deadline)) 3389 continue 3390 raise plumbing.convert_error_to_porcelain(e) from e 3391 tries = 0 3392 for plumbing_item in plumbing_response.history: 3393 yield plumbing.convert_group_history_to_porcelain( 3394 plumbing_item) 3395 if plumbing_response.meta.next_cursor == '': 3396 break 3397 req.meta.cursor = plumbing_response.meta.next_cursor 3398 3399 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)
3360 def list(self, filter, *args, timeout=None): 3361 ''' 3362 List gets a list of GroupHistory records matching a given set of criteria. 3363 ''' 3364 deadline = None if timeout is None else time.time() + timeout 3365 req = GroupHistoryListRequest() 3366 req.meta.CopyFrom(ListRequestMetadata()) 3367 if self.parent.page_limit > 0: 3368 req.meta.limit = self.parent.page_limit 3369 if self.parent.snapshot_datetime is not None: 3370 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3371 3372 req.filter = plumbing.quote_filter_args(filter, *args) 3373 3374 def generator(svc, req): 3375 tries = 0 3376 while True: 3377 t = None if deadline is None else deadline - time.time() 3378 try: 3379 plumbing_response = svc.stub.List( 3380 req, 3381 metadata=svc.parent.get_metadata( 3382 'GroupsHistory.List', req), 3383 timeout=t) 3384 except Exception as e: 3385 if self.parent.shouldRetry(tries, e, deadline): 3386 tries += 1 3387 time.sleep( 3388 self.parent.exponentialBackoff(tries, deadline)) 3389 continue 3390 raise plumbing.convert_error_to_porcelain(e) from e 3391 tries = 0 3392 for plumbing_item in plumbing_response.history: 3393 yield plumbing.convert_group_history_to_porcelain( 3394 plumbing_item) 3395 if plumbing_response.meta.next_cursor == '': 3396 break 3397 req.meta.cursor = plumbing_response.meta.next_cursor 3398 3399 return generator(self, req)
List gets a list of GroupHistory records matching a given set of criteria.
class
GroupsRoles:
3402class GroupsRoles: 3403 ''' 3404 A GroupRole is an assignment of a Group to a Role. 3405 See `strongdm.models.GroupRole`. 3406 ''' 3407 def __init__(self, channel, client): 3408 self.parent = client 3409 self.stub = GroupsRolesStub(channel) 3410 3411 def create(self, group_role, timeout=None): 3412 ''' 3413 Create registers a new GroupRole. 3414 ''' 3415 deadline = None if timeout is None else time.time() + timeout 3416 req = GroupRoleCreateRequest() 3417 3418 if group_role is not None: 3419 req.group_role.CopyFrom( 3420 plumbing.convert_group_role_to_plumbing(group_role)) 3421 tries = 0 3422 plumbing_response = None 3423 while True: 3424 t = None if deadline is None else deadline - time.time() 3425 try: 3426 plumbing_response = self.stub.Create( 3427 req, 3428 metadata=self.parent.get_metadata('GroupsRoles.Create', 3429 req), 3430 timeout=t) 3431 except Exception as e: 3432 if self.parent.shouldRetry(tries, e, deadline): 3433 tries += 1 3434 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3435 continue 3436 raise plumbing.convert_error_to_porcelain(e) from e 3437 break 3438 3439 resp = models.GroupRoleCreateResponse() 3440 resp.group_role = plumbing.convert_group_role_to_porcelain( 3441 plumbing_response.group_role) 3442 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3443 plumbing_response.rate_limit) 3444 return resp 3445 3446 def get(self, id, timeout=None): 3447 ''' 3448 Get reads one GroupRole by ID. 3449 ''' 3450 deadline = None if timeout is None else time.time() + timeout 3451 req = GroupRoleGetRequest() 3452 if self.parent.snapshot_datetime is not None: 3453 req.meta.CopyFrom(GetRequestMetadata()) 3454 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3455 3456 req.id = (id) 3457 tries = 0 3458 plumbing_response = None 3459 while True: 3460 t = None if deadline is None else deadline - time.time() 3461 try: 3462 plumbing_response = self.stub.Get( 3463 req, 3464 metadata=self.parent.get_metadata('GroupsRoles.Get', req), 3465 timeout=t) 3466 except Exception as e: 3467 if self.parent.shouldRetry(tries, e, deadline): 3468 tries += 1 3469 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3470 continue 3471 raise plumbing.convert_error_to_porcelain(e) from e 3472 break 3473 3474 resp = models.GroupRoleGetResponse() 3475 resp.group_role = plumbing.convert_group_role_to_porcelain( 3476 plumbing_response.group_role) 3477 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3478 plumbing_response.meta) 3479 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3480 plumbing_response.rate_limit) 3481 return resp 3482 3483 def delete(self, id, timeout=None): 3484 ''' 3485 Delete removes a GroupRole by ID. 3486 ''' 3487 deadline = None if timeout is None else time.time() + timeout 3488 req = GroupRoleDeleteRequest() 3489 3490 req.id = (id) 3491 tries = 0 3492 plumbing_response = None 3493 while True: 3494 t = None if deadline is None else deadline - time.time() 3495 try: 3496 plumbing_response = self.stub.Delete( 3497 req, 3498 metadata=self.parent.get_metadata('GroupsRoles.Delete', 3499 req), 3500 timeout=t) 3501 except Exception as e: 3502 if self.parent.shouldRetry(tries, e, deadline): 3503 tries += 1 3504 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3505 continue 3506 raise plumbing.convert_error_to_porcelain(e) from e 3507 break 3508 3509 resp = models.GroupRoleDeleteResponse() 3510 resp.group_role = plumbing.convert_group_role_to_porcelain( 3511 plumbing_response.group_role) 3512 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3513 plumbing_response.meta) 3514 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3515 plumbing_response.rate_limit) 3516 return resp 3517 3518 def list(self, filter, *args, timeout=None): 3519 ''' 3520 List gets a list of GroupRoles matching a given set of criteria. 3521 ''' 3522 deadline = None if timeout is None else time.time() + timeout 3523 req = GroupRoleListRequest() 3524 req.meta.CopyFrom(ListRequestMetadata()) 3525 if self.parent.page_limit > 0: 3526 req.meta.limit = self.parent.page_limit 3527 if self.parent.snapshot_datetime is not None: 3528 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3529 3530 req.filter = plumbing.quote_filter_args(filter, *args) 3531 3532 def generator(svc, req): 3533 tries = 0 3534 while True: 3535 t = None if deadline is None else deadline - time.time() 3536 try: 3537 plumbing_response = svc.stub.List( 3538 req, 3539 metadata=svc.parent.get_metadata( 3540 'GroupsRoles.List', req), 3541 timeout=t) 3542 except Exception as e: 3543 if self.parent.shouldRetry(tries, e, deadline): 3544 tries += 1 3545 time.sleep( 3546 self.parent.exponentialBackoff(tries, deadline)) 3547 continue 3548 raise plumbing.convert_error_to_porcelain(e) from e 3549 tries = 0 3550 for plumbing_item in plumbing_response.groups_roles: 3551 yield plumbing.convert_group_role_to_porcelain( 3552 plumbing_item) 3553 if plumbing_response.meta.next_cursor == '': 3554 break 3555 req.meta.cursor = plumbing_response.meta.next_cursor 3556 3557 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)
3411 def create(self, group_role, timeout=None): 3412 ''' 3413 Create registers a new GroupRole. 3414 ''' 3415 deadline = None if timeout is None else time.time() + timeout 3416 req = GroupRoleCreateRequest() 3417 3418 if group_role is not None: 3419 req.group_role.CopyFrom( 3420 plumbing.convert_group_role_to_plumbing(group_role)) 3421 tries = 0 3422 plumbing_response = None 3423 while True: 3424 t = None if deadline is None else deadline - time.time() 3425 try: 3426 plumbing_response = self.stub.Create( 3427 req, 3428 metadata=self.parent.get_metadata('GroupsRoles.Create', 3429 req), 3430 timeout=t) 3431 except Exception as e: 3432 if self.parent.shouldRetry(tries, e, deadline): 3433 tries += 1 3434 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3435 continue 3436 raise plumbing.convert_error_to_porcelain(e) from e 3437 break 3438 3439 resp = models.GroupRoleCreateResponse() 3440 resp.group_role = plumbing.convert_group_role_to_porcelain( 3441 plumbing_response.group_role) 3442 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3443 plumbing_response.rate_limit) 3444 return resp
Create registers a new GroupRole.
def
get(self, id, timeout=None)
3446 def get(self, id, timeout=None): 3447 ''' 3448 Get reads one GroupRole by ID. 3449 ''' 3450 deadline = None if timeout is None else time.time() + timeout 3451 req = GroupRoleGetRequest() 3452 if self.parent.snapshot_datetime is not None: 3453 req.meta.CopyFrom(GetRequestMetadata()) 3454 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3455 3456 req.id = (id) 3457 tries = 0 3458 plumbing_response = None 3459 while True: 3460 t = None if deadline is None else deadline - time.time() 3461 try: 3462 plumbing_response = self.stub.Get( 3463 req, 3464 metadata=self.parent.get_metadata('GroupsRoles.Get', req), 3465 timeout=t) 3466 except Exception as e: 3467 if self.parent.shouldRetry(tries, e, deadline): 3468 tries += 1 3469 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3470 continue 3471 raise plumbing.convert_error_to_porcelain(e) from e 3472 break 3473 3474 resp = models.GroupRoleGetResponse() 3475 resp.group_role = plumbing.convert_group_role_to_porcelain( 3476 plumbing_response.group_role) 3477 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3478 plumbing_response.meta) 3479 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3480 plumbing_response.rate_limit) 3481 return resp
Get reads one GroupRole by ID.
def
delete(self, id, timeout=None)
3483 def delete(self, id, timeout=None): 3484 ''' 3485 Delete removes a GroupRole by ID. 3486 ''' 3487 deadline = None if timeout is None else time.time() + timeout 3488 req = GroupRoleDeleteRequest() 3489 3490 req.id = (id) 3491 tries = 0 3492 plumbing_response = None 3493 while True: 3494 t = None if deadline is None else deadline - time.time() 3495 try: 3496 plumbing_response = self.stub.Delete( 3497 req, 3498 metadata=self.parent.get_metadata('GroupsRoles.Delete', 3499 req), 3500 timeout=t) 3501 except Exception as e: 3502 if self.parent.shouldRetry(tries, e, deadline): 3503 tries += 1 3504 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3505 continue 3506 raise plumbing.convert_error_to_porcelain(e) from e 3507 break 3508 3509 resp = models.GroupRoleDeleteResponse() 3510 resp.group_role = plumbing.convert_group_role_to_porcelain( 3511 plumbing_response.group_role) 3512 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3513 plumbing_response.meta) 3514 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3515 plumbing_response.rate_limit) 3516 return resp
Delete removes a GroupRole by ID.
def
list(self, filter, *args, timeout=None)
3518 def list(self, filter, *args, timeout=None): 3519 ''' 3520 List gets a list of GroupRoles matching a given set of criteria. 3521 ''' 3522 deadline = None if timeout is None else time.time() + timeout 3523 req = GroupRoleListRequest() 3524 req.meta.CopyFrom(ListRequestMetadata()) 3525 if self.parent.page_limit > 0: 3526 req.meta.limit = self.parent.page_limit 3527 if self.parent.snapshot_datetime is not None: 3528 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3529 3530 req.filter = plumbing.quote_filter_args(filter, *args) 3531 3532 def generator(svc, req): 3533 tries = 0 3534 while True: 3535 t = None if deadline is None else deadline - time.time() 3536 try: 3537 plumbing_response = svc.stub.List( 3538 req, 3539 metadata=svc.parent.get_metadata( 3540 'GroupsRoles.List', req), 3541 timeout=t) 3542 except Exception as e: 3543 if self.parent.shouldRetry(tries, e, deadline): 3544 tries += 1 3545 time.sleep( 3546 self.parent.exponentialBackoff(tries, deadline)) 3547 continue 3548 raise plumbing.convert_error_to_porcelain(e) from e 3549 tries = 0 3550 for plumbing_item in plumbing_response.groups_roles: 3551 yield plumbing.convert_group_role_to_porcelain( 3552 plumbing_item) 3553 if plumbing_response.meta.next_cursor == '': 3554 break 3555 req.meta.cursor = plumbing_response.meta.next_cursor 3556 3557 return generator(self, req)
List gets a list of GroupRoles matching a given set of criteria.
class
SnapshotGroupsRoles:
3560class SnapshotGroupsRoles: 3561 ''' 3562 SnapshotGroupsRoles exposes the read only methods of the GroupsRoles 3563 service for historical queries. 3564 ''' 3565 def __init__(self, groups_roles): 3566 self.groups_roles = groups_roles 3567 3568 def get(self, id, timeout=None): 3569 ''' 3570 Get reads one GroupRole by ID. 3571 ''' 3572 return self.groups_roles.get(id, timeout=timeout) 3573 3574 def list(self, filter, *args, timeout=None): 3575 ''' 3576 List gets a list of GroupRoles matching a given set of criteria. 3577 ''' 3578 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)
3568 def get(self, id, timeout=None): 3569 ''' 3570 Get reads one GroupRole by ID. 3571 ''' 3572 return self.groups_roles.get(id, timeout=timeout)
Get reads one GroupRole by ID.
def
list(self, filter, *args, timeout=None)
3574 def list(self, filter, *args, timeout=None): 3575 ''' 3576 List gets a list of GroupRoles matching a given set of criteria. 3577 ''' 3578 return self.groups_roles.list(filter, *args, timeout=timeout)
List gets a list of GroupRoles matching a given set of criteria.
class
GroupsRolesHistory:
3581class GroupsRolesHistory: 3582 ''' 3583 GroupsRolesHistory records all changes to the state of a GroupRole. 3584 See `strongdm.models.GroupRoleHistory`. 3585 ''' 3586 def __init__(self, channel, client): 3587 self.parent = client 3588 self.stub = GroupsRolesHistoryStub(channel) 3589 3590 def list(self, filter, *args, timeout=None): 3591 ''' 3592 List gets a list of GroupRoleHistory records matching a given set of criteria. 3593 ''' 3594 deadline = None if timeout is None else time.time() + timeout 3595 req = GroupRoleHistoryListRequest() 3596 req.meta.CopyFrom(ListRequestMetadata()) 3597 if self.parent.page_limit > 0: 3598 req.meta.limit = self.parent.page_limit 3599 if self.parent.snapshot_datetime is not None: 3600 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3601 3602 req.filter = plumbing.quote_filter_args(filter, *args) 3603 3604 def generator(svc, req): 3605 tries = 0 3606 while True: 3607 t = None if deadline is None else deadline - time.time() 3608 try: 3609 plumbing_response = svc.stub.List( 3610 req, 3611 metadata=svc.parent.get_metadata( 3612 'GroupsRolesHistory.List', req), 3613 timeout=t) 3614 except Exception as e: 3615 if self.parent.shouldRetry(tries, e, deadline): 3616 tries += 1 3617 time.sleep( 3618 self.parent.exponentialBackoff(tries, deadline)) 3619 continue 3620 raise plumbing.convert_error_to_porcelain(e) from e 3621 tries = 0 3622 for plumbing_item in plumbing_response.history: 3623 yield plumbing.convert_group_role_history_to_porcelain( 3624 plumbing_item) 3625 if plumbing_response.meta.next_cursor == '': 3626 break 3627 req.meta.cursor = plumbing_response.meta.next_cursor 3628 3629 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)
3590 def list(self, filter, *args, timeout=None): 3591 ''' 3592 List gets a list of GroupRoleHistory records matching a given set of criteria. 3593 ''' 3594 deadline = None if timeout is None else time.time() + timeout 3595 req = GroupRoleHistoryListRequest() 3596 req.meta.CopyFrom(ListRequestMetadata()) 3597 if self.parent.page_limit > 0: 3598 req.meta.limit = self.parent.page_limit 3599 if self.parent.snapshot_datetime is not None: 3600 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3601 3602 req.filter = plumbing.quote_filter_args(filter, *args) 3603 3604 def generator(svc, req): 3605 tries = 0 3606 while True: 3607 t = None if deadline is None else deadline - time.time() 3608 try: 3609 plumbing_response = svc.stub.List( 3610 req, 3611 metadata=svc.parent.get_metadata( 3612 'GroupsRolesHistory.List', req), 3613 timeout=t) 3614 except Exception as e: 3615 if self.parent.shouldRetry(tries, e, deadline): 3616 tries += 1 3617 time.sleep( 3618 self.parent.exponentialBackoff(tries, deadline)) 3619 continue 3620 raise plumbing.convert_error_to_porcelain(e) from e 3621 tries = 0 3622 for plumbing_item in plumbing_response.history: 3623 yield plumbing.convert_group_role_history_to_porcelain( 3624 plumbing_item) 3625 if plumbing_response.meta.next_cursor == '': 3626 break 3627 req.meta.cursor = plumbing_response.meta.next_cursor 3628 3629 return generator(self, req)
List gets a list of GroupRoleHistory records matching a given set of criteria.
class
HealthChecks:
3632class HealthChecks: 3633 ''' 3634 HealthChecks lists the last healthcheck between each node and resource. 3635 Note the unconventional capitalization here is to prevent having a collision with GRPC 3636 See `strongdm.models.Healthcheck`. 3637 ''' 3638 def __init__(self, channel, client): 3639 self.parent = client 3640 self.stub = HealthChecksStub(channel) 3641 3642 def list(self, filter, *args, timeout=None): 3643 ''' 3644 List gets a list of Healthchecks matching a given set of criteria. 3645 ''' 3646 deadline = None if timeout is None else time.time() + timeout 3647 req = HealthcheckListRequest() 3648 req.meta.CopyFrom(ListRequestMetadata()) 3649 if self.parent.page_limit > 0: 3650 req.meta.limit = self.parent.page_limit 3651 if self.parent.snapshot_datetime is not None: 3652 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3653 3654 req.filter = plumbing.quote_filter_args(filter, *args) 3655 3656 def generator(svc, req): 3657 tries = 0 3658 while True: 3659 t = None if deadline is None else deadline - time.time() 3660 try: 3661 plumbing_response = svc.stub.List( 3662 req, 3663 metadata=svc.parent.get_metadata( 3664 'HealthChecks.List', req), 3665 timeout=t) 3666 except Exception as e: 3667 if self.parent.shouldRetry(tries, e, deadline): 3668 tries += 1 3669 time.sleep( 3670 self.parent.exponentialBackoff(tries, deadline)) 3671 continue 3672 raise plumbing.convert_error_to_porcelain(e) from e 3673 tries = 0 3674 for plumbing_item in plumbing_response.healthchecks: 3675 yield plumbing.convert_healthcheck_to_porcelain( 3676 plumbing_item) 3677 if plumbing_response.meta.next_cursor == '': 3678 break 3679 req.meta.cursor = plumbing_response.meta.next_cursor 3680 3681 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)
3642 def list(self, filter, *args, timeout=None): 3643 ''' 3644 List gets a list of Healthchecks matching a given set of criteria. 3645 ''' 3646 deadline = None if timeout is None else time.time() + timeout 3647 req = HealthcheckListRequest() 3648 req.meta.CopyFrom(ListRequestMetadata()) 3649 if self.parent.page_limit > 0: 3650 req.meta.limit = self.parent.page_limit 3651 if self.parent.snapshot_datetime is not None: 3652 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3653 3654 req.filter = plumbing.quote_filter_args(filter, *args) 3655 3656 def generator(svc, req): 3657 tries = 0 3658 while True: 3659 t = None if deadline is None else deadline - time.time() 3660 try: 3661 plumbing_response = svc.stub.List( 3662 req, 3663 metadata=svc.parent.get_metadata( 3664 'HealthChecks.List', req), 3665 timeout=t) 3666 except Exception as e: 3667 if self.parent.shouldRetry(tries, e, deadline): 3668 tries += 1 3669 time.sleep( 3670 self.parent.exponentialBackoff(tries, deadline)) 3671 continue 3672 raise plumbing.convert_error_to_porcelain(e) from e 3673 tries = 0 3674 for plumbing_item in plumbing_response.healthchecks: 3675 yield plumbing.convert_healthcheck_to_porcelain( 3676 plumbing_item) 3677 if plumbing_response.meta.next_cursor == '': 3678 break 3679 req.meta.cursor = plumbing_response.meta.next_cursor 3680 3681 return generator(self, req)
List gets a list of Healthchecks matching a given set of criteria.
class
IdentityAliases:
3684class IdentityAliases: 3685 ''' 3686 IdentityAliases assign an alias to an account within an IdentitySet. 3687 The alias is used as the username when connecting to a identity supported resource. 3688 See `strongdm.models.IdentityAlias`. 3689 ''' 3690 def __init__(self, channel, client): 3691 self.parent = client 3692 self.stub = IdentityAliasesStub(channel) 3693 3694 def create(self, identity_alias, timeout=None): 3695 ''' 3696 Create registers a new IdentityAlias. 3697 ''' 3698 deadline = None if timeout is None else time.time() + timeout 3699 req = IdentityAliasCreateRequest() 3700 3701 if identity_alias is not None: 3702 req.identity_alias.CopyFrom( 3703 plumbing.convert_identity_alias_to_plumbing(identity_alias)) 3704 tries = 0 3705 plumbing_response = None 3706 while True: 3707 t = None if deadline is None else deadline - time.time() 3708 try: 3709 plumbing_response = self.stub.Create( 3710 req, 3711 metadata=self.parent.get_metadata('IdentityAliases.Create', 3712 req), 3713 timeout=t) 3714 except Exception as e: 3715 if self.parent.shouldRetry(tries, e, deadline): 3716 tries += 1 3717 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3718 continue 3719 raise plumbing.convert_error_to_porcelain(e) from e 3720 break 3721 3722 resp = models.IdentityAliasCreateResponse() 3723 resp.identity_alias = plumbing.convert_identity_alias_to_porcelain( 3724 plumbing_response.identity_alias) 3725 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 3726 plumbing_response.meta) 3727 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3728 plumbing_response.rate_limit) 3729 return resp 3730 3731 def get(self, id, timeout=None): 3732 ''' 3733 Get reads one IdentityAlias by ID. 3734 ''' 3735 deadline = None if timeout is None else time.time() + timeout 3736 req = IdentityAliasGetRequest() 3737 if self.parent.snapshot_datetime is not None: 3738 req.meta.CopyFrom(GetRequestMetadata()) 3739 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3740 3741 req.id = (id) 3742 tries = 0 3743 plumbing_response = None 3744 while True: 3745 t = None if deadline is None else deadline - time.time() 3746 try: 3747 plumbing_response = self.stub.Get( 3748 req, 3749 metadata=self.parent.get_metadata('IdentityAliases.Get', 3750 req), 3751 timeout=t) 3752 except Exception as e: 3753 if self.parent.shouldRetry(tries, e, deadline): 3754 tries += 1 3755 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3756 continue 3757 raise plumbing.convert_error_to_porcelain(e) from e 3758 break 3759 3760 resp = models.IdentityAliasGetResponse() 3761 resp.identity_alias = plumbing.convert_identity_alias_to_porcelain( 3762 plumbing_response.identity_alias) 3763 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3764 plumbing_response.meta) 3765 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3766 plumbing_response.rate_limit) 3767 return resp 3768 3769 def update(self, identity_alias, timeout=None): 3770 ''' 3771 Update replaces all the fields of a IdentityAlias by ID. 3772 ''' 3773 deadline = None if timeout is None else time.time() + timeout 3774 req = IdentityAliasUpdateRequest() 3775 3776 if identity_alias is not None: 3777 req.identity_alias.CopyFrom( 3778 plumbing.convert_identity_alias_to_plumbing(identity_alias)) 3779 tries = 0 3780 plumbing_response = None 3781 while True: 3782 t = None if deadline is None else deadline - time.time() 3783 try: 3784 plumbing_response = self.stub.Update( 3785 req, 3786 metadata=self.parent.get_metadata('IdentityAliases.Update', 3787 req), 3788 timeout=t) 3789 except Exception as e: 3790 if self.parent.shouldRetry(tries, e, deadline): 3791 tries += 1 3792 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3793 continue 3794 raise plumbing.convert_error_to_porcelain(e) from e 3795 break 3796 3797 resp = models.IdentityAliasUpdateResponse() 3798 resp.identity_alias = plumbing.convert_identity_alias_to_porcelain( 3799 plumbing_response.identity_alias) 3800 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 3801 plumbing_response.meta) 3802 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3803 plumbing_response.rate_limit) 3804 return resp 3805 3806 def delete(self, id, timeout=None): 3807 ''' 3808 Delete removes a IdentityAlias by ID. 3809 ''' 3810 deadline = None if timeout is None else time.time() + timeout 3811 req = IdentityAliasDeleteRequest() 3812 3813 req.id = (id) 3814 tries = 0 3815 plumbing_response = None 3816 while True: 3817 t = None if deadline is None else deadline - time.time() 3818 try: 3819 plumbing_response = self.stub.Delete( 3820 req, 3821 metadata=self.parent.get_metadata('IdentityAliases.Delete', 3822 req), 3823 timeout=t) 3824 except Exception as e: 3825 if self.parent.shouldRetry(tries, e, deadline): 3826 tries += 1 3827 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3828 continue 3829 raise plumbing.convert_error_to_porcelain(e) from e 3830 break 3831 3832 resp = models.IdentityAliasDeleteResponse() 3833 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3834 plumbing_response.meta) 3835 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3836 plumbing_response.rate_limit) 3837 return resp 3838 3839 def list(self, filter, *args, timeout=None): 3840 ''' 3841 List gets a list of IdentityAliases matching a given set of criteria. 3842 ''' 3843 deadline = None if timeout is None else time.time() + timeout 3844 req = IdentityAliasListRequest() 3845 req.meta.CopyFrom(ListRequestMetadata()) 3846 if self.parent.page_limit > 0: 3847 req.meta.limit = self.parent.page_limit 3848 if self.parent.snapshot_datetime is not None: 3849 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3850 3851 req.filter = plumbing.quote_filter_args(filter, *args) 3852 3853 def generator(svc, req): 3854 tries = 0 3855 while True: 3856 t = None if deadline is None else deadline - time.time() 3857 try: 3858 plumbing_response = svc.stub.List( 3859 req, 3860 metadata=svc.parent.get_metadata( 3861 'IdentityAliases.List', req), 3862 timeout=t) 3863 except Exception as e: 3864 if self.parent.shouldRetry(tries, e, deadline): 3865 tries += 1 3866 time.sleep( 3867 self.parent.exponentialBackoff(tries, deadline)) 3868 continue 3869 raise plumbing.convert_error_to_porcelain(e) from e 3870 tries = 0 3871 for plumbing_item in plumbing_response.identity_aliases: 3872 yield plumbing.convert_identity_alias_to_porcelain( 3873 plumbing_item) 3874 if plumbing_response.meta.next_cursor == '': 3875 break 3876 req.meta.cursor = plumbing_response.meta.next_cursor 3877 3878 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)
3694 def create(self, identity_alias, timeout=None): 3695 ''' 3696 Create registers a new IdentityAlias. 3697 ''' 3698 deadline = None if timeout is None else time.time() + timeout 3699 req = IdentityAliasCreateRequest() 3700 3701 if identity_alias is not None: 3702 req.identity_alias.CopyFrom( 3703 plumbing.convert_identity_alias_to_plumbing(identity_alias)) 3704 tries = 0 3705 plumbing_response = None 3706 while True: 3707 t = None if deadline is None else deadline - time.time() 3708 try: 3709 plumbing_response = self.stub.Create( 3710 req, 3711 metadata=self.parent.get_metadata('IdentityAliases.Create', 3712 req), 3713 timeout=t) 3714 except Exception as e: 3715 if self.parent.shouldRetry(tries, e, deadline): 3716 tries += 1 3717 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3718 continue 3719 raise plumbing.convert_error_to_porcelain(e) from e 3720 break 3721 3722 resp = models.IdentityAliasCreateResponse() 3723 resp.identity_alias = plumbing.convert_identity_alias_to_porcelain( 3724 plumbing_response.identity_alias) 3725 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 3726 plumbing_response.meta) 3727 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3728 plumbing_response.rate_limit) 3729 return resp
Create registers a new IdentityAlias.
def
get(self, id, timeout=None)
3731 def get(self, id, timeout=None): 3732 ''' 3733 Get reads one IdentityAlias by ID. 3734 ''' 3735 deadline = None if timeout is None else time.time() + timeout 3736 req = IdentityAliasGetRequest() 3737 if self.parent.snapshot_datetime is not None: 3738 req.meta.CopyFrom(GetRequestMetadata()) 3739 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3740 3741 req.id = (id) 3742 tries = 0 3743 plumbing_response = None 3744 while True: 3745 t = None if deadline is None else deadline - time.time() 3746 try: 3747 plumbing_response = self.stub.Get( 3748 req, 3749 metadata=self.parent.get_metadata('IdentityAliases.Get', 3750 req), 3751 timeout=t) 3752 except Exception as e: 3753 if self.parent.shouldRetry(tries, e, deadline): 3754 tries += 1 3755 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3756 continue 3757 raise plumbing.convert_error_to_porcelain(e) from e 3758 break 3759 3760 resp = models.IdentityAliasGetResponse() 3761 resp.identity_alias = plumbing.convert_identity_alias_to_porcelain( 3762 plumbing_response.identity_alias) 3763 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3764 plumbing_response.meta) 3765 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3766 plumbing_response.rate_limit) 3767 return resp
Get reads one IdentityAlias by ID.
def
update(self, identity_alias, timeout=None)
3769 def update(self, identity_alias, timeout=None): 3770 ''' 3771 Update replaces all the fields of a IdentityAlias by ID. 3772 ''' 3773 deadline = None if timeout is None else time.time() + timeout 3774 req = IdentityAliasUpdateRequest() 3775 3776 if identity_alias is not None: 3777 req.identity_alias.CopyFrom( 3778 plumbing.convert_identity_alias_to_plumbing(identity_alias)) 3779 tries = 0 3780 plumbing_response = None 3781 while True: 3782 t = None if deadline is None else deadline - time.time() 3783 try: 3784 plumbing_response = self.stub.Update( 3785 req, 3786 metadata=self.parent.get_metadata('IdentityAliases.Update', 3787 req), 3788 timeout=t) 3789 except Exception as e: 3790 if self.parent.shouldRetry(tries, e, deadline): 3791 tries += 1 3792 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3793 continue 3794 raise plumbing.convert_error_to_porcelain(e) from e 3795 break 3796 3797 resp = models.IdentityAliasUpdateResponse() 3798 resp.identity_alias = plumbing.convert_identity_alias_to_porcelain( 3799 plumbing_response.identity_alias) 3800 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 3801 plumbing_response.meta) 3802 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3803 plumbing_response.rate_limit) 3804 return resp
Update replaces all the fields of a IdentityAlias by ID.
def
delete(self, id, timeout=None)
3806 def delete(self, id, timeout=None): 3807 ''' 3808 Delete removes a IdentityAlias by ID. 3809 ''' 3810 deadline = None if timeout is None else time.time() + timeout 3811 req = IdentityAliasDeleteRequest() 3812 3813 req.id = (id) 3814 tries = 0 3815 plumbing_response = None 3816 while True: 3817 t = None if deadline is None else deadline - time.time() 3818 try: 3819 plumbing_response = self.stub.Delete( 3820 req, 3821 metadata=self.parent.get_metadata('IdentityAliases.Delete', 3822 req), 3823 timeout=t) 3824 except Exception as e: 3825 if self.parent.shouldRetry(tries, e, deadline): 3826 tries += 1 3827 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3828 continue 3829 raise plumbing.convert_error_to_porcelain(e) from e 3830 break 3831 3832 resp = models.IdentityAliasDeleteResponse() 3833 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3834 plumbing_response.meta) 3835 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3836 plumbing_response.rate_limit) 3837 return resp
Delete removes a IdentityAlias by ID.
def
list(self, filter, *args, timeout=None)
3839 def list(self, filter, *args, timeout=None): 3840 ''' 3841 List gets a list of IdentityAliases matching a given set of criteria. 3842 ''' 3843 deadline = None if timeout is None else time.time() + timeout 3844 req = IdentityAliasListRequest() 3845 req.meta.CopyFrom(ListRequestMetadata()) 3846 if self.parent.page_limit > 0: 3847 req.meta.limit = self.parent.page_limit 3848 if self.parent.snapshot_datetime is not None: 3849 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3850 3851 req.filter = plumbing.quote_filter_args(filter, *args) 3852 3853 def generator(svc, req): 3854 tries = 0 3855 while True: 3856 t = None if deadline is None else deadline - time.time() 3857 try: 3858 plumbing_response = svc.stub.List( 3859 req, 3860 metadata=svc.parent.get_metadata( 3861 'IdentityAliases.List', req), 3862 timeout=t) 3863 except Exception as e: 3864 if self.parent.shouldRetry(tries, e, deadline): 3865 tries += 1 3866 time.sleep( 3867 self.parent.exponentialBackoff(tries, deadline)) 3868 continue 3869 raise plumbing.convert_error_to_porcelain(e) from e 3870 tries = 0 3871 for plumbing_item in plumbing_response.identity_aliases: 3872 yield plumbing.convert_identity_alias_to_porcelain( 3873 plumbing_item) 3874 if plumbing_response.meta.next_cursor == '': 3875 break 3876 req.meta.cursor = plumbing_response.meta.next_cursor 3877 3878 return generator(self, req)
List gets a list of IdentityAliases matching a given set of criteria.
class
SnapshotIdentityAliases:
3881class SnapshotIdentityAliases: 3882 ''' 3883 SnapshotIdentityAliases exposes the read only methods of the IdentityAliases 3884 service for historical queries. 3885 ''' 3886 def __init__(self, identity_aliases): 3887 self.identity_aliases = identity_aliases 3888 3889 def get(self, id, timeout=None): 3890 ''' 3891 Get reads one IdentityAlias by ID. 3892 ''' 3893 return self.identity_aliases.get(id, timeout=timeout) 3894 3895 def list(self, filter, *args, timeout=None): 3896 ''' 3897 List gets a list of IdentityAliases matching a given set of criteria. 3898 ''' 3899 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)
3889 def get(self, id, timeout=None): 3890 ''' 3891 Get reads one IdentityAlias by ID. 3892 ''' 3893 return self.identity_aliases.get(id, timeout=timeout)
Get reads one IdentityAlias by ID.
def
list(self, filter, *args, timeout=None)
3895 def list(self, filter, *args, timeout=None): 3896 ''' 3897 List gets a list of IdentityAliases matching a given set of criteria. 3898 ''' 3899 return self.identity_aliases.list(filter, *args, timeout=timeout)
List gets a list of IdentityAliases matching a given set of criteria.
class
IdentityAliasesHistory:
3902class IdentityAliasesHistory: 3903 ''' 3904 IdentityAliasesHistory records all changes to the state of a IdentityAlias. 3905 See `strongdm.models.IdentityAliasHistory`. 3906 ''' 3907 def __init__(self, channel, client): 3908 self.parent = client 3909 self.stub = IdentityAliasesHistoryStub(channel) 3910 3911 def list(self, filter, *args, timeout=None): 3912 ''' 3913 List gets a list of IdentityAliasHistory records matching a given set of criteria. 3914 ''' 3915 deadline = None if timeout is None else time.time() + timeout 3916 req = IdentityAliasHistoryListRequest() 3917 req.meta.CopyFrom(ListRequestMetadata()) 3918 if self.parent.page_limit > 0: 3919 req.meta.limit = self.parent.page_limit 3920 if self.parent.snapshot_datetime is not None: 3921 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3922 3923 req.filter = plumbing.quote_filter_args(filter, *args) 3924 3925 def generator(svc, req): 3926 tries = 0 3927 while True: 3928 t = None if deadline is None else deadline - time.time() 3929 try: 3930 plumbing_response = svc.stub.List( 3931 req, 3932 metadata=svc.parent.get_metadata( 3933 'IdentityAliasesHistory.List', req), 3934 timeout=t) 3935 except Exception as e: 3936 if self.parent.shouldRetry(tries, e, deadline): 3937 tries += 1 3938 time.sleep( 3939 self.parent.exponentialBackoff(tries, deadline)) 3940 continue 3941 raise plumbing.convert_error_to_porcelain(e) from e 3942 tries = 0 3943 for plumbing_item in plumbing_response.history: 3944 yield plumbing.convert_identity_alias_history_to_porcelain( 3945 plumbing_item) 3946 if plumbing_response.meta.next_cursor == '': 3947 break 3948 req.meta.cursor = plumbing_response.meta.next_cursor 3949 3950 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)
3911 def list(self, filter, *args, timeout=None): 3912 ''' 3913 List gets a list of IdentityAliasHistory records matching a given set of criteria. 3914 ''' 3915 deadline = None if timeout is None else time.time() + timeout 3916 req = IdentityAliasHistoryListRequest() 3917 req.meta.CopyFrom(ListRequestMetadata()) 3918 if self.parent.page_limit > 0: 3919 req.meta.limit = self.parent.page_limit 3920 if self.parent.snapshot_datetime is not None: 3921 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3922 3923 req.filter = plumbing.quote_filter_args(filter, *args) 3924 3925 def generator(svc, req): 3926 tries = 0 3927 while True: 3928 t = None if deadline is None else deadline - time.time() 3929 try: 3930 plumbing_response = svc.stub.List( 3931 req, 3932 metadata=svc.parent.get_metadata( 3933 'IdentityAliasesHistory.List', req), 3934 timeout=t) 3935 except Exception as e: 3936 if self.parent.shouldRetry(tries, e, deadline): 3937 tries += 1 3938 time.sleep( 3939 self.parent.exponentialBackoff(tries, deadline)) 3940 continue 3941 raise plumbing.convert_error_to_porcelain(e) from e 3942 tries = 0 3943 for plumbing_item in plumbing_response.history: 3944 yield plumbing.convert_identity_alias_history_to_porcelain( 3945 plumbing_item) 3946 if plumbing_response.meta.next_cursor == '': 3947 break 3948 req.meta.cursor = plumbing_response.meta.next_cursor 3949 3950 return generator(self, req)
List gets a list of IdentityAliasHistory records matching a given set of criteria.
class
IdentitySets:
3953class IdentitySets: 3954 ''' 3955 A IdentitySet is a named grouping of Identity Aliases for Accounts. 3956 An Account's relationship to a IdentitySet is defined via IdentityAlias objects. 3957 See `strongdm.models.IdentitySet`. 3958 ''' 3959 def __init__(self, channel, client): 3960 self.parent = client 3961 self.stub = IdentitySetsStub(channel) 3962 3963 def create(self, identity_set, timeout=None): 3964 ''' 3965 Create registers a new IdentitySet. 3966 ''' 3967 deadline = None if timeout is None else time.time() + timeout 3968 req = IdentitySetCreateRequest() 3969 3970 if identity_set is not None: 3971 req.identity_set.CopyFrom( 3972 plumbing.convert_identity_set_to_plumbing(identity_set)) 3973 tries = 0 3974 plumbing_response = None 3975 while True: 3976 t = None if deadline is None else deadline - time.time() 3977 try: 3978 plumbing_response = self.stub.Create( 3979 req, 3980 metadata=self.parent.get_metadata('IdentitySets.Create', 3981 req), 3982 timeout=t) 3983 except Exception as e: 3984 if self.parent.shouldRetry(tries, e, deadline): 3985 tries += 1 3986 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3987 continue 3988 raise plumbing.convert_error_to_porcelain(e) from e 3989 break 3990 3991 resp = models.IdentitySetCreateResponse() 3992 resp.identity_set = plumbing.convert_identity_set_to_porcelain( 3993 plumbing_response.identity_set) 3994 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 3995 plumbing_response.meta) 3996 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3997 plumbing_response.rate_limit) 3998 return resp 3999 4000 def get(self, id, timeout=None): 4001 ''' 4002 Get reads one IdentitySet by ID. 4003 ''' 4004 deadline = None if timeout is None else time.time() + timeout 4005 req = IdentitySetGetRequest() 4006 if self.parent.snapshot_datetime is not None: 4007 req.meta.CopyFrom(GetRequestMetadata()) 4008 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4009 4010 req.id = (id) 4011 tries = 0 4012 plumbing_response = None 4013 while True: 4014 t = None if deadline is None else deadline - time.time() 4015 try: 4016 plumbing_response = self.stub.Get( 4017 req, 4018 metadata=self.parent.get_metadata('IdentitySets.Get', req), 4019 timeout=t) 4020 except Exception as e: 4021 if self.parent.shouldRetry(tries, e, deadline): 4022 tries += 1 4023 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4024 continue 4025 raise plumbing.convert_error_to_porcelain(e) from e 4026 break 4027 4028 resp = models.IdentitySetGetResponse() 4029 resp.identity_set = plumbing.convert_identity_set_to_porcelain( 4030 plumbing_response.identity_set) 4031 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4032 plumbing_response.meta) 4033 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4034 plumbing_response.rate_limit) 4035 return resp 4036 4037 def update(self, identity_set, timeout=None): 4038 ''' 4039 Update replaces all the fields of a IdentitySet by ID. 4040 ''' 4041 deadline = None if timeout is None else time.time() + timeout 4042 req = IdentitySetUpdateRequest() 4043 4044 if identity_set is not None: 4045 req.identity_set.CopyFrom( 4046 plumbing.convert_identity_set_to_plumbing(identity_set)) 4047 tries = 0 4048 plumbing_response = None 4049 while True: 4050 t = None if deadline is None else deadline - time.time() 4051 try: 4052 plumbing_response = self.stub.Update( 4053 req, 4054 metadata=self.parent.get_metadata('IdentitySets.Update', 4055 req), 4056 timeout=t) 4057 except Exception as e: 4058 if self.parent.shouldRetry(tries, e, deadline): 4059 tries += 1 4060 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4061 continue 4062 raise plumbing.convert_error_to_porcelain(e) from e 4063 break 4064 4065 resp = models.IdentitySetUpdateResponse() 4066 resp.identity_set = plumbing.convert_identity_set_to_porcelain( 4067 plumbing_response.identity_set) 4068 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 4069 plumbing_response.meta) 4070 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4071 plumbing_response.rate_limit) 4072 return resp 4073 4074 def delete(self, id, timeout=None): 4075 ''' 4076 Delete removes a IdentitySet by ID. 4077 ''' 4078 deadline = None if timeout is None else time.time() + timeout 4079 req = IdentitySetDeleteRequest() 4080 4081 req.id = (id) 4082 tries = 0 4083 plumbing_response = None 4084 while True: 4085 t = None if deadline is None else deadline - time.time() 4086 try: 4087 plumbing_response = self.stub.Delete( 4088 req, 4089 metadata=self.parent.get_metadata('IdentitySets.Delete', 4090 req), 4091 timeout=t) 4092 except Exception as e: 4093 if self.parent.shouldRetry(tries, e, deadline): 4094 tries += 1 4095 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4096 continue 4097 raise plumbing.convert_error_to_porcelain(e) from e 4098 break 4099 4100 resp = models.IdentitySetDeleteResponse() 4101 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 4102 plumbing_response.meta) 4103 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4104 plumbing_response.rate_limit) 4105 return resp 4106 4107 def list(self, filter, *args, timeout=None): 4108 ''' 4109 List gets a list of IdentitySets matching a given set of criteria. 4110 ''' 4111 deadline = None if timeout is None else time.time() + timeout 4112 req = IdentitySetListRequest() 4113 req.meta.CopyFrom(ListRequestMetadata()) 4114 if self.parent.page_limit > 0: 4115 req.meta.limit = self.parent.page_limit 4116 if self.parent.snapshot_datetime is not None: 4117 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4118 4119 req.filter = plumbing.quote_filter_args(filter, *args) 4120 4121 def generator(svc, req): 4122 tries = 0 4123 while True: 4124 t = None if deadline is None else deadline - time.time() 4125 try: 4126 plumbing_response = svc.stub.List( 4127 req, 4128 metadata=svc.parent.get_metadata( 4129 'IdentitySets.List', req), 4130 timeout=t) 4131 except Exception as e: 4132 if self.parent.shouldRetry(tries, e, deadline): 4133 tries += 1 4134 time.sleep( 4135 self.parent.exponentialBackoff(tries, deadline)) 4136 continue 4137 raise plumbing.convert_error_to_porcelain(e) from e 4138 tries = 0 4139 for plumbing_item in plumbing_response.identity_sets: 4140 yield plumbing.convert_identity_set_to_porcelain( 4141 plumbing_item) 4142 if plumbing_response.meta.next_cursor == '': 4143 break 4144 req.meta.cursor = plumbing_response.meta.next_cursor 4145 4146 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)
3963 def create(self, identity_set, timeout=None): 3964 ''' 3965 Create registers a new IdentitySet. 3966 ''' 3967 deadline = None if timeout is None else time.time() + timeout 3968 req = IdentitySetCreateRequest() 3969 3970 if identity_set is not None: 3971 req.identity_set.CopyFrom( 3972 plumbing.convert_identity_set_to_plumbing(identity_set)) 3973 tries = 0 3974 plumbing_response = None 3975 while True: 3976 t = None if deadline is None else deadline - time.time() 3977 try: 3978 plumbing_response = self.stub.Create( 3979 req, 3980 metadata=self.parent.get_metadata('IdentitySets.Create', 3981 req), 3982 timeout=t) 3983 except Exception as e: 3984 if self.parent.shouldRetry(tries, e, deadline): 3985 tries += 1 3986 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3987 continue 3988 raise plumbing.convert_error_to_porcelain(e) from e 3989 break 3990 3991 resp = models.IdentitySetCreateResponse() 3992 resp.identity_set = plumbing.convert_identity_set_to_porcelain( 3993 plumbing_response.identity_set) 3994 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 3995 plumbing_response.meta) 3996 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3997 plumbing_response.rate_limit) 3998 return resp
Create registers a new IdentitySet.
def
get(self, id, timeout=None)
4000 def get(self, id, timeout=None): 4001 ''' 4002 Get reads one IdentitySet by ID. 4003 ''' 4004 deadline = None if timeout is None else time.time() + timeout 4005 req = IdentitySetGetRequest() 4006 if self.parent.snapshot_datetime is not None: 4007 req.meta.CopyFrom(GetRequestMetadata()) 4008 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4009 4010 req.id = (id) 4011 tries = 0 4012 plumbing_response = None 4013 while True: 4014 t = None if deadline is None else deadline - time.time() 4015 try: 4016 plumbing_response = self.stub.Get( 4017 req, 4018 metadata=self.parent.get_metadata('IdentitySets.Get', req), 4019 timeout=t) 4020 except Exception as e: 4021 if self.parent.shouldRetry(tries, e, deadline): 4022 tries += 1 4023 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4024 continue 4025 raise plumbing.convert_error_to_porcelain(e) from e 4026 break 4027 4028 resp = models.IdentitySetGetResponse() 4029 resp.identity_set = plumbing.convert_identity_set_to_porcelain( 4030 plumbing_response.identity_set) 4031 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4032 plumbing_response.meta) 4033 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4034 plumbing_response.rate_limit) 4035 return resp
Get reads one IdentitySet by ID.
def
update(self, identity_set, timeout=None)
4037 def update(self, identity_set, timeout=None): 4038 ''' 4039 Update replaces all the fields of a IdentitySet by ID. 4040 ''' 4041 deadline = None if timeout is None else time.time() + timeout 4042 req = IdentitySetUpdateRequest() 4043 4044 if identity_set is not None: 4045 req.identity_set.CopyFrom( 4046 plumbing.convert_identity_set_to_plumbing(identity_set)) 4047 tries = 0 4048 plumbing_response = None 4049 while True: 4050 t = None if deadline is None else deadline - time.time() 4051 try: 4052 plumbing_response = self.stub.Update( 4053 req, 4054 metadata=self.parent.get_metadata('IdentitySets.Update', 4055 req), 4056 timeout=t) 4057 except Exception as e: 4058 if self.parent.shouldRetry(tries, e, deadline): 4059 tries += 1 4060 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4061 continue 4062 raise plumbing.convert_error_to_porcelain(e) from e 4063 break 4064 4065 resp = models.IdentitySetUpdateResponse() 4066 resp.identity_set = plumbing.convert_identity_set_to_porcelain( 4067 plumbing_response.identity_set) 4068 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 4069 plumbing_response.meta) 4070 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4071 plumbing_response.rate_limit) 4072 return resp
Update replaces all the fields of a IdentitySet by ID.
def
delete(self, id, timeout=None)
4074 def delete(self, id, timeout=None): 4075 ''' 4076 Delete removes a IdentitySet by ID. 4077 ''' 4078 deadline = None if timeout is None else time.time() + timeout 4079 req = IdentitySetDeleteRequest() 4080 4081 req.id = (id) 4082 tries = 0 4083 plumbing_response = None 4084 while True: 4085 t = None if deadline is None else deadline - time.time() 4086 try: 4087 plumbing_response = self.stub.Delete( 4088 req, 4089 metadata=self.parent.get_metadata('IdentitySets.Delete', 4090 req), 4091 timeout=t) 4092 except Exception as e: 4093 if self.parent.shouldRetry(tries, e, deadline): 4094 tries += 1 4095 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4096 continue 4097 raise plumbing.convert_error_to_porcelain(e) from e 4098 break 4099 4100 resp = models.IdentitySetDeleteResponse() 4101 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 4102 plumbing_response.meta) 4103 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4104 plumbing_response.rate_limit) 4105 return resp
Delete removes a IdentitySet by ID.
def
list(self, filter, *args, timeout=None)
4107 def list(self, filter, *args, timeout=None): 4108 ''' 4109 List gets a list of IdentitySets matching a given set of criteria. 4110 ''' 4111 deadline = None if timeout is None else time.time() + timeout 4112 req = IdentitySetListRequest() 4113 req.meta.CopyFrom(ListRequestMetadata()) 4114 if self.parent.page_limit > 0: 4115 req.meta.limit = self.parent.page_limit 4116 if self.parent.snapshot_datetime is not None: 4117 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4118 4119 req.filter = plumbing.quote_filter_args(filter, *args) 4120 4121 def generator(svc, req): 4122 tries = 0 4123 while True: 4124 t = None if deadline is None else deadline - time.time() 4125 try: 4126 plumbing_response = svc.stub.List( 4127 req, 4128 metadata=svc.parent.get_metadata( 4129 'IdentitySets.List', req), 4130 timeout=t) 4131 except Exception as e: 4132 if self.parent.shouldRetry(tries, e, deadline): 4133 tries += 1 4134 time.sleep( 4135 self.parent.exponentialBackoff(tries, deadline)) 4136 continue 4137 raise plumbing.convert_error_to_porcelain(e) from e 4138 tries = 0 4139 for plumbing_item in plumbing_response.identity_sets: 4140 yield plumbing.convert_identity_set_to_porcelain( 4141 plumbing_item) 4142 if plumbing_response.meta.next_cursor == '': 4143 break 4144 req.meta.cursor = plumbing_response.meta.next_cursor 4145 4146 return generator(self, req)
List gets a list of IdentitySets matching a given set of criteria.
class
SnapshotIdentitySets:
4149class SnapshotIdentitySets: 4150 ''' 4151 SnapshotIdentitySets exposes the read only methods of the IdentitySets 4152 service for historical queries. 4153 ''' 4154 def __init__(self, identity_sets): 4155 self.identity_sets = identity_sets 4156 4157 def get(self, id, timeout=None): 4158 ''' 4159 Get reads one IdentitySet by ID. 4160 ''' 4161 return self.identity_sets.get(id, timeout=timeout) 4162 4163 def list(self, filter, *args, timeout=None): 4164 ''' 4165 List gets a list of IdentitySets matching a given set of criteria. 4166 ''' 4167 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)
4157 def get(self, id, timeout=None): 4158 ''' 4159 Get reads one IdentitySet by ID. 4160 ''' 4161 return self.identity_sets.get(id, timeout=timeout)
Get reads one IdentitySet by ID.
def
list(self, filter, *args, timeout=None)
4163 def list(self, filter, *args, timeout=None): 4164 ''' 4165 List gets a list of IdentitySets matching a given set of criteria. 4166 ''' 4167 return self.identity_sets.list(filter, *args, timeout=timeout)
List gets a list of IdentitySets matching a given set of criteria.
class
IdentitySetsHistory:
4170class IdentitySetsHistory: 4171 ''' 4172 IdentitySetsHistory records all changes to the state of a IdentitySet. 4173 See `strongdm.models.IdentitySetHistory`. 4174 ''' 4175 def __init__(self, channel, client): 4176 self.parent = client 4177 self.stub = IdentitySetsHistoryStub(channel) 4178 4179 def list(self, filter, *args, timeout=None): 4180 ''' 4181 List gets a list of IdentitySetHistory records matching a given set of criteria. 4182 ''' 4183 deadline = None if timeout is None else time.time() + timeout 4184 req = IdentitySetHistoryListRequest() 4185 req.meta.CopyFrom(ListRequestMetadata()) 4186 if self.parent.page_limit > 0: 4187 req.meta.limit = self.parent.page_limit 4188 if self.parent.snapshot_datetime is not None: 4189 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4190 4191 req.filter = plumbing.quote_filter_args(filter, *args) 4192 4193 def generator(svc, req): 4194 tries = 0 4195 while True: 4196 t = None if deadline is None else deadline - time.time() 4197 try: 4198 plumbing_response = svc.stub.List( 4199 req, 4200 metadata=svc.parent.get_metadata( 4201 'IdentitySetsHistory.List', req), 4202 timeout=t) 4203 except Exception as e: 4204 if self.parent.shouldRetry(tries, e, deadline): 4205 tries += 1 4206 time.sleep( 4207 self.parent.exponentialBackoff(tries, deadline)) 4208 continue 4209 raise plumbing.convert_error_to_porcelain(e) from e 4210 tries = 0 4211 for plumbing_item in plumbing_response.history: 4212 yield plumbing.convert_identity_set_history_to_porcelain( 4213 plumbing_item) 4214 if plumbing_response.meta.next_cursor == '': 4215 break 4216 req.meta.cursor = plumbing_response.meta.next_cursor 4217 4218 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)
4179 def list(self, filter, *args, timeout=None): 4180 ''' 4181 List gets a list of IdentitySetHistory records matching a given set of criteria. 4182 ''' 4183 deadline = None if timeout is None else time.time() + timeout 4184 req = IdentitySetHistoryListRequest() 4185 req.meta.CopyFrom(ListRequestMetadata()) 4186 if self.parent.page_limit > 0: 4187 req.meta.limit = self.parent.page_limit 4188 if self.parent.snapshot_datetime is not None: 4189 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4190 4191 req.filter = plumbing.quote_filter_args(filter, *args) 4192 4193 def generator(svc, req): 4194 tries = 0 4195 while True: 4196 t = None if deadline is None else deadline - time.time() 4197 try: 4198 plumbing_response = svc.stub.List( 4199 req, 4200 metadata=svc.parent.get_metadata( 4201 'IdentitySetsHistory.List', req), 4202 timeout=t) 4203 except Exception as e: 4204 if self.parent.shouldRetry(tries, e, deadline): 4205 tries += 1 4206 time.sleep( 4207 self.parent.exponentialBackoff(tries, deadline)) 4208 continue 4209 raise plumbing.convert_error_to_porcelain(e) from e 4210 tries = 0 4211 for plumbing_item in plumbing_response.history: 4212 yield plumbing.convert_identity_set_history_to_porcelain( 4213 plumbing_item) 4214 if plumbing_response.meta.next_cursor == '': 4215 break 4216 req.meta.cursor = plumbing_response.meta.next_cursor 4217 4218 return generator(self, req)
List gets a list of IdentitySetHistory records matching a given set of criteria.
class
ManagedSecrets:
4221class ManagedSecrets: 4222 ''' 4223 ManagedSecret is a private vertical for creating, reading, updating, 4224 deleting, listing and rotating the managed secrets in the secrets engines as 4225 an authenticated user. 4226 See `strongdm.models.ManagedSecret`. 4227 ''' 4228 def __init__(self, channel, client): 4229 self.parent = client 4230 self.stub = ManagedSecretsStub(channel) 4231 4232 def list(self, filter, *args, timeout=None): 4233 ''' 4234 List returns Managed Secrets from a Secret Engine. 4235 ''' 4236 deadline = None if timeout is None else time.time() + timeout 4237 req = ManagedSecretListRequest() 4238 req.meta.CopyFrom(ListRequestMetadata()) 4239 if self.parent.page_limit > 0: 4240 req.meta.limit = self.parent.page_limit 4241 if self.parent.snapshot_datetime is not None: 4242 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4243 4244 req.filter = plumbing.quote_filter_args(filter, *args) 4245 4246 def generator(svc, req): 4247 tries = 0 4248 while True: 4249 t = None if deadline is None else deadline - time.time() 4250 try: 4251 plumbing_response = svc.stub.List( 4252 req, 4253 metadata=svc.parent.get_metadata( 4254 'ManagedSecrets.List', req), 4255 timeout=t) 4256 except Exception as e: 4257 if self.parent.shouldRetry(tries, e, deadline): 4258 tries += 1 4259 time.sleep( 4260 self.parent.exponentialBackoff(tries, deadline)) 4261 continue 4262 raise plumbing.convert_error_to_porcelain(e) from e 4263 tries = 0 4264 for plumbing_item in plumbing_response.managed_secrets: 4265 yield plumbing.convert_managed_secret_to_porcelain( 4266 plumbing_item) 4267 if plumbing_response.meta.next_cursor == '': 4268 break 4269 req.meta.cursor = plumbing_response.meta.next_cursor 4270 4271 return generator(self, req) 4272 4273 def list_by_actor(self, filter, *args, timeout=None): 4274 ''' 4275 List returns Managed Secrets for an Actor from a Secret Engine. 4276 ''' 4277 deadline = None if timeout is None else time.time() + timeout 4278 req = ManagedSecretListRequest() 4279 req.meta.CopyFrom(ListRequestMetadata()) 4280 if self.parent.page_limit > 0: 4281 req.meta.limit = self.parent.page_limit 4282 if self.parent.snapshot_datetime is not None: 4283 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4284 4285 req.filter = plumbing.quote_filter_args(filter, *args) 4286 4287 def generator(svc, req): 4288 tries = 0 4289 while True: 4290 t = None if deadline is None else deadline - time.time() 4291 try: 4292 plumbing_response = svc.stub.ListByActor( 4293 req, 4294 metadata=svc.parent.get_metadata( 4295 'ManagedSecrets.ListByActor', req), 4296 timeout=t) 4297 except Exception as e: 4298 if self.parent.shouldRetry(tries, e, deadline): 4299 tries += 1 4300 time.sleep( 4301 self.parent.exponentialBackoff(tries, deadline)) 4302 continue 4303 raise plumbing.convert_error_to_porcelain(e) from e 4304 tries = 0 4305 for plumbing_item in plumbing_response.managed_secrets: 4306 yield plumbing.convert_managed_secret_to_porcelain( 4307 plumbing_item) 4308 if plumbing_response.meta.next_cursor == '': 4309 break 4310 req.meta.cursor = plumbing_response.meta.next_cursor 4311 4312 return generator(self, req) 4313 4314 def create(self, managed_secret, timeout=None): 4315 ''' 4316 Create creates a Managed Secret 4317 ''' 4318 deadline = None if timeout is None else time.time() + timeout 4319 req = ManagedSecretCreateRequest() 4320 4321 if managed_secret is not None: 4322 req.managed_secret.CopyFrom( 4323 plumbing.convert_managed_secret_to_plumbing(managed_secret)) 4324 tries = 0 4325 plumbing_response = None 4326 while True: 4327 t = None if deadline is None else deadline - time.time() 4328 try: 4329 plumbing_response = self.stub.Create( 4330 req, 4331 metadata=self.parent.get_metadata('ManagedSecrets.Create', 4332 req), 4333 timeout=t) 4334 except Exception as e: 4335 if self.parent.shouldRetry(tries, e, deadline): 4336 tries += 1 4337 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4338 continue 4339 raise plumbing.convert_error_to_porcelain(e) from e 4340 break 4341 4342 resp = models.ManagedSecretCreateResponse() 4343 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 4344 plumbing_response.managed_secret) 4345 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4346 plumbing_response.meta) 4347 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4348 plumbing_response.rate_limit) 4349 return resp 4350 4351 def update(self, managed_secret, timeout=None): 4352 ''' 4353 Update updates a Managed Secret 4354 ''' 4355 deadline = None if timeout is None else time.time() + timeout 4356 req = ManagedSecretUpdateRequest() 4357 4358 if managed_secret is not None: 4359 req.managed_secret.CopyFrom( 4360 plumbing.convert_managed_secret_to_plumbing(managed_secret)) 4361 tries = 0 4362 plumbing_response = None 4363 while True: 4364 t = None if deadline is None else deadline - time.time() 4365 try: 4366 plumbing_response = self.stub.Update( 4367 req, 4368 metadata=self.parent.get_metadata('ManagedSecrets.Update', 4369 req), 4370 timeout=t) 4371 except Exception as e: 4372 if self.parent.shouldRetry(tries, e, deadline): 4373 tries += 1 4374 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4375 continue 4376 raise plumbing.convert_error_to_porcelain(e) from e 4377 break 4378 4379 resp = models.ManagedSecretUpdateResponse() 4380 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 4381 plumbing_response.managed_secret) 4382 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 4383 plumbing_response.meta) 4384 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4385 plumbing_response.rate_limit) 4386 return resp 4387 4388 def rotate(self, id, timeout=None): 4389 ''' 4390 Rotate forces rotation of Managed Secret 4391 ''' 4392 deadline = None if timeout is None else time.time() + timeout 4393 req = ManagedSecretRotateRequest() 4394 4395 req.id = (id) 4396 tries = 0 4397 plumbing_response = None 4398 while True: 4399 t = None if deadline is None else deadline - time.time() 4400 try: 4401 plumbing_response = self.stub.Rotate( 4402 req, 4403 metadata=self.parent.get_metadata('ManagedSecrets.Rotate', 4404 req), 4405 timeout=t) 4406 except Exception as e: 4407 if self.parent.shouldRetry(tries, e, deadline): 4408 tries += 1 4409 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4410 continue 4411 raise plumbing.convert_error_to_porcelain(e) from e 4412 break 4413 4414 resp = models.ManagedSecretRotateResponse() 4415 resp.meta = plumbing.convert_generic_response_metadata_to_porcelain( 4416 plumbing_response.meta) 4417 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4418 plumbing_response.rate_limit) 4419 return resp 4420 4421 def delete(self, id, timeout=None): 4422 ''' 4423 Delete deletes a Managed Secret 4424 ''' 4425 deadline = None if timeout is None else time.time() + timeout 4426 req = ManagedSecretDeleteRequest() 4427 4428 req.id = (id) 4429 tries = 0 4430 plumbing_response = None 4431 while True: 4432 t = None if deadline is None else deadline - time.time() 4433 try: 4434 plumbing_response = self.stub.Delete( 4435 req, 4436 metadata=self.parent.get_metadata('ManagedSecrets.Delete', 4437 req), 4438 timeout=t) 4439 except Exception as e: 4440 if self.parent.shouldRetry(tries, e, deadline): 4441 tries += 1 4442 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4443 continue 4444 raise plumbing.convert_error_to_porcelain(e) from e 4445 break 4446 4447 resp = models.ManagedSecretDeleteResponse() 4448 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4449 plumbing_response.rate_limit) 4450 return resp 4451 4452 def force_delete(self, id, timeout=None): 4453 ''' 4454 ForceDelete deletes a Managed Secret regardless of errors on external system 4455 ''' 4456 deadline = None if timeout is None else time.time() + timeout 4457 req = ManagedSecretDeleteRequest() 4458 4459 req.id = (id) 4460 tries = 0 4461 plumbing_response = None 4462 while True: 4463 t = None if deadline is None else deadline - time.time() 4464 try: 4465 plumbing_response = self.stub.ForceDelete( 4466 req, 4467 metadata=self.parent.get_metadata( 4468 'ManagedSecrets.ForceDelete', req), 4469 timeout=t) 4470 except Exception as e: 4471 if self.parent.shouldRetry(tries, e, deadline): 4472 tries += 1 4473 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4474 continue 4475 raise plumbing.convert_error_to_porcelain(e) from e 4476 break 4477 4478 resp = models.ManagedSecretDeleteResponse() 4479 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4480 plumbing_response.rate_limit) 4481 return resp 4482 4483 def get(self, id, timeout=None): 4484 ''' 4485 Get gets details of a Managed Secret without sensitive data 4486 ''' 4487 deadline = None if timeout is None else time.time() + timeout 4488 req = ManagedSecretGetRequest() 4489 if self.parent.snapshot_datetime is not None: 4490 req.meta.CopyFrom(GetRequestMetadata()) 4491 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4492 4493 req.id = (id) 4494 tries = 0 4495 plumbing_response = None 4496 while True: 4497 t = None if deadline is None else deadline - time.time() 4498 try: 4499 plumbing_response = self.stub.Get( 4500 req, 4501 metadata=self.parent.get_metadata('ManagedSecrets.Get', 4502 req), 4503 timeout=t) 4504 except Exception as e: 4505 if self.parent.shouldRetry(tries, e, deadline): 4506 tries += 1 4507 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4508 continue 4509 raise plumbing.convert_error_to_porcelain(e) from e 4510 break 4511 4512 resp = models.ManagedSecretGetResponse() 4513 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 4514 plumbing_response.managed_secret) 4515 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4516 plumbing_response.meta) 4517 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4518 plumbing_response.rate_limit) 4519 return resp 4520 4521 def retrieve(self, id, timeout=None): 4522 ''' 4523 Retrieve returns Managed Secret with sensitive data 4524 ''' 4525 deadline = None if timeout is None else time.time() + timeout 4526 req = ManagedSecretRetrieveRequest() 4527 4528 req.id = (id) 4529 tries = 0 4530 plumbing_response = None 4531 while True: 4532 t = None if deadline is None else deadline - time.time() 4533 try: 4534 plumbing_response = self.stub.Retrieve( 4535 req, 4536 metadata=self.parent.get_metadata( 4537 'ManagedSecrets.Retrieve', req), 4538 timeout=t) 4539 except Exception as e: 4540 if self.parent.shouldRetry(tries, e, deadline): 4541 tries += 1 4542 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4543 continue 4544 raise plumbing.convert_error_to_porcelain(e) from e 4545 break 4546 4547 resp = models.ManagedSecretRetrieveResponse() 4548 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 4549 plumbing_response.managed_secret) 4550 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4551 plumbing_response.meta) 4552 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4553 plumbing_response.rate_limit) 4554 return resp 4555 4556 def validate(self, id, timeout=None): 4557 ''' 4558 Validate returns the result of testing the stored credential against the 4559 secret engine. 4560 ''' 4561 deadline = None if timeout is None else time.time() + timeout 4562 req = ManagedSecretValidateRequest() 4563 4564 req.id = (id) 4565 tries = 0 4566 plumbing_response = None 4567 while True: 4568 t = None if deadline is None else deadline - time.time() 4569 try: 4570 plumbing_response = self.stub.Validate( 4571 req, 4572 metadata=self.parent.get_metadata( 4573 'ManagedSecrets.Validate', req), 4574 timeout=t) 4575 except Exception as e: 4576 if self.parent.shouldRetry(tries, e, deadline): 4577 tries += 1 4578 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4579 continue 4580 raise plumbing.convert_error_to_porcelain(e) from e 4581 break 4582 4583 resp = models.ManagedSecretValidateResponse() 4584 resp.invalid_info = (plumbing_response.invalid_info) 4585 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4586 plumbing_response.meta) 4587 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4588 plumbing_response.rate_limit) 4589 resp.valid = (plumbing_response.valid) 4590 return resp 4591 4592 def logs(self, filter, *args, timeout=None): 4593 ''' 4594 Logs returns the audit records for the managed secret. This may be replaced 4595 in the future. 4596 ''' 4597 deadline = None if timeout is None else time.time() + timeout 4598 req = ManagedSecretLogsRequest() 4599 req.meta.CopyFrom(ListRequestMetadata()) 4600 if self.parent.page_limit > 0: 4601 req.meta.limit = self.parent.page_limit 4602 if self.parent.snapshot_datetime is not None: 4603 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4604 4605 req.filter = plumbing.quote_filter_args(filter, *args) 4606 4607 def generator(svc, req): 4608 tries = 0 4609 while True: 4610 t = None if deadline is None else deadline - time.time() 4611 try: 4612 plumbing_response = svc.stub.Logs( 4613 req, 4614 metadata=svc.parent.get_metadata( 4615 'ManagedSecrets.Logs', req), 4616 timeout=t) 4617 except Exception as e: 4618 if self.parent.shouldRetry(tries, e, deadline): 4619 tries += 1 4620 time.sleep( 4621 self.parent.exponentialBackoff(tries, deadline)) 4622 continue 4623 raise plumbing.convert_error_to_porcelain(e) from e 4624 tries = 0 4625 for plumbing_item in plumbing_response.managed_secret_logs: 4626 yield plumbing.convert_managed_secret_log_to_porcelain( 4627 plumbing_item) 4628 if plumbing_response.meta.next_cursor == '': 4629 break 4630 req.meta.cursor = plumbing_response.meta.next_cursor 4631 4632 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)
4232 def list(self, filter, *args, timeout=None): 4233 ''' 4234 List returns Managed Secrets from a Secret Engine. 4235 ''' 4236 deadline = None if timeout is None else time.time() + timeout 4237 req = ManagedSecretListRequest() 4238 req.meta.CopyFrom(ListRequestMetadata()) 4239 if self.parent.page_limit > 0: 4240 req.meta.limit = self.parent.page_limit 4241 if self.parent.snapshot_datetime is not None: 4242 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4243 4244 req.filter = plumbing.quote_filter_args(filter, *args) 4245 4246 def generator(svc, req): 4247 tries = 0 4248 while True: 4249 t = None if deadline is None else deadline - time.time() 4250 try: 4251 plumbing_response = svc.stub.List( 4252 req, 4253 metadata=svc.parent.get_metadata( 4254 'ManagedSecrets.List', req), 4255 timeout=t) 4256 except Exception as e: 4257 if self.parent.shouldRetry(tries, e, deadline): 4258 tries += 1 4259 time.sleep( 4260 self.parent.exponentialBackoff(tries, deadline)) 4261 continue 4262 raise plumbing.convert_error_to_porcelain(e) from e 4263 tries = 0 4264 for plumbing_item in plumbing_response.managed_secrets: 4265 yield plumbing.convert_managed_secret_to_porcelain( 4266 plumbing_item) 4267 if plumbing_response.meta.next_cursor == '': 4268 break 4269 req.meta.cursor = plumbing_response.meta.next_cursor 4270 4271 return generator(self, req)
List returns Managed Secrets from a Secret Engine.
def
list_by_actor(self, filter, *args, timeout=None)
4273 def list_by_actor(self, filter, *args, timeout=None): 4274 ''' 4275 List returns Managed Secrets for an Actor from a Secret Engine. 4276 ''' 4277 deadline = None if timeout is None else time.time() + timeout 4278 req = ManagedSecretListRequest() 4279 req.meta.CopyFrom(ListRequestMetadata()) 4280 if self.parent.page_limit > 0: 4281 req.meta.limit = self.parent.page_limit 4282 if self.parent.snapshot_datetime is not None: 4283 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4284 4285 req.filter = plumbing.quote_filter_args(filter, *args) 4286 4287 def generator(svc, req): 4288 tries = 0 4289 while True: 4290 t = None if deadline is None else deadline - time.time() 4291 try: 4292 plumbing_response = svc.stub.ListByActor( 4293 req, 4294 metadata=svc.parent.get_metadata( 4295 'ManagedSecrets.ListByActor', req), 4296 timeout=t) 4297 except Exception as e: 4298 if self.parent.shouldRetry(tries, e, deadline): 4299 tries += 1 4300 time.sleep( 4301 self.parent.exponentialBackoff(tries, deadline)) 4302 continue 4303 raise plumbing.convert_error_to_porcelain(e) from e 4304 tries = 0 4305 for plumbing_item in plumbing_response.managed_secrets: 4306 yield plumbing.convert_managed_secret_to_porcelain( 4307 plumbing_item) 4308 if plumbing_response.meta.next_cursor == '': 4309 break 4310 req.meta.cursor = plumbing_response.meta.next_cursor 4311 4312 return generator(self, req)
List returns Managed Secrets for an Actor from a Secret Engine.
def
create(self, managed_secret, timeout=None)
4314 def create(self, managed_secret, timeout=None): 4315 ''' 4316 Create creates a Managed Secret 4317 ''' 4318 deadline = None if timeout is None else time.time() + timeout 4319 req = ManagedSecretCreateRequest() 4320 4321 if managed_secret is not None: 4322 req.managed_secret.CopyFrom( 4323 plumbing.convert_managed_secret_to_plumbing(managed_secret)) 4324 tries = 0 4325 plumbing_response = None 4326 while True: 4327 t = None if deadline is None else deadline - time.time() 4328 try: 4329 plumbing_response = self.stub.Create( 4330 req, 4331 metadata=self.parent.get_metadata('ManagedSecrets.Create', 4332 req), 4333 timeout=t) 4334 except Exception as e: 4335 if self.parent.shouldRetry(tries, e, deadline): 4336 tries += 1 4337 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4338 continue 4339 raise plumbing.convert_error_to_porcelain(e) from e 4340 break 4341 4342 resp = models.ManagedSecretCreateResponse() 4343 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 4344 plumbing_response.managed_secret) 4345 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4346 plumbing_response.meta) 4347 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4348 plumbing_response.rate_limit) 4349 return resp
Create creates a Managed Secret
def
update(self, managed_secret, timeout=None)
4351 def update(self, managed_secret, timeout=None): 4352 ''' 4353 Update updates a Managed Secret 4354 ''' 4355 deadline = None if timeout is None else time.time() + timeout 4356 req = ManagedSecretUpdateRequest() 4357 4358 if managed_secret is not None: 4359 req.managed_secret.CopyFrom( 4360 plumbing.convert_managed_secret_to_plumbing(managed_secret)) 4361 tries = 0 4362 plumbing_response = None 4363 while True: 4364 t = None if deadline is None else deadline - time.time() 4365 try: 4366 plumbing_response = self.stub.Update( 4367 req, 4368 metadata=self.parent.get_metadata('ManagedSecrets.Update', 4369 req), 4370 timeout=t) 4371 except Exception as e: 4372 if self.parent.shouldRetry(tries, e, deadline): 4373 tries += 1 4374 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4375 continue 4376 raise plumbing.convert_error_to_porcelain(e) from e 4377 break 4378 4379 resp = models.ManagedSecretUpdateResponse() 4380 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 4381 plumbing_response.managed_secret) 4382 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 4383 plumbing_response.meta) 4384 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4385 plumbing_response.rate_limit) 4386 return resp
Update updates a Managed Secret
def
rotate(self, id, timeout=None)
4388 def rotate(self, id, timeout=None): 4389 ''' 4390 Rotate forces rotation of Managed Secret 4391 ''' 4392 deadline = None if timeout is None else time.time() + timeout 4393 req = ManagedSecretRotateRequest() 4394 4395 req.id = (id) 4396 tries = 0 4397 plumbing_response = None 4398 while True: 4399 t = None if deadline is None else deadline - time.time() 4400 try: 4401 plumbing_response = self.stub.Rotate( 4402 req, 4403 metadata=self.parent.get_metadata('ManagedSecrets.Rotate', 4404 req), 4405 timeout=t) 4406 except Exception as e: 4407 if self.parent.shouldRetry(tries, e, deadline): 4408 tries += 1 4409 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4410 continue 4411 raise plumbing.convert_error_to_porcelain(e) from e 4412 break 4413 4414 resp = models.ManagedSecretRotateResponse() 4415 resp.meta = plumbing.convert_generic_response_metadata_to_porcelain( 4416 plumbing_response.meta) 4417 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4418 plumbing_response.rate_limit) 4419 return resp
Rotate forces rotation of Managed Secret
def
delete(self, id, timeout=None)
4421 def delete(self, id, timeout=None): 4422 ''' 4423 Delete deletes a Managed Secret 4424 ''' 4425 deadline = None if timeout is None else time.time() + timeout 4426 req = ManagedSecretDeleteRequest() 4427 4428 req.id = (id) 4429 tries = 0 4430 plumbing_response = None 4431 while True: 4432 t = None if deadline is None else deadline - time.time() 4433 try: 4434 plumbing_response = self.stub.Delete( 4435 req, 4436 metadata=self.parent.get_metadata('ManagedSecrets.Delete', 4437 req), 4438 timeout=t) 4439 except Exception as e: 4440 if self.parent.shouldRetry(tries, e, deadline): 4441 tries += 1 4442 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4443 continue 4444 raise plumbing.convert_error_to_porcelain(e) from e 4445 break 4446 4447 resp = models.ManagedSecretDeleteResponse() 4448 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4449 plumbing_response.rate_limit) 4450 return resp
Delete deletes a Managed Secret
def
force_delete(self, id, timeout=None)
4452 def force_delete(self, id, timeout=None): 4453 ''' 4454 ForceDelete deletes a Managed Secret regardless of errors on external system 4455 ''' 4456 deadline = None if timeout is None else time.time() + timeout 4457 req = ManagedSecretDeleteRequest() 4458 4459 req.id = (id) 4460 tries = 0 4461 plumbing_response = None 4462 while True: 4463 t = None if deadline is None else deadline - time.time() 4464 try: 4465 plumbing_response = self.stub.ForceDelete( 4466 req, 4467 metadata=self.parent.get_metadata( 4468 'ManagedSecrets.ForceDelete', req), 4469 timeout=t) 4470 except Exception as e: 4471 if self.parent.shouldRetry(tries, e, deadline): 4472 tries += 1 4473 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4474 continue 4475 raise plumbing.convert_error_to_porcelain(e) from e 4476 break 4477 4478 resp = models.ManagedSecretDeleteResponse() 4479 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4480 plumbing_response.rate_limit) 4481 return resp
ForceDelete deletes a Managed Secret regardless of errors on external system
def
get(self, id, timeout=None)
4483 def get(self, id, timeout=None): 4484 ''' 4485 Get gets details of a Managed Secret without sensitive data 4486 ''' 4487 deadline = None if timeout is None else time.time() + timeout 4488 req = ManagedSecretGetRequest() 4489 if self.parent.snapshot_datetime is not None: 4490 req.meta.CopyFrom(GetRequestMetadata()) 4491 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4492 4493 req.id = (id) 4494 tries = 0 4495 plumbing_response = None 4496 while True: 4497 t = None if deadline is None else deadline - time.time() 4498 try: 4499 plumbing_response = self.stub.Get( 4500 req, 4501 metadata=self.parent.get_metadata('ManagedSecrets.Get', 4502 req), 4503 timeout=t) 4504 except Exception as e: 4505 if self.parent.shouldRetry(tries, e, deadline): 4506 tries += 1 4507 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4508 continue 4509 raise plumbing.convert_error_to_porcelain(e) from e 4510 break 4511 4512 resp = models.ManagedSecretGetResponse() 4513 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 4514 plumbing_response.managed_secret) 4515 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4516 plumbing_response.meta) 4517 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4518 plumbing_response.rate_limit) 4519 return resp
Get gets details of a Managed Secret without sensitive data
def
retrieve(self, id, timeout=None)
4521 def retrieve(self, id, timeout=None): 4522 ''' 4523 Retrieve returns Managed Secret with sensitive data 4524 ''' 4525 deadline = None if timeout is None else time.time() + timeout 4526 req = ManagedSecretRetrieveRequest() 4527 4528 req.id = (id) 4529 tries = 0 4530 plumbing_response = None 4531 while True: 4532 t = None if deadline is None else deadline - time.time() 4533 try: 4534 plumbing_response = self.stub.Retrieve( 4535 req, 4536 metadata=self.parent.get_metadata( 4537 'ManagedSecrets.Retrieve', req), 4538 timeout=t) 4539 except Exception as e: 4540 if self.parent.shouldRetry(tries, e, deadline): 4541 tries += 1 4542 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4543 continue 4544 raise plumbing.convert_error_to_porcelain(e) from e 4545 break 4546 4547 resp = models.ManagedSecretRetrieveResponse() 4548 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 4549 plumbing_response.managed_secret) 4550 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4551 plumbing_response.meta) 4552 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4553 plumbing_response.rate_limit) 4554 return resp
Retrieve returns Managed Secret with sensitive data
def
validate(self, id, timeout=None)
4556 def validate(self, id, timeout=None): 4557 ''' 4558 Validate returns the result of testing the stored credential against the 4559 secret engine. 4560 ''' 4561 deadline = None if timeout is None else time.time() + timeout 4562 req = ManagedSecretValidateRequest() 4563 4564 req.id = (id) 4565 tries = 0 4566 plumbing_response = None 4567 while True: 4568 t = None if deadline is None else deadline - time.time() 4569 try: 4570 plumbing_response = self.stub.Validate( 4571 req, 4572 metadata=self.parent.get_metadata( 4573 'ManagedSecrets.Validate', req), 4574 timeout=t) 4575 except Exception as e: 4576 if self.parent.shouldRetry(tries, e, deadline): 4577 tries += 1 4578 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4579 continue 4580 raise plumbing.convert_error_to_porcelain(e) from e 4581 break 4582 4583 resp = models.ManagedSecretValidateResponse() 4584 resp.invalid_info = (plumbing_response.invalid_info) 4585 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4586 plumbing_response.meta) 4587 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4588 plumbing_response.rate_limit) 4589 resp.valid = (plumbing_response.valid) 4590 return resp
Validate returns the result of testing the stored credential against the secret engine.
def
logs(self, filter, *args, timeout=None)
4592 def logs(self, filter, *args, timeout=None): 4593 ''' 4594 Logs returns the audit records for the managed secret. This may be replaced 4595 in the future. 4596 ''' 4597 deadline = None if timeout is None else time.time() + timeout 4598 req = ManagedSecretLogsRequest() 4599 req.meta.CopyFrom(ListRequestMetadata()) 4600 if self.parent.page_limit > 0: 4601 req.meta.limit = self.parent.page_limit 4602 if self.parent.snapshot_datetime is not None: 4603 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4604 4605 req.filter = plumbing.quote_filter_args(filter, *args) 4606 4607 def generator(svc, req): 4608 tries = 0 4609 while True: 4610 t = None if deadline is None else deadline - time.time() 4611 try: 4612 plumbing_response = svc.stub.Logs( 4613 req, 4614 metadata=svc.parent.get_metadata( 4615 'ManagedSecrets.Logs', req), 4616 timeout=t) 4617 except Exception as e: 4618 if self.parent.shouldRetry(tries, e, deadline): 4619 tries += 1 4620 time.sleep( 4621 self.parent.exponentialBackoff(tries, deadline)) 4622 continue 4623 raise plumbing.convert_error_to_porcelain(e) from e 4624 tries = 0 4625 for plumbing_item in plumbing_response.managed_secret_logs: 4626 yield plumbing.convert_managed_secret_log_to_porcelain( 4627 plumbing_item) 4628 if plumbing_response.meta.next_cursor == '': 4629 break 4630 req.meta.cursor = plumbing_response.meta.next_cursor 4631 4632 return generator(self, req)
Logs returns the audit records for the managed secret. This may be replaced in the future.
class
Nodes:
4635class Nodes: 4636 ''' 4637 Nodes make up the StrongDM network, and allow your users to connect securely to your resources. 4638 There are three types of nodes: 4639 1. **Relay:** creates connectivity to your datasources, while maintaining the egress-only nature of your firewall 4640 2. **Gateway:** a relay that also listens for connections from StrongDM clients 4641 3. **Proxy Cluster:** a cluster of workers that together mediate access from clients to resources 4642 See: 4643 `strongdm.models.Gateway` 4644 `strongdm.models.ProxyCluster` 4645 `strongdm.models.Relay` 4646 ''' 4647 def __init__(self, channel, client): 4648 self.parent = client 4649 self.stub = NodesStub(channel) 4650 4651 def create(self, node, timeout=None): 4652 ''' 4653 Create registers a new Node. 4654 ''' 4655 deadline = None if timeout is None else time.time() + timeout 4656 req = NodeCreateRequest() 4657 4658 if node is not None: 4659 req.node.CopyFrom(plumbing.convert_node_to_plumbing(node)) 4660 tries = 0 4661 plumbing_response = None 4662 while True: 4663 t = None if deadline is None else deadline - time.time() 4664 try: 4665 plumbing_response = self.stub.Create( 4666 req, 4667 metadata=self.parent.get_metadata('Nodes.Create', req), 4668 timeout=t) 4669 except Exception as e: 4670 if self.parent.shouldRetry(tries, e, deadline): 4671 tries += 1 4672 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4673 continue 4674 raise plumbing.convert_error_to_porcelain(e) from e 4675 break 4676 4677 resp = models.NodeCreateResponse() 4678 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4679 plumbing_response.meta) 4680 resp.node = plumbing.convert_node_to_porcelain(plumbing_response.node) 4681 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4682 plumbing_response.rate_limit) 4683 resp.token = (plumbing_response.token) 4684 return resp 4685 4686 def get(self, id, timeout=None): 4687 ''' 4688 Get reads one Node by ID. 4689 ''' 4690 deadline = None if timeout is None else time.time() + timeout 4691 req = NodeGetRequest() 4692 if self.parent.snapshot_datetime is not None: 4693 req.meta.CopyFrom(GetRequestMetadata()) 4694 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4695 4696 req.id = (id) 4697 tries = 0 4698 plumbing_response = None 4699 while True: 4700 t = None if deadline is None else deadline - time.time() 4701 try: 4702 plumbing_response = self.stub.Get( 4703 req, 4704 metadata=self.parent.get_metadata('Nodes.Get', req), 4705 timeout=t) 4706 except Exception as e: 4707 if self.parent.shouldRetry(tries, e, deadline): 4708 tries += 1 4709 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4710 continue 4711 raise plumbing.convert_error_to_porcelain(e) from e 4712 break 4713 4714 resp = models.NodeGetResponse() 4715 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4716 plumbing_response.meta) 4717 resp.node = plumbing.convert_node_to_porcelain(plumbing_response.node) 4718 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4719 plumbing_response.rate_limit) 4720 return resp 4721 4722 def update(self, node, timeout=None): 4723 ''' 4724 Update replaces all the fields of a Node by ID. 4725 ''' 4726 deadline = None if timeout is None else time.time() + timeout 4727 req = NodeUpdateRequest() 4728 4729 if node is not None: 4730 req.node.CopyFrom(plumbing.convert_node_to_plumbing(node)) 4731 tries = 0 4732 plumbing_response = None 4733 while True: 4734 t = None if deadline is None else deadline - time.time() 4735 try: 4736 plumbing_response = self.stub.Update( 4737 req, 4738 metadata=self.parent.get_metadata('Nodes.Update', req), 4739 timeout=t) 4740 except Exception as e: 4741 if self.parent.shouldRetry(tries, e, deadline): 4742 tries += 1 4743 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4744 continue 4745 raise plumbing.convert_error_to_porcelain(e) from e 4746 break 4747 4748 resp = models.NodeUpdateResponse() 4749 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 4750 plumbing_response.meta) 4751 resp.node = plumbing.convert_node_to_porcelain(plumbing_response.node) 4752 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4753 plumbing_response.rate_limit) 4754 return resp 4755 4756 def delete(self, id, timeout=None): 4757 ''' 4758 Delete removes a Node by ID. 4759 ''' 4760 deadline = None if timeout is None else time.time() + timeout 4761 req = NodeDeleteRequest() 4762 4763 req.id = (id) 4764 tries = 0 4765 plumbing_response = None 4766 while True: 4767 t = None if deadline is None else deadline - time.time() 4768 try: 4769 plumbing_response = self.stub.Delete( 4770 req, 4771 metadata=self.parent.get_metadata('Nodes.Delete', req), 4772 timeout=t) 4773 except Exception as e: 4774 if self.parent.shouldRetry(tries, e, deadline): 4775 tries += 1 4776 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4777 continue 4778 raise plumbing.convert_error_to_porcelain(e) from e 4779 break 4780 4781 resp = models.NodeDeleteResponse() 4782 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 4783 plumbing_response.meta) 4784 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4785 plumbing_response.rate_limit) 4786 return resp 4787 4788 def list(self, filter, *args, timeout=None): 4789 ''' 4790 List gets a list of Nodes matching a given set of criteria. 4791 ''' 4792 deadline = None if timeout is None else time.time() + timeout 4793 req = NodeListRequest() 4794 req.meta.CopyFrom(ListRequestMetadata()) 4795 if self.parent.page_limit > 0: 4796 req.meta.limit = self.parent.page_limit 4797 if self.parent.snapshot_datetime is not None: 4798 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4799 4800 req.filter = plumbing.quote_filter_args(filter, *args) 4801 4802 def generator(svc, req): 4803 tries = 0 4804 while True: 4805 t = None if deadline is None else deadline - time.time() 4806 try: 4807 plumbing_response = svc.stub.List( 4808 req, 4809 metadata=svc.parent.get_metadata('Nodes.List', req), 4810 timeout=t) 4811 except Exception as e: 4812 if self.parent.shouldRetry(tries, e, deadline): 4813 tries += 1 4814 time.sleep( 4815 self.parent.exponentialBackoff(tries, deadline)) 4816 continue 4817 raise plumbing.convert_error_to_porcelain(e) from e 4818 tries = 0 4819 for plumbing_item in plumbing_response.nodes: 4820 yield plumbing.convert_node_to_porcelain(plumbing_item) 4821 if plumbing_response.meta.next_cursor == '': 4822 break 4823 req.meta.cursor = plumbing_response.meta.next_cursor 4824 4825 return generator(self, req) 4826 4827 def tcp_probe(self, node_id, host, port, timeout=None): 4828 ''' 4829 TCPProbe instructs a Node to connect to an address via TCP and report the 4830 result. 4831 ''' 4832 deadline = None if timeout is None else time.time() + timeout 4833 req = NodeTCPProbeRequest() 4834 4835 req.node_id = (node_id) 4836 req.host = (host) 4837 req.port = (port) 4838 tries = 0 4839 plumbing_response = None 4840 while True: 4841 t = None if deadline is None else deadline - time.time() 4842 try: 4843 plumbing_response = self.stub.TCPProbe( 4844 req, 4845 metadata=self.parent.get_metadata('Nodes.TCPProbe', req), 4846 timeout=t) 4847 except Exception as e: 4848 if self.parent.shouldRetry(tries, e, deadline): 4849 tries += 1 4850 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4851 continue 4852 raise plumbing.convert_error_to_porcelain(e) from e 4853 break 4854 4855 resp = models.NodeTCPProbeResponse() 4856 resp.error = (plumbing_response.error) 4857 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4858 plumbing_response.meta) 4859 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4860 plumbing_response.rate_limit) 4861 resp.succeeded = (plumbing_response.succeeded) 4862 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)
4651 def create(self, node, timeout=None): 4652 ''' 4653 Create registers a new Node. 4654 ''' 4655 deadline = None if timeout is None else time.time() + timeout 4656 req = NodeCreateRequest() 4657 4658 if node is not None: 4659 req.node.CopyFrom(plumbing.convert_node_to_plumbing(node)) 4660 tries = 0 4661 plumbing_response = None 4662 while True: 4663 t = None if deadline is None else deadline - time.time() 4664 try: 4665 plumbing_response = self.stub.Create( 4666 req, 4667 metadata=self.parent.get_metadata('Nodes.Create', req), 4668 timeout=t) 4669 except Exception as e: 4670 if self.parent.shouldRetry(tries, e, deadline): 4671 tries += 1 4672 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4673 continue 4674 raise plumbing.convert_error_to_porcelain(e) from e 4675 break 4676 4677 resp = models.NodeCreateResponse() 4678 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4679 plumbing_response.meta) 4680 resp.node = plumbing.convert_node_to_porcelain(plumbing_response.node) 4681 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4682 plumbing_response.rate_limit) 4683 resp.token = (plumbing_response.token) 4684 return resp
Create registers a new Node.
def
get(self, id, timeout=None)
4686 def get(self, id, timeout=None): 4687 ''' 4688 Get reads one Node by ID. 4689 ''' 4690 deadline = None if timeout is None else time.time() + timeout 4691 req = NodeGetRequest() 4692 if self.parent.snapshot_datetime is not None: 4693 req.meta.CopyFrom(GetRequestMetadata()) 4694 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4695 4696 req.id = (id) 4697 tries = 0 4698 plumbing_response = None 4699 while True: 4700 t = None if deadline is None else deadline - time.time() 4701 try: 4702 plumbing_response = self.stub.Get( 4703 req, 4704 metadata=self.parent.get_metadata('Nodes.Get', req), 4705 timeout=t) 4706 except Exception as e: 4707 if self.parent.shouldRetry(tries, e, deadline): 4708 tries += 1 4709 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4710 continue 4711 raise plumbing.convert_error_to_porcelain(e) from e 4712 break 4713 4714 resp = models.NodeGetResponse() 4715 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4716 plumbing_response.meta) 4717 resp.node = plumbing.convert_node_to_porcelain(plumbing_response.node) 4718 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4719 plumbing_response.rate_limit) 4720 return resp
Get reads one Node by ID.
def
update(self, node, timeout=None)
4722 def update(self, node, timeout=None): 4723 ''' 4724 Update replaces all the fields of a Node by ID. 4725 ''' 4726 deadline = None if timeout is None else time.time() + timeout 4727 req = NodeUpdateRequest() 4728 4729 if node is not None: 4730 req.node.CopyFrom(plumbing.convert_node_to_plumbing(node)) 4731 tries = 0 4732 plumbing_response = None 4733 while True: 4734 t = None if deadline is None else deadline - time.time() 4735 try: 4736 plumbing_response = self.stub.Update( 4737 req, 4738 metadata=self.parent.get_metadata('Nodes.Update', req), 4739 timeout=t) 4740 except Exception as e: 4741 if self.parent.shouldRetry(tries, e, deadline): 4742 tries += 1 4743 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4744 continue 4745 raise plumbing.convert_error_to_porcelain(e) from e 4746 break 4747 4748 resp = models.NodeUpdateResponse() 4749 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 4750 plumbing_response.meta) 4751 resp.node = plumbing.convert_node_to_porcelain(plumbing_response.node) 4752 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4753 plumbing_response.rate_limit) 4754 return resp
Update replaces all the fields of a Node by ID.
def
delete(self, id, timeout=None)
4756 def delete(self, id, timeout=None): 4757 ''' 4758 Delete removes a Node by ID. 4759 ''' 4760 deadline = None if timeout is None else time.time() + timeout 4761 req = NodeDeleteRequest() 4762 4763 req.id = (id) 4764 tries = 0 4765 plumbing_response = None 4766 while True: 4767 t = None if deadline is None else deadline - time.time() 4768 try: 4769 plumbing_response = self.stub.Delete( 4770 req, 4771 metadata=self.parent.get_metadata('Nodes.Delete', req), 4772 timeout=t) 4773 except Exception as e: 4774 if self.parent.shouldRetry(tries, e, deadline): 4775 tries += 1 4776 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4777 continue 4778 raise plumbing.convert_error_to_porcelain(e) from e 4779 break 4780 4781 resp = models.NodeDeleteResponse() 4782 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 4783 plumbing_response.meta) 4784 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4785 plumbing_response.rate_limit) 4786 return resp
Delete removes a Node by ID.
def
list(self, filter, *args, timeout=None)
4788 def list(self, filter, *args, timeout=None): 4789 ''' 4790 List gets a list of Nodes matching a given set of criteria. 4791 ''' 4792 deadline = None if timeout is None else time.time() + timeout 4793 req = NodeListRequest() 4794 req.meta.CopyFrom(ListRequestMetadata()) 4795 if self.parent.page_limit > 0: 4796 req.meta.limit = self.parent.page_limit 4797 if self.parent.snapshot_datetime is not None: 4798 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4799 4800 req.filter = plumbing.quote_filter_args(filter, *args) 4801 4802 def generator(svc, req): 4803 tries = 0 4804 while True: 4805 t = None if deadline is None else deadline - time.time() 4806 try: 4807 plumbing_response = svc.stub.List( 4808 req, 4809 metadata=svc.parent.get_metadata('Nodes.List', req), 4810 timeout=t) 4811 except Exception as e: 4812 if self.parent.shouldRetry(tries, e, deadline): 4813 tries += 1 4814 time.sleep( 4815 self.parent.exponentialBackoff(tries, deadline)) 4816 continue 4817 raise plumbing.convert_error_to_porcelain(e) from e 4818 tries = 0 4819 for plumbing_item in plumbing_response.nodes: 4820 yield plumbing.convert_node_to_porcelain(plumbing_item) 4821 if plumbing_response.meta.next_cursor == '': 4822 break 4823 req.meta.cursor = plumbing_response.meta.next_cursor 4824 4825 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)
4827 def tcp_probe(self, node_id, host, port, timeout=None): 4828 ''' 4829 TCPProbe instructs a Node to connect to an address via TCP and report the 4830 result. 4831 ''' 4832 deadline = None if timeout is None else time.time() + timeout 4833 req = NodeTCPProbeRequest() 4834 4835 req.node_id = (node_id) 4836 req.host = (host) 4837 req.port = (port) 4838 tries = 0 4839 plumbing_response = None 4840 while True: 4841 t = None if deadline is None else deadline - time.time() 4842 try: 4843 plumbing_response = self.stub.TCPProbe( 4844 req, 4845 metadata=self.parent.get_metadata('Nodes.TCPProbe', req), 4846 timeout=t) 4847 except Exception as e: 4848 if self.parent.shouldRetry(tries, e, deadline): 4849 tries += 1 4850 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4851 continue 4852 raise plumbing.convert_error_to_porcelain(e) from e 4853 break 4854 4855 resp = models.NodeTCPProbeResponse() 4856 resp.error = (plumbing_response.error) 4857 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4858 plumbing_response.meta) 4859 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4860 plumbing_response.rate_limit) 4861 resp.succeeded = (plumbing_response.succeeded) 4862 return resp
TCPProbe instructs a Node to connect to an address via TCP and report the result.
class
SnapshotNodes:
4865class SnapshotNodes: 4866 ''' 4867 SnapshotNodes exposes the read only methods of the Nodes 4868 service for historical queries. 4869 ''' 4870 def __init__(self, nodes): 4871 self.nodes = nodes 4872 4873 def get(self, id, timeout=None): 4874 ''' 4875 Get reads one Node by ID. 4876 ''' 4877 return self.nodes.get(id, timeout=timeout) 4878 4879 def list(self, filter, *args, timeout=None): 4880 ''' 4881 List gets a list of Nodes matching a given set of criteria. 4882 ''' 4883 return self.nodes.list(filter, *args, timeout=timeout)
SnapshotNodes exposes the read only methods of the Nodes service for historical queries.
class
NodesHistory:
4886class NodesHistory: 4887 ''' 4888 NodesHistory records all changes to the state of a Node. 4889 See `strongdm.models.NodeHistory`. 4890 ''' 4891 def __init__(self, channel, client): 4892 self.parent = client 4893 self.stub = NodesHistoryStub(channel) 4894 4895 def list(self, filter, *args, timeout=None): 4896 ''' 4897 List gets a list of NodeHistory records matching a given set of criteria. 4898 ''' 4899 deadline = None if timeout is None else time.time() + timeout 4900 req = NodeHistoryListRequest() 4901 req.meta.CopyFrom(ListRequestMetadata()) 4902 if self.parent.page_limit > 0: 4903 req.meta.limit = self.parent.page_limit 4904 if self.parent.snapshot_datetime is not None: 4905 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4906 4907 req.filter = plumbing.quote_filter_args(filter, *args) 4908 4909 def generator(svc, req): 4910 tries = 0 4911 while True: 4912 t = None if deadline is None else deadline - time.time() 4913 try: 4914 plumbing_response = svc.stub.List( 4915 req, 4916 metadata=svc.parent.get_metadata( 4917 'NodesHistory.List', req), 4918 timeout=t) 4919 except Exception as e: 4920 if self.parent.shouldRetry(tries, e, deadline): 4921 tries += 1 4922 time.sleep( 4923 self.parent.exponentialBackoff(tries, deadline)) 4924 continue 4925 raise plumbing.convert_error_to_porcelain(e) from e 4926 tries = 0 4927 for plumbing_item in plumbing_response.history: 4928 yield plumbing.convert_node_history_to_porcelain( 4929 plumbing_item) 4930 if plumbing_response.meta.next_cursor == '': 4931 break 4932 req.meta.cursor = plumbing_response.meta.next_cursor 4933 4934 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)
4895 def list(self, filter, *args, timeout=None): 4896 ''' 4897 List gets a list of NodeHistory records matching a given set of criteria. 4898 ''' 4899 deadline = None if timeout is None else time.time() + timeout 4900 req = NodeHistoryListRequest() 4901 req.meta.CopyFrom(ListRequestMetadata()) 4902 if self.parent.page_limit > 0: 4903 req.meta.limit = self.parent.page_limit 4904 if self.parent.snapshot_datetime is not None: 4905 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4906 4907 req.filter = plumbing.quote_filter_args(filter, *args) 4908 4909 def generator(svc, req): 4910 tries = 0 4911 while True: 4912 t = None if deadline is None else deadline - time.time() 4913 try: 4914 plumbing_response = svc.stub.List( 4915 req, 4916 metadata=svc.parent.get_metadata( 4917 'NodesHistory.List', req), 4918 timeout=t) 4919 except Exception as e: 4920 if self.parent.shouldRetry(tries, e, deadline): 4921 tries += 1 4922 time.sleep( 4923 self.parent.exponentialBackoff(tries, deadline)) 4924 continue 4925 raise plumbing.convert_error_to_porcelain(e) from e 4926 tries = 0 4927 for plumbing_item in plumbing_response.history: 4928 yield plumbing.convert_node_history_to_porcelain( 4929 plumbing_item) 4930 if plumbing_response.meta.next_cursor == '': 4931 break 4932 req.meta.cursor = plumbing_response.meta.next_cursor 4933 4934 return generator(self, req)
List gets a list of NodeHistory records matching a given set of criteria.
class
OrganizationHistory:
4937class OrganizationHistory: 4938 ''' 4939 OrganizationHistory records all changes to the state of an Organization. 4940 See `strongdm.models.OrganizationHistoryRecord`. 4941 ''' 4942 def __init__(self, channel, client): 4943 self.parent = client 4944 self.stub = OrganizationHistoryStub(channel) 4945 4946 def list(self, filter, *args, timeout=None): 4947 ''' 4948 List gets a list of OrganizationHistory records matching a given set of criteria. 4949 ''' 4950 deadline = None if timeout is None else time.time() + timeout 4951 req = OrganizationHistoryListRequest() 4952 req.meta.CopyFrom(ListRequestMetadata()) 4953 if self.parent.page_limit > 0: 4954 req.meta.limit = self.parent.page_limit 4955 if self.parent.snapshot_datetime is not None: 4956 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4957 4958 req.filter = plumbing.quote_filter_args(filter, *args) 4959 4960 def generator(svc, req): 4961 tries = 0 4962 while True: 4963 t = None if deadline is None else deadline - time.time() 4964 try: 4965 plumbing_response = svc.stub.List( 4966 req, 4967 metadata=svc.parent.get_metadata( 4968 'OrganizationHistory.List', req), 4969 timeout=t) 4970 except Exception as e: 4971 if self.parent.shouldRetry(tries, e, deadline): 4972 tries += 1 4973 time.sleep( 4974 self.parent.exponentialBackoff(tries, deadline)) 4975 continue 4976 raise plumbing.convert_error_to_porcelain(e) from e 4977 tries = 0 4978 for plumbing_item in plumbing_response.history: 4979 yield plumbing.convert_organization_history_record_to_porcelain( 4980 plumbing_item) 4981 if plumbing_response.meta.next_cursor == '': 4982 break 4983 req.meta.cursor = plumbing_response.meta.next_cursor 4984 4985 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)
4946 def list(self, filter, *args, timeout=None): 4947 ''' 4948 List gets a list of OrganizationHistory records matching a given set of criteria. 4949 ''' 4950 deadline = None if timeout is None else time.time() + timeout 4951 req = OrganizationHistoryListRequest() 4952 req.meta.CopyFrom(ListRequestMetadata()) 4953 if self.parent.page_limit > 0: 4954 req.meta.limit = self.parent.page_limit 4955 if self.parent.snapshot_datetime is not None: 4956 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4957 4958 req.filter = plumbing.quote_filter_args(filter, *args) 4959 4960 def generator(svc, req): 4961 tries = 0 4962 while True: 4963 t = None if deadline is None else deadline - time.time() 4964 try: 4965 plumbing_response = svc.stub.List( 4966 req, 4967 metadata=svc.parent.get_metadata( 4968 'OrganizationHistory.List', req), 4969 timeout=t) 4970 except Exception as e: 4971 if self.parent.shouldRetry(tries, e, deadline): 4972 tries += 1 4973 time.sleep( 4974 self.parent.exponentialBackoff(tries, deadline)) 4975 continue 4976 raise plumbing.convert_error_to_porcelain(e) from e 4977 tries = 0 4978 for plumbing_item in plumbing_response.history: 4979 yield plumbing.convert_organization_history_record_to_porcelain( 4980 plumbing_item) 4981 if plumbing_response.meta.next_cursor == '': 4982 break 4983 req.meta.cursor = plumbing_response.meta.next_cursor 4984 4985 return generator(self, req)
List gets a list of OrganizationHistory records matching a given set of criteria.
class
PeeringGroupNodes:
4988class PeeringGroupNodes: 4989 ''' 4990 PeeringGroupNodes provides the building blocks necessary to obtain attach a node to a peering group. 4991 See `strongdm.models.PeeringGroupNode`. 4992 ''' 4993 def __init__(self, channel, client): 4994 self.parent = client 4995 self.stub = PeeringGroupNodesStub(channel) 4996 4997 def create(self, peering_group_node, timeout=None): 4998 ''' 4999 Create attaches a Node to a PeeringGroup 5000 ''' 5001 deadline = None if timeout is None else time.time() + timeout 5002 req = PeeringGroupNodeCreateRequest() 5003 5004 if peering_group_node is not None: 5005 req.peering_group_node.CopyFrom( 5006 plumbing.convert_peering_group_node_to_plumbing( 5007 peering_group_node)) 5008 tries = 0 5009 plumbing_response = None 5010 while True: 5011 t = None if deadline is None else deadline - time.time() 5012 try: 5013 plumbing_response = self.stub.Create( 5014 req, 5015 metadata=self.parent.get_metadata( 5016 'PeeringGroupNodes.Create', req), 5017 timeout=t) 5018 except Exception as e: 5019 if self.parent.shouldRetry(tries, e, deadline): 5020 tries += 1 5021 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5022 continue 5023 raise plumbing.convert_error_to_porcelain(e) from e 5024 break 5025 5026 resp = models.PeeringGroupNodeCreateResponse() 5027 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5028 plumbing_response.meta) 5029 resp.peering_group_node = plumbing.convert_peering_group_node_to_porcelain( 5030 plumbing_response.peering_group_node) 5031 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5032 plumbing_response.rate_limit) 5033 return resp 5034 5035 def delete(self, id, timeout=None): 5036 ''' 5037 Delete detaches a Node to a PeeringGroup. 5038 ''' 5039 deadline = None if timeout is None else time.time() + timeout 5040 req = PeeringGroupNodeDeleteRequest() 5041 5042 req.id = (id) 5043 tries = 0 5044 plumbing_response = None 5045 while True: 5046 t = None if deadline is None else deadline - time.time() 5047 try: 5048 plumbing_response = self.stub.Delete( 5049 req, 5050 metadata=self.parent.get_metadata( 5051 'PeeringGroupNodes.Delete', req), 5052 timeout=t) 5053 except Exception as e: 5054 if self.parent.shouldRetry(tries, e, deadline): 5055 tries += 1 5056 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5057 continue 5058 raise plumbing.convert_error_to_porcelain(e) from e 5059 break 5060 5061 resp = models.PeeringGroupNodeDeleteResponse() 5062 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 5063 plumbing_response.meta) 5064 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5065 plumbing_response.rate_limit) 5066 return resp 5067 5068 def get(self, id, timeout=None): 5069 ''' 5070 Get reads the information of one peering group to node attachment. 5071 ''' 5072 deadline = None if timeout is None else time.time() + timeout 5073 req = PeeringGroupNodeGetRequest() 5074 if self.parent.snapshot_datetime is not None: 5075 req.meta.CopyFrom(GetRequestMetadata()) 5076 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5077 5078 req.id = (id) 5079 tries = 0 5080 plumbing_response = None 5081 while True: 5082 t = None if deadline is None else deadline - time.time() 5083 try: 5084 plumbing_response = self.stub.Get( 5085 req, 5086 metadata=self.parent.get_metadata('PeeringGroupNodes.Get', 5087 req), 5088 timeout=t) 5089 except Exception as e: 5090 if self.parent.shouldRetry(tries, e, deadline): 5091 tries += 1 5092 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5093 continue 5094 raise plumbing.convert_error_to_porcelain(e) from e 5095 break 5096 5097 resp = models.PeeringGroupNodeGetResponse() 5098 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5099 plumbing_response.meta) 5100 resp.peering_group_node = plumbing.convert_peering_group_node_to_porcelain( 5101 plumbing_response.peering_group_node) 5102 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5103 plumbing_response.rate_limit) 5104 return resp 5105 5106 def list(self, filter, *args, timeout=None): 5107 ''' 5108 List gets a list of peering group node attachments. 5109 ''' 5110 deadline = None if timeout is None else time.time() + timeout 5111 req = PeeringGroupNodeListRequest() 5112 req.meta.CopyFrom(ListRequestMetadata()) 5113 if self.parent.page_limit > 0: 5114 req.meta.limit = self.parent.page_limit 5115 if self.parent.snapshot_datetime is not None: 5116 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5117 5118 req.filter = plumbing.quote_filter_args(filter, *args) 5119 5120 def generator(svc, req): 5121 tries = 0 5122 while True: 5123 t = None if deadline is None else deadline - time.time() 5124 try: 5125 plumbing_response = svc.stub.List( 5126 req, 5127 metadata=svc.parent.get_metadata( 5128 'PeeringGroupNodes.List', req), 5129 timeout=t) 5130 except Exception as e: 5131 if self.parent.shouldRetry(tries, e, deadline): 5132 tries += 1 5133 time.sleep( 5134 self.parent.exponentialBackoff(tries, deadline)) 5135 continue 5136 raise plumbing.convert_error_to_porcelain(e) from e 5137 tries = 0 5138 for plumbing_item in plumbing_response.peering_group_nodes: 5139 yield plumbing.convert_peering_group_node_to_porcelain( 5140 plumbing_item) 5141 if plumbing_response.meta.next_cursor == '': 5142 break 5143 req.meta.cursor = plumbing_response.meta.next_cursor 5144 5145 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)
4997 def create(self, peering_group_node, timeout=None): 4998 ''' 4999 Create attaches a Node to a PeeringGroup 5000 ''' 5001 deadline = None if timeout is None else time.time() + timeout 5002 req = PeeringGroupNodeCreateRequest() 5003 5004 if peering_group_node is not None: 5005 req.peering_group_node.CopyFrom( 5006 plumbing.convert_peering_group_node_to_plumbing( 5007 peering_group_node)) 5008 tries = 0 5009 plumbing_response = None 5010 while True: 5011 t = None if deadline is None else deadline - time.time() 5012 try: 5013 plumbing_response = self.stub.Create( 5014 req, 5015 metadata=self.parent.get_metadata( 5016 'PeeringGroupNodes.Create', req), 5017 timeout=t) 5018 except Exception as e: 5019 if self.parent.shouldRetry(tries, e, deadline): 5020 tries += 1 5021 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5022 continue 5023 raise plumbing.convert_error_to_porcelain(e) from e 5024 break 5025 5026 resp = models.PeeringGroupNodeCreateResponse() 5027 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5028 plumbing_response.meta) 5029 resp.peering_group_node = plumbing.convert_peering_group_node_to_porcelain( 5030 plumbing_response.peering_group_node) 5031 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5032 plumbing_response.rate_limit) 5033 return resp
Create attaches a Node to a PeeringGroup
def
delete(self, id, timeout=None)
5035 def delete(self, id, timeout=None): 5036 ''' 5037 Delete detaches a Node to a PeeringGroup. 5038 ''' 5039 deadline = None if timeout is None else time.time() + timeout 5040 req = PeeringGroupNodeDeleteRequest() 5041 5042 req.id = (id) 5043 tries = 0 5044 plumbing_response = None 5045 while True: 5046 t = None if deadline is None else deadline - time.time() 5047 try: 5048 plumbing_response = self.stub.Delete( 5049 req, 5050 metadata=self.parent.get_metadata( 5051 'PeeringGroupNodes.Delete', req), 5052 timeout=t) 5053 except Exception as e: 5054 if self.parent.shouldRetry(tries, e, deadline): 5055 tries += 1 5056 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5057 continue 5058 raise plumbing.convert_error_to_porcelain(e) from e 5059 break 5060 5061 resp = models.PeeringGroupNodeDeleteResponse() 5062 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 5063 plumbing_response.meta) 5064 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5065 plumbing_response.rate_limit) 5066 return resp
Delete detaches a Node to a PeeringGroup.
def
get(self, id, timeout=None)
5068 def get(self, id, timeout=None): 5069 ''' 5070 Get reads the information of one peering group to node attachment. 5071 ''' 5072 deadline = None if timeout is None else time.time() + timeout 5073 req = PeeringGroupNodeGetRequest() 5074 if self.parent.snapshot_datetime is not None: 5075 req.meta.CopyFrom(GetRequestMetadata()) 5076 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5077 5078 req.id = (id) 5079 tries = 0 5080 plumbing_response = None 5081 while True: 5082 t = None if deadline is None else deadline - time.time() 5083 try: 5084 plumbing_response = self.stub.Get( 5085 req, 5086 metadata=self.parent.get_metadata('PeeringGroupNodes.Get', 5087 req), 5088 timeout=t) 5089 except Exception as e: 5090 if self.parent.shouldRetry(tries, e, deadline): 5091 tries += 1 5092 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5093 continue 5094 raise plumbing.convert_error_to_porcelain(e) from e 5095 break 5096 5097 resp = models.PeeringGroupNodeGetResponse() 5098 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5099 plumbing_response.meta) 5100 resp.peering_group_node = plumbing.convert_peering_group_node_to_porcelain( 5101 plumbing_response.peering_group_node) 5102 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5103 plumbing_response.rate_limit) 5104 return resp
Get reads the information of one peering group to node attachment.
def
list(self, filter, *args, timeout=None)
5106 def list(self, filter, *args, timeout=None): 5107 ''' 5108 List gets a list of peering group node attachments. 5109 ''' 5110 deadline = None if timeout is None else time.time() + timeout 5111 req = PeeringGroupNodeListRequest() 5112 req.meta.CopyFrom(ListRequestMetadata()) 5113 if self.parent.page_limit > 0: 5114 req.meta.limit = self.parent.page_limit 5115 if self.parent.snapshot_datetime is not None: 5116 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5117 5118 req.filter = plumbing.quote_filter_args(filter, *args) 5119 5120 def generator(svc, req): 5121 tries = 0 5122 while True: 5123 t = None if deadline is None else deadline - time.time() 5124 try: 5125 plumbing_response = svc.stub.List( 5126 req, 5127 metadata=svc.parent.get_metadata( 5128 'PeeringGroupNodes.List', req), 5129 timeout=t) 5130 except Exception as e: 5131 if self.parent.shouldRetry(tries, e, deadline): 5132 tries += 1 5133 time.sleep( 5134 self.parent.exponentialBackoff(tries, deadline)) 5135 continue 5136 raise plumbing.convert_error_to_porcelain(e) from e 5137 tries = 0 5138 for plumbing_item in plumbing_response.peering_group_nodes: 5139 yield plumbing.convert_peering_group_node_to_porcelain( 5140 plumbing_item) 5141 if plumbing_response.meta.next_cursor == '': 5142 break 5143 req.meta.cursor = plumbing_response.meta.next_cursor 5144 5145 return generator(self, req)
List gets a list of peering group node attachments.
class
PeeringGroupPeers:
5148class PeeringGroupPeers: 5149 ''' 5150 PeeringGroupPeers provides the building blocks necessary to link two peering groups. 5151 See `strongdm.models.PeeringGroupPeer`. 5152 ''' 5153 def __init__(self, channel, client): 5154 self.parent = client 5155 self.stub = PeeringGroupPeersStub(channel) 5156 5157 def create(self, peering_group_peer, timeout=None): 5158 ''' 5159 Create links two peering groups. 5160 ''' 5161 deadline = None if timeout is None else time.time() + timeout 5162 req = PeeringGroupPeerCreateRequest() 5163 5164 if peering_group_peer is not None: 5165 req.peering_group_peer.CopyFrom( 5166 plumbing.convert_peering_group_peer_to_plumbing( 5167 peering_group_peer)) 5168 tries = 0 5169 plumbing_response = None 5170 while True: 5171 t = None if deadline is None else deadline - time.time() 5172 try: 5173 plumbing_response = self.stub.Create( 5174 req, 5175 metadata=self.parent.get_metadata( 5176 'PeeringGroupPeers.Create', req), 5177 timeout=t) 5178 except Exception as e: 5179 if self.parent.shouldRetry(tries, e, deadline): 5180 tries += 1 5181 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5182 continue 5183 raise plumbing.convert_error_to_porcelain(e) from e 5184 break 5185 5186 resp = models.PeeringGroupPeerCreateResponse() 5187 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5188 plumbing_response.meta) 5189 resp.peering_group_peer = plumbing.convert_peering_group_peer_to_porcelain( 5190 plumbing_response.peering_group_peer) 5191 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5192 plumbing_response.rate_limit) 5193 return resp 5194 5195 def delete(self, id, timeout=None): 5196 ''' 5197 Delete unlinks two peering groups. 5198 ''' 5199 deadline = None if timeout is None else time.time() + timeout 5200 req = PeeringGroupPeerDeleteRequest() 5201 5202 req.id = (id) 5203 tries = 0 5204 plumbing_response = None 5205 while True: 5206 t = None if deadline is None else deadline - time.time() 5207 try: 5208 plumbing_response = self.stub.Delete( 5209 req, 5210 metadata=self.parent.get_metadata( 5211 'PeeringGroupPeers.Delete', req), 5212 timeout=t) 5213 except Exception as e: 5214 if self.parent.shouldRetry(tries, e, deadline): 5215 tries += 1 5216 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5217 continue 5218 raise plumbing.convert_error_to_porcelain(e) from e 5219 break 5220 5221 resp = models.PeeringGroupPeerDeleteResponse() 5222 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 5223 plumbing_response.meta) 5224 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5225 plumbing_response.rate_limit) 5226 return resp 5227 5228 def get(self, id, timeout=None): 5229 ''' 5230 Get reads the information of one peering group link. 5231 ''' 5232 deadline = None if timeout is None else time.time() + timeout 5233 req = PeeringGroupPeerGetRequest() 5234 if self.parent.snapshot_datetime is not None: 5235 req.meta.CopyFrom(GetRequestMetadata()) 5236 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5237 5238 req.id = (id) 5239 tries = 0 5240 plumbing_response = None 5241 while True: 5242 t = None if deadline is None else deadline - time.time() 5243 try: 5244 plumbing_response = self.stub.Get( 5245 req, 5246 metadata=self.parent.get_metadata('PeeringGroupPeers.Get', 5247 req), 5248 timeout=t) 5249 except Exception as e: 5250 if self.parent.shouldRetry(tries, e, deadline): 5251 tries += 1 5252 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5253 continue 5254 raise plumbing.convert_error_to_porcelain(e) from e 5255 break 5256 5257 resp = models.PeeringGroupPeerGetResponse() 5258 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5259 plumbing_response.meta) 5260 resp.peering_group_peer = plumbing.convert_peering_group_peer_to_porcelain( 5261 plumbing_response.peering_group_peer) 5262 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5263 plumbing_response.rate_limit) 5264 return resp 5265 5266 def list(self, filter, *args, timeout=None): 5267 ''' 5268 List gets a list of peering group links. 5269 ''' 5270 deadline = None if timeout is None else time.time() + timeout 5271 req = PeeringGroupPeerListRequest() 5272 req.meta.CopyFrom(ListRequestMetadata()) 5273 if self.parent.page_limit > 0: 5274 req.meta.limit = self.parent.page_limit 5275 if self.parent.snapshot_datetime is not None: 5276 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5277 5278 req.filter = plumbing.quote_filter_args(filter, *args) 5279 5280 def generator(svc, req): 5281 tries = 0 5282 while True: 5283 t = None if deadline is None else deadline - time.time() 5284 try: 5285 plumbing_response = svc.stub.List( 5286 req, 5287 metadata=svc.parent.get_metadata( 5288 'PeeringGroupPeers.List', req), 5289 timeout=t) 5290 except Exception as e: 5291 if self.parent.shouldRetry(tries, e, deadline): 5292 tries += 1 5293 time.sleep( 5294 self.parent.exponentialBackoff(tries, deadline)) 5295 continue 5296 raise plumbing.convert_error_to_porcelain(e) from e 5297 tries = 0 5298 for plumbing_item in plumbing_response.peering_group_peers: 5299 yield plumbing.convert_peering_group_peer_to_porcelain( 5300 plumbing_item) 5301 if plumbing_response.meta.next_cursor == '': 5302 break 5303 req.meta.cursor = plumbing_response.meta.next_cursor 5304 5305 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)
5157 def create(self, peering_group_peer, timeout=None): 5158 ''' 5159 Create links two peering groups. 5160 ''' 5161 deadline = None if timeout is None else time.time() + timeout 5162 req = PeeringGroupPeerCreateRequest() 5163 5164 if peering_group_peer is not None: 5165 req.peering_group_peer.CopyFrom( 5166 plumbing.convert_peering_group_peer_to_plumbing( 5167 peering_group_peer)) 5168 tries = 0 5169 plumbing_response = None 5170 while True: 5171 t = None if deadline is None else deadline - time.time() 5172 try: 5173 plumbing_response = self.stub.Create( 5174 req, 5175 metadata=self.parent.get_metadata( 5176 'PeeringGroupPeers.Create', req), 5177 timeout=t) 5178 except Exception as e: 5179 if self.parent.shouldRetry(tries, e, deadline): 5180 tries += 1 5181 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5182 continue 5183 raise plumbing.convert_error_to_porcelain(e) from e 5184 break 5185 5186 resp = models.PeeringGroupPeerCreateResponse() 5187 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5188 plumbing_response.meta) 5189 resp.peering_group_peer = plumbing.convert_peering_group_peer_to_porcelain( 5190 plumbing_response.peering_group_peer) 5191 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5192 plumbing_response.rate_limit) 5193 return resp
Create links two peering groups.
def
delete(self, id, timeout=None)
5195 def delete(self, id, timeout=None): 5196 ''' 5197 Delete unlinks two peering groups. 5198 ''' 5199 deadline = None if timeout is None else time.time() + timeout 5200 req = PeeringGroupPeerDeleteRequest() 5201 5202 req.id = (id) 5203 tries = 0 5204 plumbing_response = None 5205 while True: 5206 t = None if deadline is None else deadline - time.time() 5207 try: 5208 plumbing_response = self.stub.Delete( 5209 req, 5210 metadata=self.parent.get_metadata( 5211 'PeeringGroupPeers.Delete', req), 5212 timeout=t) 5213 except Exception as e: 5214 if self.parent.shouldRetry(tries, e, deadline): 5215 tries += 1 5216 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5217 continue 5218 raise plumbing.convert_error_to_porcelain(e) from e 5219 break 5220 5221 resp = models.PeeringGroupPeerDeleteResponse() 5222 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 5223 plumbing_response.meta) 5224 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5225 plumbing_response.rate_limit) 5226 return resp
Delete unlinks two peering groups.
def
get(self, id, timeout=None)
5228 def get(self, id, timeout=None): 5229 ''' 5230 Get reads the information of one peering group link. 5231 ''' 5232 deadline = None if timeout is None else time.time() + timeout 5233 req = PeeringGroupPeerGetRequest() 5234 if self.parent.snapshot_datetime is not None: 5235 req.meta.CopyFrom(GetRequestMetadata()) 5236 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5237 5238 req.id = (id) 5239 tries = 0 5240 plumbing_response = None 5241 while True: 5242 t = None if deadline is None else deadline - time.time() 5243 try: 5244 plumbing_response = self.stub.Get( 5245 req, 5246 metadata=self.parent.get_metadata('PeeringGroupPeers.Get', 5247 req), 5248 timeout=t) 5249 except Exception as e: 5250 if self.parent.shouldRetry(tries, e, deadline): 5251 tries += 1 5252 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5253 continue 5254 raise plumbing.convert_error_to_porcelain(e) from e 5255 break 5256 5257 resp = models.PeeringGroupPeerGetResponse() 5258 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5259 plumbing_response.meta) 5260 resp.peering_group_peer = plumbing.convert_peering_group_peer_to_porcelain( 5261 plumbing_response.peering_group_peer) 5262 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5263 plumbing_response.rate_limit) 5264 return resp
Get reads the information of one peering group link.
def
list(self, filter, *args, timeout=None)
5266 def list(self, filter, *args, timeout=None): 5267 ''' 5268 List gets a list of peering group links. 5269 ''' 5270 deadline = None if timeout is None else time.time() + timeout 5271 req = PeeringGroupPeerListRequest() 5272 req.meta.CopyFrom(ListRequestMetadata()) 5273 if self.parent.page_limit > 0: 5274 req.meta.limit = self.parent.page_limit 5275 if self.parent.snapshot_datetime is not None: 5276 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5277 5278 req.filter = plumbing.quote_filter_args(filter, *args) 5279 5280 def generator(svc, req): 5281 tries = 0 5282 while True: 5283 t = None if deadline is None else deadline - time.time() 5284 try: 5285 plumbing_response = svc.stub.List( 5286 req, 5287 metadata=svc.parent.get_metadata( 5288 'PeeringGroupPeers.List', req), 5289 timeout=t) 5290 except Exception as e: 5291 if self.parent.shouldRetry(tries, e, deadline): 5292 tries += 1 5293 time.sleep( 5294 self.parent.exponentialBackoff(tries, deadline)) 5295 continue 5296 raise plumbing.convert_error_to_porcelain(e) from e 5297 tries = 0 5298 for plumbing_item in plumbing_response.peering_group_peers: 5299 yield plumbing.convert_peering_group_peer_to_porcelain( 5300 plumbing_item) 5301 if plumbing_response.meta.next_cursor == '': 5302 break 5303 req.meta.cursor = plumbing_response.meta.next_cursor 5304 5305 return generator(self, req)
List gets a list of peering group links.
class
PeeringGroupResources:
5308class PeeringGroupResources: 5309 ''' 5310 PeeringGroupResources provides the building blocks necessary to obtain attach a resource to a peering group. 5311 See `strongdm.models.PeeringGroupResource`. 5312 ''' 5313 def __init__(self, channel, client): 5314 self.parent = client 5315 self.stub = PeeringGroupResourcesStub(channel) 5316 5317 def create(self, peering_group_resource, timeout=None): 5318 ''' 5319 Create attaches a Resource to a PeeringGroup 5320 ''' 5321 deadline = None if timeout is None else time.time() + timeout 5322 req = PeeringGroupResourceCreateRequest() 5323 5324 if peering_group_resource is not None: 5325 req.peering_group_resource.CopyFrom( 5326 plumbing.convert_peering_group_resource_to_plumbing( 5327 peering_group_resource)) 5328 tries = 0 5329 plumbing_response = None 5330 while True: 5331 t = None if deadline is None else deadline - time.time() 5332 try: 5333 plumbing_response = self.stub.Create( 5334 req, 5335 metadata=self.parent.get_metadata( 5336 'PeeringGroupResources.Create', req), 5337 timeout=t) 5338 except Exception as e: 5339 if self.parent.shouldRetry(tries, e, deadline): 5340 tries += 1 5341 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5342 continue 5343 raise plumbing.convert_error_to_porcelain(e) from e 5344 break 5345 5346 resp = models.PeeringGroupResourceCreateResponse() 5347 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5348 plumbing_response.meta) 5349 resp.peering_group_resource = plumbing.convert_peering_group_resource_to_porcelain( 5350 plumbing_response.peering_group_resource) 5351 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5352 plumbing_response.rate_limit) 5353 return resp 5354 5355 def delete(self, id, timeout=None): 5356 ''' 5357 Delete detaches a Resource to a PeeringGroup 5358 ''' 5359 deadline = None if timeout is None else time.time() + timeout 5360 req = PeeringGroupResourceDeleteRequest() 5361 5362 req.id = (id) 5363 tries = 0 5364 plumbing_response = None 5365 while True: 5366 t = None if deadline is None else deadline - time.time() 5367 try: 5368 plumbing_response = self.stub.Delete( 5369 req, 5370 metadata=self.parent.get_metadata( 5371 'PeeringGroupResources.Delete', req), 5372 timeout=t) 5373 except Exception as e: 5374 if self.parent.shouldRetry(tries, e, deadline): 5375 tries += 1 5376 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5377 continue 5378 raise plumbing.convert_error_to_porcelain(e) from e 5379 break 5380 5381 resp = models.PeeringGroupResourceDeleteResponse() 5382 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 5383 plumbing_response.meta) 5384 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5385 plumbing_response.rate_limit) 5386 return resp 5387 5388 def get(self, id, timeout=None): 5389 ''' 5390 Get reads the information of one peering group to resource attachment. 5391 ''' 5392 deadline = None if timeout is None else time.time() + timeout 5393 req = PeeringGroupResourceGetRequest() 5394 if self.parent.snapshot_datetime is not None: 5395 req.meta.CopyFrom(GetRequestMetadata()) 5396 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5397 5398 req.id = (id) 5399 tries = 0 5400 plumbing_response = None 5401 while True: 5402 t = None if deadline is None else deadline - time.time() 5403 try: 5404 plumbing_response = self.stub.Get( 5405 req, 5406 metadata=self.parent.get_metadata( 5407 'PeeringGroupResources.Get', req), 5408 timeout=t) 5409 except Exception as e: 5410 if self.parent.shouldRetry(tries, e, deadline): 5411 tries += 1 5412 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5413 continue 5414 raise plumbing.convert_error_to_porcelain(e) from e 5415 break 5416 5417 resp = models.PeeringGroupResourceGetResponse() 5418 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5419 plumbing_response.meta) 5420 resp.peering_group_resource = plumbing.convert_peering_group_resource_to_porcelain( 5421 plumbing_response.peering_group_resource) 5422 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5423 plumbing_response.rate_limit) 5424 return resp 5425 5426 def list(self, filter, *args, timeout=None): 5427 ''' 5428 List gets a list of peering group resource attachments. 5429 ''' 5430 deadline = None if timeout is None else time.time() + timeout 5431 req = PeeringGroupResourceListRequest() 5432 req.meta.CopyFrom(ListRequestMetadata()) 5433 if self.parent.page_limit > 0: 5434 req.meta.limit = self.parent.page_limit 5435 if self.parent.snapshot_datetime is not None: 5436 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5437 5438 req.filter = plumbing.quote_filter_args(filter, *args) 5439 5440 def generator(svc, req): 5441 tries = 0 5442 while True: 5443 t = None if deadline is None else deadline - time.time() 5444 try: 5445 plumbing_response = svc.stub.List( 5446 req, 5447 metadata=svc.parent.get_metadata( 5448 'PeeringGroupResources.List', req), 5449 timeout=t) 5450 except Exception as e: 5451 if self.parent.shouldRetry(tries, e, deadline): 5452 tries += 1 5453 time.sleep( 5454 self.parent.exponentialBackoff(tries, deadline)) 5455 continue 5456 raise plumbing.convert_error_to_porcelain(e) from e 5457 tries = 0 5458 for plumbing_item in plumbing_response.peering_group_resources: 5459 yield plumbing.convert_peering_group_resource_to_porcelain( 5460 plumbing_item) 5461 if plumbing_response.meta.next_cursor == '': 5462 break 5463 req.meta.cursor = plumbing_response.meta.next_cursor 5464 5465 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)
5317 def create(self, peering_group_resource, timeout=None): 5318 ''' 5319 Create attaches a Resource to a PeeringGroup 5320 ''' 5321 deadline = None if timeout is None else time.time() + timeout 5322 req = PeeringGroupResourceCreateRequest() 5323 5324 if peering_group_resource is not None: 5325 req.peering_group_resource.CopyFrom( 5326 plumbing.convert_peering_group_resource_to_plumbing( 5327 peering_group_resource)) 5328 tries = 0 5329 plumbing_response = None 5330 while True: 5331 t = None if deadline is None else deadline - time.time() 5332 try: 5333 plumbing_response = self.stub.Create( 5334 req, 5335 metadata=self.parent.get_metadata( 5336 'PeeringGroupResources.Create', req), 5337 timeout=t) 5338 except Exception as e: 5339 if self.parent.shouldRetry(tries, e, deadline): 5340 tries += 1 5341 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5342 continue 5343 raise plumbing.convert_error_to_porcelain(e) from e 5344 break 5345 5346 resp = models.PeeringGroupResourceCreateResponse() 5347 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5348 plumbing_response.meta) 5349 resp.peering_group_resource = plumbing.convert_peering_group_resource_to_porcelain( 5350 plumbing_response.peering_group_resource) 5351 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5352 plumbing_response.rate_limit) 5353 return resp
Create attaches a Resource to a PeeringGroup
def
delete(self, id, timeout=None)
5355 def delete(self, id, timeout=None): 5356 ''' 5357 Delete detaches a Resource to a PeeringGroup 5358 ''' 5359 deadline = None if timeout is None else time.time() + timeout 5360 req = PeeringGroupResourceDeleteRequest() 5361 5362 req.id = (id) 5363 tries = 0 5364 plumbing_response = None 5365 while True: 5366 t = None if deadline is None else deadline - time.time() 5367 try: 5368 plumbing_response = self.stub.Delete( 5369 req, 5370 metadata=self.parent.get_metadata( 5371 'PeeringGroupResources.Delete', req), 5372 timeout=t) 5373 except Exception as e: 5374 if self.parent.shouldRetry(tries, e, deadline): 5375 tries += 1 5376 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5377 continue 5378 raise plumbing.convert_error_to_porcelain(e) from e 5379 break 5380 5381 resp = models.PeeringGroupResourceDeleteResponse() 5382 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 5383 plumbing_response.meta) 5384 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5385 plumbing_response.rate_limit) 5386 return resp
Delete detaches a Resource to a PeeringGroup
def
get(self, id, timeout=None)
5388 def get(self, id, timeout=None): 5389 ''' 5390 Get reads the information of one peering group to resource attachment. 5391 ''' 5392 deadline = None if timeout is None else time.time() + timeout 5393 req = PeeringGroupResourceGetRequest() 5394 if self.parent.snapshot_datetime is not None: 5395 req.meta.CopyFrom(GetRequestMetadata()) 5396 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5397 5398 req.id = (id) 5399 tries = 0 5400 plumbing_response = None 5401 while True: 5402 t = None if deadline is None else deadline - time.time() 5403 try: 5404 plumbing_response = self.stub.Get( 5405 req, 5406 metadata=self.parent.get_metadata( 5407 'PeeringGroupResources.Get', req), 5408 timeout=t) 5409 except Exception as e: 5410 if self.parent.shouldRetry(tries, e, deadline): 5411 tries += 1 5412 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5413 continue 5414 raise plumbing.convert_error_to_porcelain(e) from e 5415 break 5416 5417 resp = models.PeeringGroupResourceGetResponse() 5418 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5419 plumbing_response.meta) 5420 resp.peering_group_resource = plumbing.convert_peering_group_resource_to_porcelain( 5421 plumbing_response.peering_group_resource) 5422 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5423 plumbing_response.rate_limit) 5424 return resp
Get reads the information of one peering group to resource attachment.
def
list(self, filter, *args, timeout=None)
5426 def list(self, filter, *args, timeout=None): 5427 ''' 5428 List gets a list of peering group resource attachments. 5429 ''' 5430 deadline = None if timeout is None else time.time() + timeout 5431 req = PeeringGroupResourceListRequest() 5432 req.meta.CopyFrom(ListRequestMetadata()) 5433 if self.parent.page_limit > 0: 5434 req.meta.limit = self.parent.page_limit 5435 if self.parent.snapshot_datetime is not None: 5436 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5437 5438 req.filter = plumbing.quote_filter_args(filter, *args) 5439 5440 def generator(svc, req): 5441 tries = 0 5442 while True: 5443 t = None if deadline is None else deadline - time.time() 5444 try: 5445 plumbing_response = svc.stub.List( 5446 req, 5447 metadata=svc.parent.get_metadata( 5448 'PeeringGroupResources.List', req), 5449 timeout=t) 5450 except Exception as e: 5451 if self.parent.shouldRetry(tries, e, deadline): 5452 tries += 1 5453 time.sleep( 5454 self.parent.exponentialBackoff(tries, deadline)) 5455 continue 5456 raise plumbing.convert_error_to_porcelain(e) from e 5457 tries = 0 5458 for plumbing_item in plumbing_response.peering_group_resources: 5459 yield plumbing.convert_peering_group_resource_to_porcelain( 5460 plumbing_item) 5461 if plumbing_response.meta.next_cursor == '': 5462 break 5463 req.meta.cursor = plumbing_response.meta.next_cursor 5464 5465 return generator(self, req)
List gets a list of peering group resource attachments.
class
PeeringGroups:
5468class PeeringGroups: 5469 ''' 5470 PeeringGroups provides the building blocks necessary to obtain explicit network topology and routing. 5471 See `strongdm.models.PeeringGroup`. 5472 ''' 5473 def __init__(self, channel, client): 5474 self.parent = client 5475 self.stub = PeeringGroupsStub(channel) 5476 5477 def create(self, peering_group, timeout=None): 5478 ''' 5479 Create registers a new PeeringGroup. 5480 ''' 5481 deadline = None if timeout is None else time.time() + timeout 5482 req = PeeringGroupCreateRequest() 5483 5484 if peering_group is not None: 5485 req.peering_group.CopyFrom( 5486 plumbing.convert_peering_group_to_plumbing(peering_group)) 5487 tries = 0 5488 plumbing_response = None 5489 while True: 5490 t = None if deadline is None else deadline - time.time() 5491 try: 5492 plumbing_response = self.stub.Create( 5493 req, 5494 metadata=self.parent.get_metadata('PeeringGroups.Create', 5495 req), 5496 timeout=t) 5497 except Exception as e: 5498 if self.parent.shouldRetry(tries, e, deadline): 5499 tries += 1 5500 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5501 continue 5502 raise plumbing.convert_error_to_porcelain(e) from e 5503 break 5504 5505 resp = models.PeeringGroupCreateResponse() 5506 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5507 plumbing_response.meta) 5508 resp.peering_group = plumbing.convert_peering_group_to_porcelain( 5509 plumbing_response.peering_group) 5510 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5511 plumbing_response.rate_limit) 5512 return resp 5513 5514 def delete(self, id, timeout=None): 5515 ''' 5516 Delete removes a PeeringGroup by ID. 5517 ''' 5518 deadline = None if timeout is None else time.time() + timeout 5519 req = PeeringGroupDeleteRequest() 5520 5521 req.id = (id) 5522 tries = 0 5523 plumbing_response = None 5524 while True: 5525 t = None if deadline is None else deadline - time.time() 5526 try: 5527 plumbing_response = self.stub.Delete( 5528 req, 5529 metadata=self.parent.get_metadata('PeeringGroups.Delete', 5530 req), 5531 timeout=t) 5532 except Exception as e: 5533 if self.parent.shouldRetry(tries, e, deadline): 5534 tries += 1 5535 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5536 continue 5537 raise plumbing.convert_error_to_porcelain(e) from e 5538 break 5539 5540 resp = models.PeeringGroupDeleteResponse() 5541 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 5542 plumbing_response.meta) 5543 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5544 plumbing_response.rate_limit) 5545 return resp 5546 5547 def get(self, id, timeout=None): 5548 ''' 5549 Get reads one PeeringGroup by ID. It will load all its dependencies. 5550 ''' 5551 deadline = None if timeout is None else time.time() + timeout 5552 req = PeeringGroupGetRequest() 5553 if self.parent.snapshot_datetime is not None: 5554 req.meta.CopyFrom(GetRequestMetadata()) 5555 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5556 5557 req.id = (id) 5558 tries = 0 5559 plumbing_response = None 5560 while True: 5561 t = None if deadline is None else deadline - time.time() 5562 try: 5563 plumbing_response = self.stub.Get( 5564 req, 5565 metadata=self.parent.get_metadata('PeeringGroups.Get', 5566 req), 5567 timeout=t) 5568 except Exception as e: 5569 if self.parent.shouldRetry(tries, e, deadline): 5570 tries += 1 5571 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5572 continue 5573 raise plumbing.convert_error_to_porcelain(e) from e 5574 break 5575 5576 resp = models.PeeringGroupGetResponse() 5577 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5578 plumbing_response.meta) 5579 resp.peering_group = plumbing.convert_peering_group_to_porcelain( 5580 plumbing_response.peering_group) 5581 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5582 plumbing_response.rate_limit) 5583 return resp 5584 5585 def list(self, filter, *args, timeout=None): 5586 ''' 5587 List gets a list of Peering Groups. 5588 ''' 5589 deadline = None if timeout is None else time.time() + timeout 5590 req = PeeringGroupListRequest() 5591 req.meta.CopyFrom(ListRequestMetadata()) 5592 if self.parent.page_limit > 0: 5593 req.meta.limit = self.parent.page_limit 5594 if self.parent.snapshot_datetime is not None: 5595 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5596 5597 req.filter = plumbing.quote_filter_args(filter, *args) 5598 5599 def generator(svc, req): 5600 tries = 0 5601 while True: 5602 t = None if deadline is None else deadline - time.time() 5603 try: 5604 plumbing_response = svc.stub.List( 5605 req, 5606 metadata=svc.parent.get_metadata( 5607 'PeeringGroups.List', req), 5608 timeout=t) 5609 except Exception as e: 5610 if self.parent.shouldRetry(tries, e, deadline): 5611 tries += 1 5612 time.sleep( 5613 self.parent.exponentialBackoff(tries, deadline)) 5614 continue 5615 raise plumbing.convert_error_to_porcelain(e) from e 5616 tries = 0 5617 for plumbing_item in plumbing_response.peering_groups: 5618 yield plumbing.convert_peering_group_to_porcelain( 5619 plumbing_item) 5620 if plumbing_response.meta.next_cursor == '': 5621 break 5622 req.meta.cursor = plumbing_response.meta.next_cursor 5623 5624 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)
5477 def create(self, peering_group, timeout=None): 5478 ''' 5479 Create registers a new PeeringGroup. 5480 ''' 5481 deadline = None if timeout is None else time.time() + timeout 5482 req = PeeringGroupCreateRequest() 5483 5484 if peering_group is not None: 5485 req.peering_group.CopyFrom( 5486 plumbing.convert_peering_group_to_plumbing(peering_group)) 5487 tries = 0 5488 plumbing_response = None 5489 while True: 5490 t = None if deadline is None else deadline - time.time() 5491 try: 5492 plumbing_response = self.stub.Create( 5493 req, 5494 metadata=self.parent.get_metadata('PeeringGroups.Create', 5495 req), 5496 timeout=t) 5497 except Exception as e: 5498 if self.parent.shouldRetry(tries, e, deadline): 5499 tries += 1 5500 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5501 continue 5502 raise plumbing.convert_error_to_porcelain(e) from e 5503 break 5504 5505 resp = models.PeeringGroupCreateResponse() 5506 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5507 plumbing_response.meta) 5508 resp.peering_group = plumbing.convert_peering_group_to_porcelain( 5509 plumbing_response.peering_group) 5510 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5511 plumbing_response.rate_limit) 5512 return resp
Create registers a new PeeringGroup.
def
delete(self, id, timeout=None)
5514 def delete(self, id, timeout=None): 5515 ''' 5516 Delete removes a PeeringGroup by ID. 5517 ''' 5518 deadline = None if timeout is None else time.time() + timeout 5519 req = PeeringGroupDeleteRequest() 5520 5521 req.id = (id) 5522 tries = 0 5523 plumbing_response = None 5524 while True: 5525 t = None if deadline is None else deadline - time.time() 5526 try: 5527 plumbing_response = self.stub.Delete( 5528 req, 5529 metadata=self.parent.get_metadata('PeeringGroups.Delete', 5530 req), 5531 timeout=t) 5532 except Exception as e: 5533 if self.parent.shouldRetry(tries, e, deadline): 5534 tries += 1 5535 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5536 continue 5537 raise plumbing.convert_error_to_porcelain(e) from e 5538 break 5539 5540 resp = models.PeeringGroupDeleteResponse() 5541 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 5542 plumbing_response.meta) 5543 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5544 plumbing_response.rate_limit) 5545 return resp
Delete removes a PeeringGroup by ID.
def
get(self, id, timeout=None)
5547 def get(self, id, timeout=None): 5548 ''' 5549 Get reads one PeeringGroup by ID. It will load all its dependencies. 5550 ''' 5551 deadline = None if timeout is None else time.time() + timeout 5552 req = PeeringGroupGetRequest() 5553 if self.parent.snapshot_datetime is not None: 5554 req.meta.CopyFrom(GetRequestMetadata()) 5555 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5556 5557 req.id = (id) 5558 tries = 0 5559 plumbing_response = None 5560 while True: 5561 t = None if deadline is None else deadline - time.time() 5562 try: 5563 plumbing_response = self.stub.Get( 5564 req, 5565 metadata=self.parent.get_metadata('PeeringGroups.Get', 5566 req), 5567 timeout=t) 5568 except Exception as e: 5569 if self.parent.shouldRetry(tries, e, deadline): 5570 tries += 1 5571 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5572 continue 5573 raise plumbing.convert_error_to_porcelain(e) from e 5574 break 5575 5576 resp = models.PeeringGroupGetResponse() 5577 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5578 plumbing_response.meta) 5579 resp.peering_group = plumbing.convert_peering_group_to_porcelain( 5580 plumbing_response.peering_group) 5581 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5582 plumbing_response.rate_limit) 5583 return resp
Get reads one PeeringGroup by ID. It will load all its dependencies.
def
list(self, filter, *args, timeout=None)
5585 def list(self, filter, *args, timeout=None): 5586 ''' 5587 List gets a list of Peering Groups. 5588 ''' 5589 deadline = None if timeout is None else time.time() + timeout 5590 req = PeeringGroupListRequest() 5591 req.meta.CopyFrom(ListRequestMetadata()) 5592 if self.parent.page_limit > 0: 5593 req.meta.limit = self.parent.page_limit 5594 if self.parent.snapshot_datetime is not None: 5595 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5596 5597 req.filter = plumbing.quote_filter_args(filter, *args) 5598 5599 def generator(svc, req): 5600 tries = 0 5601 while True: 5602 t = None if deadline is None else deadline - time.time() 5603 try: 5604 plumbing_response = svc.stub.List( 5605 req, 5606 metadata=svc.parent.get_metadata( 5607 'PeeringGroups.List', req), 5608 timeout=t) 5609 except Exception as e: 5610 if self.parent.shouldRetry(tries, e, deadline): 5611 tries += 1 5612 time.sleep( 5613 self.parent.exponentialBackoff(tries, deadline)) 5614 continue 5615 raise plumbing.convert_error_to_porcelain(e) from e 5616 tries = 0 5617 for plumbing_item in plumbing_response.peering_groups: 5618 yield plumbing.convert_peering_group_to_porcelain( 5619 plumbing_item) 5620 if plumbing_response.meta.next_cursor == '': 5621 break 5622 req.meta.cursor = plumbing_response.meta.next_cursor 5623 5624 return generator(self, req)
List gets a list of Peering Groups.
class
Policies:
5627class Policies: 5628 ''' 5629 Policies are the collection of one or more statements that enforce fine-grained access 5630 control for the users of an organization. 5631 See `strongdm.models.Policy`. 5632 ''' 5633 def __init__(self, channel, client): 5634 self.parent = client 5635 self.stub = PoliciesStub(channel) 5636 5637 def create(self, policy, timeout=None): 5638 ''' 5639 Create creates a new Policy. 5640 ''' 5641 deadline = None if timeout is None else time.time() + timeout 5642 req = PolicyCreateRequest() 5643 5644 if policy is not None: 5645 req.policy.CopyFrom(plumbing.convert_policy_to_plumbing(policy)) 5646 tries = 0 5647 plumbing_response = None 5648 while True: 5649 t = None if deadline is None else deadline - time.time() 5650 try: 5651 plumbing_response = self.stub.Create( 5652 req, 5653 metadata=self.parent.get_metadata('Policies.Create', req), 5654 timeout=t) 5655 except Exception as e: 5656 if self.parent.shouldRetry(tries, e, deadline): 5657 tries += 1 5658 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5659 continue 5660 raise plumbing.convert_error_to_porcelain(e) from e 5661 break 5662 5663 resp = models.PolicyCreateResponse() 5664 resp.policy = plumbing.convert_policy_to_porcelain( 5665 plumbing_response.policy) 5666 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5667 plumbing_response.rate_limit) 5668 return resp 5669 5670 def delete(self, id, timeout=None): 5671 ''' 5672 Delete removes a Policy by ID. 5673 ''' 5674 deadline = None if timeout is None else time.time() + timeout 5675 req = PolicyDeleteRequest() 5676 5677 req.id = (id) 5678 tries = 0 5679 plumbing_response = None 5680 while True: 5681 t = None if deadline is None else deadline - time.time() 5682 try: 5683 plumbing_response = self.stub.Delete( 5684 req, 5685 metadata=self.parent.get_metadata('Policies.Delete', req), 5686 timeout=t) 5687 except Exception as e: 5688 if self.parent.shouldRetry(tries, e, deadline): 5689 tries += 1 5690 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5691 continue 5692 raise plumbing.convert_error_to_porcelain(e) from e 5693 break 5694 5695 resp = models.PolicyDeleteResponse() 5696 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5697 plumbing_response.rate_limit) 5698 return resp 5699 5700 def update(self, policy, timeout=None): 5701 ''' 5702 Update replaces all the fields of a Policy by ID. 5703 ''' 5704 deadline = None if timeout is None else time.time() + timeout 5705 req = PolicyUpdateRequest() 5706 5707 if policy is not None: 5708 req.policy.CopyFrom(plumbing.convert_policy_to_plumbing(policy)) 5709 tries = 0 5710 plumbing_response = None 5711 while True: 5712 t = None if deadline is None else deadline - time.time() 5713 try: 5714 plumbing_response = self.stub.Update( 5715 req, 5716 metadata=self.parent.get_metadata('Policies.Update', req), 5717 timeout=t) 5718 except Exception as e: 5719 if self.parent.shouldRetry(tries, e, deadline): 5720 tries += 1 5721 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5722 continue 5723 raise plumbing.convert_error_to_porcelain(e) from e 5724 break 5725 5726 resp = models.PolicyUpdateResponse() 5727 resp.policy = plumbing.convert_policy_to_porcelain( 5728 plumbing_response.policy) 5729 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5730 plumbing_response.rate_limit) 5731 return resp 5732 5733 def get(self, id, timeout=None): 5734 ''' 5735 Get reads one Policy by ID. 5736 ''' 5737 deadline = None if timeout is None else time.time() + timeout 5738 req = PolicyGetRequest() 5739 if self.parent.snapshot_datetime is not None: 5740 req.meta.CopyFrom(GetRequestMetadata()) 5741 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5742 5743 req.id = (id) 5744 tries = 0 5745 plumbing_response = None 5746 while True: 5747 t = None if deadline is None else deadline - time.time() 5748 try: 5749 plumbing_response = self.stub.Get( 5750 req, 5751 metadata=self.parent.get_metadata('Policies.Get', req), 5752 timeout=t) 5753 except Exception as e: 5754 if self.parent.shouldRetry(tries, e, deadline): 5755 tries += 1 5756 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5757 continue 5758 raise plumbing.convert_error_to_porcelain(e) from e 5759 break 5760 5761 resp = models.PolicyGetResponse() 5762 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5763 plumbing_response.meta) 5764 resp.policy = plumbing.convert_policy_to_porcelain( 5765 plumbing_response.policy) 5766 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5767 plumbing_response.rate_limit) 5768 return resp 5769 5770 def list(self, filter, *args, timeout=None): 5771 ''' 5772 List gets a list of Policy matching a given set of criteria 5773 ''' 5774 deadline = None if timeout is None else time.time() + timeout 5775 req = PolicyListRequest() 5776 req.meta.CopyFrom(ListRequestMetadata()) 5777 if self.parent.page_limit > 0: 5778 req.meta.limit = self.parent.page_limit 5779 if self.parent.snapshot_datetime is not None: 5780 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5781 5782 req.filter = plumbing.quote_filter_args(filter, *args) 5783 5784 def generator(svc, req): 5785 tries = 0 5786 while True: 5787 t = None if deadline is None else deadline - time.time() 5788 try: 5789 plumbing_response = svc.stub.List( 5790 req, 5791 metadata=svc.parent.get_metadata('Policies.List', req), 5792 timeout=t) 5793 except Exception as e: 5794 if self.parent.shouldRetry(tries, e, deadline): 5795 tries += 1 5796 time.sleep( 5797 self.parent.exponentialBackoff(tries, deadline)) 5798 continue 5799 raise plumbing.convert_error_to_porcelain(e) from e 5800 tries = 0 5801 for plumbing_item in plumbing_response.policies: 5802 yield plumbing.convert_policy_to_porcelain(plumbing_item) 5803 if plumbing_response.meta.next_cursor == '': 5804 break 5805 req.meta.cursor = plumbing_response.meta.next_cursor 5806 5807 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)
5637 def create(self, policy, timeout=None): 5638 ''' 5639 Create creates a new Policy. 5640 ''' 5641 deadline = None if timeout is None else time.time() + timeout 5642 req = PolicyCreateRequest() 5643 5644 if policy is not None: 5645 req.policy.CopyFrom(plumbing.convert_policy_to_plumbing(policy)) 5646 tries = 0 5647 plumbing_response = None 5648 while True: 5649 t = None if deadline is None else deadline - time.time() 5650 try: 5651 plumbing_response = self.stub.Create( 5652 req, 5653 metadata=self.parent.get_metadata('Policies.Create', req), 5654 timeout=t) 5655 except Exception as e: 5656 if self.parent.shouldRetry(tries, e, deadline): 5657 tries += 1 5658 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5659 continue 5660 raise plumbing.convert_error_to_porcelain(e) from e 5661 break 5662 5663 resp = models.PolicyCreateResponse() 5664 resp.policy = plumbing.convert_policy_to_porcelain( 5665 plumbing_response.policy) 5666 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5667 plumbing_response.rate_limit) 5668 return resp
Create creates a new Policy.
def
delete(self, id, timeout=None)
5670 def delete(self, id, timeout=None): 5671 ''' 5672 Delete removes a Policy by ID. 5673 ''' 5674 deadline = None if timeout is None else time.time() + timeout 5675 req = PolicyDeleteRequest() 5676 5677 req.id = (id) 5678 tries = 0 5679 plumbing_response = None 5680 while True: 5681 t = None if deadline is None else deadline - time.time() 5682 try: 5683 plumbing_response = self.stub.Delete( 5684 req, 5685 metadata=self.parent.get_metadata('Policies.Delete', req), 5686 timeout=t) 5687 except Exception as e: 5688 if self.parent.shouldRetry(tries, e, deadline): 5689 tries += 1 5690 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5691 continue 5692 raise plumbing.convert_error_to_porcelain(e) from e 5693 break 5694 5695 resp = models.PolicyDeleteResponse() 5696 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5697 plumbing_response.rate_limit) 5698 return resp
Delete removes a Policy by ID.
def
update(self, policy, timeout=None)
5700 def update(self, policy, timeout=None): 5701 ''' 5702 Update replaces all the fields of a Policy by ID. 5703 ''' 5704 deadline = None if timeout is None else time.time() + timeout 5705 req = PolicyUpdateRequest() 5706 5707 if policy is not None: 5708 req.policy.CopyFrom(plumbing.convert_policy_to_plumbing(policy)) 5709 tries = 0 5710 plumbing_response = None 5711 while True: 5712 t = None if deadline is None else deadline - time.time() 5713 try: 5714 plumbing_response = self.stub.Update( 5715 req, 5716 metadata=self.parent.get_metadata('Policies.Update', req), 5717 timeout=t) 5718 except Exception as e: 5719 if self.parent.shouldRetry(tries, e, deadline): 5720 tries += 1 5721 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5722 continue 5723 raise plumbing.convert_error_to_porcelain(e) from e 5724 break 5725 5726 resp = models.PolicyUpdateResponse() 5727 resp.policy = plumbing.convert_policy_to_porcelain( 5728 plumbing_response.policy) 5729 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5730 plumbing_response.rate_limit) 5731 return resp
Update replaces all the fields of a Policy by ID.
def
get(self, id, timeout=None)
5733 def get(self, id, timeout=None): 5734 ''' 5735 Get reads one Policy by ID. 5736 ''' 5737 deadline = None if timeout is None else time.time() + timeout 5738 req = PolicyGetRequest() 5739 if self.parent.snapshot_datetime is not None: 5740 req.meta.CopyFrom(GetRequestMetadata()) 5741 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5742 5743 req.id = (id) 5744 tries = 0 5745 plumbing_response = None 5746 while True: 5747 t = None if deadline is None else deadline - time.time() 5748 try: 5749 plumbing_response = self.stub.Get( 5750 req, 5751 metadata=self.parent.get_metadata('Policies.Get', req), 5752 timeout=t) 5753 except Exception as e: 5754 if self.parent.shouldRetry(tries, e, deadline): 5755 tries += 1 5756 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5757 continue 5758 raise plumbing.convert_error_to_porcelain(e) from e 5759 break 5760 5761 resp = models.PolicyGetResponse() 5762 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5763 plumbing_response.meta) 5764 resp.policy = plumbing.convert_policy_to_porcelain( 5765 plumbing_response.policy) 5766 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5767 plumbing_response.rate_limit) 5768 return resp
Get reads one Policy by ID.
def
list(self, filter, *args, timeout=None)
5770 def list(self, filter, *args, timeout=None): 5771 ''' 5772 List gets a list of Policy matching a given set of criteria 5773 ''' 5774 deadline = None if timeout is None else time.time() + timeout 5775 req = PolicyListRequest() 5776 req.meta.CopyFrom(ListRequestMetadata()) 5777 if self.parent.page_limit > 0: 5778 req.meta.limit = self.parent.page_limit 5779 if self.parent.snapshot_datetime is not None: 5780 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5781 5782 req.filter = plumbing.quote_filter_args(filter, *args) 5783 5784 def generator(svc, req): 5785 tries = 0 5786 while True: 5787 t = None if deadline is None else deadline - time.time() 5788 try: 5789 plumbing_response = svc.stub.List( 5790 req, 5791 metadata=svc.parent.get_metadata('Policies.List', req), 5792 timeout=t) 5793 except Exception as e: 5794 if self.parent.shouldRetry(tries, e, deadline): 5795 tries += 1 5796 time.sleep( 5797 self.parent.exponentialBackoff(tries, deadline)) 5798 continue 5799 raise plumbing.convert_error_to_porcelain(e) from e 5800 tries = 0 5801 for plumbing_item in plumbing_response.policies: 5802 yield plumbing.convert_policy_to_porcelain(plumbing_item) 5803 if plumbing_response.meta.next_cursor == '': 5804 break 5805 req.meta.cursor = plumbing_response.meta.next_cursor 5806 5807 return generator(self, req)
List gets a list of Policy matching a given set of criteria
class
SnapshotPolicies:
5810class SnapshotPolicies: 5811 ''' 5812 SnapshotPolicies exposes the read only methods of the Policies 5813 service for historical queries. 5814 ''' 5815 def __init__(self, policies): 5816 self.policies = policies 5817 5818 def get(self, id, timeout=None): 5819 ''' 5820 Get reads one Policy by ID. 5821 ''' 5822 return self.policies.get(id, timeout=timeout) 5823 5824 def list(self, filter, *args, timeout=None): 5825 ''' 5826 List gets a list of Policy matching a given set of criteria 5827 ''' 5828 return self.policies.list(filter, *args, timeout=timeout)
SnapshotPolicies exposes the read only methods of the Policies service for historical queries.
class
PoliciesHistory:
5831class PoliciesHistory: 5832 ''' 5833 PoliciesHistory records all changes to the state of a Policy. 5834 See `strongdm.models.PolicyHistory`. 5835 ''' 5836 def __init__(self, channel, client): 5837 self.parent = client 5838 self.stub = PoliciesHistoryStub(channel) 5839 5840 def list(self, filter, *args, timeout=None): 5841 ''' 5842 List gets a list of PolicyHistory records matching a given set of criteria. 5843 ''' 5844 deadline = None if timeout is None else time.time() + timeout 5845 req = PoliciesHistoryListRequest() 5846 req.meta.CopyFrom(ListRequestMetadata()) 5847 if self.parent.page_limit > 0: 5848 req.meta.limit = self.parent.page_limit 5849 if self.parent.snapshot_datetime is not None: 5850 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5851 5852 req.filter = plumbing.quote_filter_args(filter, *args) 5853 5854 def generator(svc, req): 5855 tries = 0 5856 while True: 5857 t = None if deadline is None else deadline - time.time() 5858 try: 5859 plumbing_response = svc.stub.List( 5860 req, 5861 metadata=svc.parent.get_metadata( 5862 'PoliciesHistory.List', req), 5863 timeout=t) 5864 except Exception as e: 5865 if self.parent.shouldRetry(tries, e, deadline): 5866 tries += 1 5867 time.sleep( 5868 self.parent.exponentialBackoff(tries, deadline)) 5869 continue 5870 raise plumbing.convert_error_to_porcelain(e) from e 5871 tries = 0 5872 for plumbing_item in plumbing_response.history: 5873 yield plumbing.convert_policy_history_to_porcelain( 5874 plumbing_item) 5875 if plumbing_response.meta.next_cursor == '': 5876 break 5877 req.meta.cursor = plumbing_response.meta.next_cursor 5878 5879 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)
5840 def list(self, filter, *args, timeout=None): 5841 ''' 5842 List gets a list of PolicyHistory records matching a given set of criteria. 5843 ''' 5844 deadline = None if timeout is None else time.time() + timeout 5845 req = PoliciesHistoryListRequest() 5846 req.meta.CopyFrom(ListRequestMetadata()) 5847 if self.parent.page_limit > 0: 5848 req.meta.limit = self.parent.page_limit 5849 if self.parent.snapshot_datetime is not None: 5850 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5851 5852 req.filter = plumbing.quote_filter_args(filter, *args) 5853 5854 def generator(svc, req): 5855 tries = 0 5856 while True: 5857 t = None if deadline is None else deadline - time.time() 5858 try: 5859 plumbing_response = svc.stub.List( 5860 req, 5861 metadata=svc.parent.get_metadata( 5862 'PoliciesHistory.List', req), 5863 timeout=t) 5864 except Exception as e: 5865 if self.parent.shouldRetry(tries, e, deadline): 5866 tries += 1 5867 time.sleep( 5868 self.parent.exponentialBackoff(tries, deadline)) 5869 continue 5870 raise plumbing.convert_error_to_porcelain(e) from e 5871 tries = 0 5872 for plumbing_item in plumbing_response.history: 5873 yield plumbing.convert_policy_history_to_porcelain( 5874 plumbing_item) 5875 if plumbing_response.meta.next_cursor == '': 5876 break 5877 req.meta.cursor = plumbing_response.meta.next_cursor 5878 5879 return generator(self, req)
List gets a list of PolicyHistory records matching a given set of criteria.
class
ProxyClusterKeys:
5882class ProxyClusterKeys: 5883 ''' 5884 Proxy Cluster Keys are authentication keys for all proxies within a cluster. 5885 The proxies within a cluster share the same key. One cluster can have 5886 multiple keys in order to facilitate key rotation. 5887 See `strongdm.models.ProxyClusterKey`. 5888 ''' 5889 def __init__(self, channel, client): 5890 self.parent = client 5891 self.stub = ProxyClusterKeysStub(channel) 5892 5893 def create(self, proxy_cluster_key, timeout=None): 5894 ''' 5895 Create registers a new ProxyClusterKey. 5896 ''' 5897 deadline = None if timeout is None else time.time() + timeout 5898 req = ProxyClusterKeyCreateRequest() 5899 5900 if proxy_cluster_key is not None: 5901 req.proxy_cluster_key.CopyFrom( 5902 plumbing.convert_proxy_cluster_key_to_plumbing( 5903 proxy_cluster_key)) 5904 tries = 0 5905 plumbing_response = None 5906 while True: 5907 t = None if deadline is None else deadline - time.time() 5908 try: 5909 plumbing_response = self.stub.Create( 5910 req, 5911 metadata=self.parent.get_metadata( 5912 'ProxyClusterKeys.Create', req), 5913 timeout=t) 5914 except Exception as e: 5915 if self.parent.shouldRetry(tries, e, deadline): 5916 tries += 1 5917 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5918 continue 5919 raise plumbing.convert_error_to_porcelain(e) from e 5920 break 5921 5922 resp = models.ProxyClusterKeyCreateResponse() 5923 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5924 plumbing_response.meta) 5925 resp.proxy_cluster_key = plumbing.convert_proxy_cluster_key_to_porcelain( 5926 plumbing_response.proxy_cluster_key) 5927 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5928 plumbing_response.rate_limit) 5929 resp.secret_key = (plumbing_response.secret_key) 5930 return resp 5931 5932 def get(self, id, timeout=None): 5933 ''' 5934 Get reads one ProxyClusterKey by ID. 5935 ''' 5936 deadline = None if timeout is None else time.time() + timeout 5937 req = ProxyClusterKeyGetRequest() 5938 if self.parent.snapshot_datetime is not None: 5939 req.meta.CopyFrom(GetRequestMetadata()) 5940 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5941 5942 req.id = (id) 5943 tries = 0 5944 plumbing_response = None 5945 while True: 5946 t = None if deadline is None else deadline - time.time() 5947 try: 5948 plumbing_response = self.stub.Get( 5949 req, 5950 metadata=self.parent.get_metadata('ProxyClusterKeys.Get', 5951 req), 5952 timeout=t) 5953 except Exception as e: 5954 if self.parent.shouldRetry(tries, e, deadline): 5955 tries += 1 5956 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5957 continue 5958 raise plumbing.convert_error_to_porcelain(e) from e 5959 break 5960 5961 resp = models.ProxyClusterKeyGetResponse() 5962 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5963 plumbing_response.meta) 5964 resp.proxy_cluster_key = plumbing.convert_proxy_cluster_key_to_porcelain( 5965 plumbing_response.proxy_cluster_key) 5966 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5967 plumbing_response.rate_limit) 5968 return resp 5969 5970 def delete(self, id, timeout=None): 5971 ''' 5972 Delete removes a ProxyClusterKey by ID. 5973 ''' 5974 deadline = None if timeout is None else time.time() + timeout 5975 req = ProxyClusterKeyDeleteRequest() 5976 5977 req.id = (id) 5978 tries = 0 5979 plumbing_response = None 5980 while True: 5981 t = None if deadline is None else deadline - time.time() 5982 try: 5983 plumbing_response = self.stub.Delete( 5984 req, 5985 metadata=self.parent.get_metadata( 5986 'ProxyClusterKeys.Delete', req), 5987 timeout=t) 5988 except Exception as e: 5989 if self.parent.shouldRetry(tries, e, deadline): 5990 tries += 1 5991 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5992 continue 5993 raise plumbing.convert_error_to_porcelain(e) from e 5994 break 5995 5996 resp = models.ProxyClusterKeyDeleteResponse() 5997 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 5998 plumbing_response.meta) 5999 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6000 plumbing_response.rate_limit) 6001 return resp 6002 6003 def list(self, filter, *args, timeout=None): 6004 ''' 6005 List gets a list of ProxyClusterKeys matching a given set of criteria. 6006 ''' 6007 deadline = None if timeout is None else time.time() + timeout 6008 req = ProxyClusterKeyListRequest() 6009 req.meta.CopyFrom(ListRequestMetadata()) 6010 if self.parent.page_limit > 0: 6011 req.meta.limit = self.parent.page_limit 6012 if self.parent.snapshot_datetime is not None: 6013 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6014 6015 req.filter = plumbing.quote_filter_args(filter, *args) 6016 6017 def generator(svc, req): 6018 tries = 0 6019 while True: 6020 t = None if deadline is None else deadline - time.time() 6021 try: 6022 plumbing_response = svc.stub.List( 6023 req, 6024 metadata=svc.parent.get_metadata( 6025 'ProxyClusterKeys.List', req), 6026 timeout=t) 6027 except Exception as e: 6028 if self.parent.shouldRetry(tries, e, deadline): 6029 tries += 1 6030 time.sleep( 6031 self.parent.exponentialBackoff(tries, deadline)) 6032 continue 6033 raise plumbing.convert_error_to_porcelain(e) from e 6034 tries = 0 6035 for plumbing_item in plumbing_response.proxy_cluster_keys: 6036 yield plumbing.convert_proxy_cluster_key_to_porcelain( 6037 plumbing_item) 6038 if plumbing_response.meta.next_cursor == '': 6039 break 6040 req.meta.cursor = plumbing_response.meta.next_cursor 6041 6042 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)
5893 def create(self, proxy_cluster_key, timeout=None): 5894 ''' 5895 Create registers a new ProxyClusterKey. 5896 ''' 5897 deadline = None if timeout is None else time.time() + timeout 5898 req = ProxyClusterKeyCreateRequest() 5899 5900 if proxy_cluster_key is not None: 5901 req.proxy_cluster_key.CopyFrom( 5902 plumbing.convert_proxy_cluster_key_to_plumbing( 5903 proxy_cluster_key)) 5904 tries = 0 5905 plumbing_response = None 5906 while True: 5907 t = None if deadline is None else deadline - time.time() 5908 try: 5909 plumbing_response = self.stub.Create( 5910 req, 5911 metadata=self.parent.get_metadata( 5912 'ProxyClusterKeys.Create', req), 5913 timeout=t) 5914 except Exception as e: 5915 if self.parent.shouldRetry(tries, e, deadline): 5916 tries += 1 5917 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5918 continue 5919 raise plumbing.convert_error_to_porcelain(e) from e 5920 break 5921 5922 resp = models.ProxyClusterKeyCreateResponse() 5923 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5924 plumbing_response.meta) 5925 resp.proxy_cluster_key = plumbing.convert_proxy_cluster_key_to_porcelain( 5926 plumbing_response.proxy_cluster_key) 5927 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5928 plumbing_response.rate_limit) 5929 resp.secret_key = (plumbing_response.secret_key) 5930 return resp
Create registers a new ProxyClusterKey.
def
get(self, id, timeout=None)
5932 def get(self, id, timeout=None): 5933 ''' 5934 Get reads one ProxyClusterKey by ID. 5935 ''' 5936 deadline = None if timeout is None else time.time() + timeout 5937 req = ProxyClusterKeyGetRequest() 5938 if self.parent.snapshot_datetime is not None: 5939 req.meta.CopyFrom(GetRequestMetadata()) 5940 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5941 5942 req.id = (id) 5943 tries = 0 5944 plumbing_response = None 5945 while True: 5946 t = None if deadline is None else deadline - time.time() 5947 try: 5948 plumbing_response = self.stub.Get( 5949 req, 5950 metadata=self.parent.get_metadata('ProxyClusterKeys.Get', 5951 req), 5952 timeout=t) 5953 except Exception as e: 5954 if self.parent.shouldRetry(tries, e, deadline): 5955 tries += 1 5956 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5957 continue 5958 raise plumbing.convert_error_to_porcelain(e) from e 5959 break 5960 5961 resp = models.ProxyClusterKeyGetResponse() 5962 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5963 plumbing_response.meta) 5964 resp.proxy_cluster_key = plumbing.convert_proxy_cluster_key_to_porcelain( 5965 plumbing_response.proxy_cluster_key) 5966 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5967 plumbing_response.rate_limit) 5968 return resp
Get reads one ProxyClusterKey by ID.
def
delete(self, id, timeout=None)
5970 def delete(self, id, timeout=None): 5971 ''' 5972 Delete removes a ProxyClusterKey by ID. 5973 ''' 5974 deadline = None if timeout is None else time.time() + timeout 5975 req = ProxyClusterKeyDeleteRequest() 5976 5977 req.id = (id) 5978 tries = 0 5979 plumbing_response = None 5980 while True: 5981 t = None if deadline is None else deadline - time.time() 5982 try: 5983 plumbing_response = self.stub.Delete( 5984 req, 5985 metadata=self.parent.get_metadata( 5986 'ProxyClusterKeys.Delete', req), 5987 timeout=t) 5988 except Exception as e: 5989 if self.parent.shouldRetry(tries, e, deadline): 5990 tries += 1 5991 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5992 continue 5993 raise plumbing.convert_error_to_porcelain(e) from e 5994 break 5995 5996 resp = models.ProxyClusterKeyDeleteResponse() 5997 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 5998 plumbing_response.meta) 5999 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6000 plumbing_response.rate_limit) 6001 return resp
Delete removes a ProxyClusterKey by ID.
def
list(self, filter, *args, timeout=None)
6003 def list(self, filter, *args, timeout=None): 6004 ''' 6005 List gets a list of ProxyClusterKeys matching a given set of criteria. 6006 ''' 6007 deadline = None if timeout is None else time.time() + timeout 6008 req = ProxyClusterKeyListRequest() 6009 req.meta.CopyFrom(ListRequestMetadata()) 6010 if self.parent.page_limit > 0: 6011 req.meta.limit = self.parent.page_limit 6012 if self.parent.snapshot_datetime is not None: 6013 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6014 6015 req.filter = plumbing.quote_filter_args(filter, *args) 6016 6017 def generator(svc, req): 6018 tries = 0 6019 while True: 6020 t = None if deadline is None else deadline - time.time() 6021 try: 6022 plumbing_response = svc.stub.List( 6023 req, 6024 metadata=svc.parent.get_metadata( 6025 'ProxyClusterKeys.List', req), 6026 timeout=t) 6027 except Exception as e: 6028 if self.parent.shouldRetry(tries, e, deadline): 6029 tries += 1 6030 time.sleep( 6031 self.parent.exponentialBackoff(tries, deadline)) 6032 continue 6033 raise plumbing.convert_error_to_porcelain(e) from e 6034 tries = 0 6035 for plumbing_item in plumbing_response.proxy_cluster_keys: 6036 yield plumbing.convert_proxy_cluster_key_to_porcelain( 6037 plumbing_item) 6038 if plumbing_response.meta.next_cursor == '': 6039 break 6040 req.meta.cursor = plumbing_response.meta.next_cursor 6041 6042 return generator(self, req)
List gets a list of ProxyClusterKeys matching a given set of criteria.
class
SnapshotProxyClusterKeys:
6045class SnapshotProxyClusterKeys: 6046 ''' 6047 SnapshotProxyClusterKeys exposes the read only methods of the ProxyClusterKeys 6048 service for historical queries. 6049 ''' 6050 def __init__(self, proxy_cluster_keys): 6051 self.proxy_cluster_keys = proxy_cluster_keys 6052 6053 def get(self, id, timeout=None): 6054 ''' 6055 Get reads one ProxyClusterKey by ID. 6056 ''' 6057 return self.proxy_cluster_keys.get(id, timeout=timeout) 6058 6059 def list(self, filter, *args, timeout=None): 6060 ''' 6061 List gets a list of ProxyClusterKeys matching a given set of criteria. 6062 ''' 6063 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)
6053 def get(self, id, timeout=None): 6054 ''' 6055 Get reads one ProxyClusterKey by ID. 6056 ''' 6057 return self.proxy_cluster_keys.get(id, timeout=timeout)
Get reads one ProxyClusterKey by ID.
def
list(self, filter, *args, timeout=None)
6059 def list(self, filter, *args, timeout=None): 6060 ''' 6061 List gets a list of ProxyClusterKeys matching a given set of criteria. 6062 ''' 6063 return self.proxy_cluster_keys.list(filter, *args, timeout=timeout)
List gets a list of ProxyClusterKeys matching a given set of criteria.
class
Queries:
6066class Queries: 6067 ''' 6068 A Query is a record of a single client request to a resource, such as a SQL query. 6069 Long-running SSH, RDP, or Kubernetes interactive sessions also count as queries. 6070 The Queries service is read-only. 6071 See `strongdm.models.Query`. 6072 ''' 6073 def __init__(self, channel, client): 6074 self.parent = client 6075 self.stub = QueriesStub(channel) 6076 6077 def list(self, filter, *args, timeout=None): 6078 ''' 6079 List gets a list of Queries matching a given set of criteria. 6080 ''' 6081 deadline = None if timeout is None else time.time() + timeout 6082 req = QueryListRequest() 6083 req.meta.CopyFrom(ListRequestMetadata()) 6084 if self.parent.page_limit > 0: 6085 req.meta.limit = self.parent.page_limit 6086 if self.parent.snapshot_datetime is not None: 6087 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6088 6089 req.filter = plumbing.quote_filter_args(filter, *args) 6090 6091 def generator(svc, req): 6092 tries = 0 6093 while True: 6094 t = None if deadline is None else deadline - time.time() 6095 try: 6096 plumbing_response = svc.stub.List( 6097 req, 6098 metadata=svc.parent.get_metadata('Queries.List', req), 6099 timeout=t) 6100 except Exception as e: 6101 if self.parent.shouldRetry(tries, e, deadline): 6102 tries += 1 6103 time.sleep( 6104 self.parent.exponentialBackoff(tries, deadline)) 6105 continue 6106 raise plumbing.convert_error_to_porcelain(e) from e 6107 tries = 0 6108 for plumbing_item in plumbing_response.queries: 6109 yield plumbing.convert_query_to_porcelain(plumbing_item) 6110 if plumbing_response.meta.next_cursor == '': 6111 break 6112 req.meta.cursor = plumbing_response.meta.next_cursor 6113 6114 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)
6077 def list(self, filter, *args, timeout=None): 6078 ''' 6079 List gets a list of Queries matching a given set of criteria. 6080 ''' 6081 deadline = None if timeout is None else time.time() + timeout 6082 req = QueryListRequest() 6083 req.meta.CopyFrom(ListRequestMetadata()) 6084 if self.parent.page_limit > 0: 6085 req.meta.limit = self.parent.page_limit 6086 if self.parent.snapshot_datetime is not None: 6087 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6088 6089 req.filter = plumbing.quote_filter_args(filter, *args) 6090 6091 def generator(svc, req): 6092 tries = 0 6093 while True: 6094 t = None if deadline is None else deadline - time.time() 6095 try: 6096 plumbing_response = svc.stub.List( 6097 req, 6098 metadata=svc.parent.get_metadata('Queries.List', req), 6099 timeout=t) 6100 except Exception as e: 6101 if self.parent.shouldRetry(tries, e, deadline): 6102 tries += 1 6103 time.sleep( 6104 self.parent.exponentialBackoff(tries, deadline)) 6105 continue 6106 raise plumbing.convert_error_to_porcelain(e) from e 6107 tries = 0 6108 for plumbing_item in plumbing_response.queries: 6109 yield plumbing.convert_query_to_porcelain(plumbing_item) 6110 if plumbing_response.meta.next_cursor == '': 6111 break 6112 req.meta.cursor = plumbing_response.meta.next_cursor 6113 6114 return generator(self, req)
List gets a list of Queries matching a given set of criteria.
class
RemoteIdentities:
6117class RemoteIdentities: 6118 ''' 6119 RemoteIdentities assign a resource directly to an account, giving the account the permission to connect to that resource. 6120 See `strongdm.models.RemoteIdentity`. 6121 ''' 6122 def __init__(self, channel, client): 6123 self.parent = client 6124 self.stub = RemoteIdentitiesStub(channel) 6125 6126 def create(self, remote_identity, timeout=None): 6127 ''' 6128 Create registers a new RemoteIdentity. 6129 ''' 6130 deadline = None if timeout is None else time.time() + timeout 6131 req = RemoteIdentityCreateRequest() 6132 6133 if remote_identity is not None: 6134 req.remote_identity.CopyFrom( 6135 plumbing.convert_remote_identity_to_plumbing(remote_identity)) 6136 tries = 0 6137 plumbing_response = None 6138 while True: 6139 t = None if deadline is None else deadline - time.time() 6140 try: 6141 plumbing_response = self.stub.Create( 6142 req, 6143 metadata=self.parent.get_metadata( 6144 'RemoteIdentities.Create', req), 6145 timeout=t) 6146 except Exception as e: 6147 if self.parent.shouldRetry(tries, e, deadline): 6148 tries += 1 6149 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6150 continue 6151 raise plumbing.convert_error_to_porcelain(e) from e 6152 break 6153 6154 resp = models.RemoteIdentityCreateResponse() 6155 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 6156 plumbing_response.meta) 6157 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6158 plumbing_response.rate_limit) 6159 resp.remote_identity = plumbing.convert_remote_identity_to_porcelain( 6160 plumbing_response.remote_identity) 6161 return resp 6162 6163 def get(self, id, timeout=None): 6164 ''' 6165 Get reads one RemoteIdentity by ID. 6166 ''' 6167 deadline = None if timeout is None else time.time() + timeout 6168 req = RemoteIdentityGetRequest() 6169 if self.parent.snapshot_datetime is not None: 6170 req.meta.CopyFrom(GetRequestMetadata()) 6171 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6172 6173 req.id = (id) 6174 tries = 0 6175 plumbing_response = None 6176 while True: 6177 t = None if deadline is None else deadline - time.time() 6178 try: 6179 plumbing_response = self.stub.Get( 6180 req, 6181 metadata=self.parent.get_metadata('RemoteIdentities.Get', 6182 req), 6183 timeout=t) 6184 except Exception as e: 6185 if self.parent.shouldRetry(tries, e, deadline): 6186 tries += 1 6187 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6188 continue 6189 raise plumbing.convert_error_to_porcelain(e) from e 6190 break 6191 6192 resp = models.RemoteIdentityGetResponse() 6193 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 6194 plumbing_response.meta) 6195 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6196 plumbing_response.rate_limit) 6197 resp.remote_identity = plumbing.convert_remote_identity_to_porcelain( 6198 plumbing_response.remote_identity) 6199 return resp 6200 6201 def update(self, remote_identity, timeout=None): 6202 ''' 6203 Update replaces all the fields of a RemoteIdentity by ID. 6204 ''' 6205 deadline = None if timeout is None else time.time() + timeout 6206 req = RemoteIdentityUpdateRequest() 6207 6208 if remote_identity is not None: 6209 req.remote_identity.CopyFrom( 6210 plumbing.convert_remote_identity_to_plumbing(remote_identity)) 6211 tries = 0 6212 plumbing_response = None 6213 while True: 6214 t = None if deadline is None else deadline - time.time() 6215 try: 6216 plumbing_response = self.stub.Update( 6217 req, 6218 metadata=self.parent.get_metadata( 6219 'RemoteIdentities.Update', req), 6220 timeout=t) 6221 except Exception as e: 6222 if self.parent.shouldRetry(tries, e, deadline): 6223 tries += 1 6224 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6225 continue 6226 raise plumbing.convert_error_to_porcelain(e) from e 6227 break 6228 6229 resp = models.RemoteIdentityUpdateResponse() 6230 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 6231 plumbing_response.meta) 6232 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6233 plumbing_response.rate_limit) 6234 resp.remote_identity = plumbing.convert_remote_identity_to_porcelain( 6235 plumbing_response.remote_identity) 6236 return resp 6237 6238 def delete(self, id, timeout=None): 6239 ''' 6240 Delete removes a RemoteIdentity by ID. 6241 ''' 6242 deadline = None if timeout is None else time.time() + timeout 6243 req = RemoteIdentityDeleteRequest() 6244 6245 req.id = (id) 6246 tries = 0 6247 plumbing_response = None 6248 while True: 6249 t = None if deadline is None else deadline - time.time() 6250 try: 6251 plumbing_response = self.stub.Delete( 6252 req, 6253 metadata=self.parent.get_metadata( 6254 'RemoteIdentities.Delete', req), 6255 timeout=t) 6256 except Exception as e: 6257 if self.parent.shouldRetry(tries, e, deadline): 6258 tries += 1 6259 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6260 continue 6261 raise plumbing.convert_error_to_porcelain(e) from e 6262 break 6263 6264 resp = models.RemoteIdentityDeleteResponse() 6265 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 6266 plumbing_response.meta) 6267 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6268 plumbing_response.rate_limit) 6269 return resp 6270 6271 def list(self, filter, *args, timeout=None): 6272 ''' 6273 List gets a list of RemoteIdentities matching a given set of criteria. 6274 ''' 6275 deadline = None if timeout is None else time.time() + timeout 6276 req = RemoteIdentityListRequest() 6277 req.meta.CopyFrom(ListRequestMetadata()) 6278 if self.parent.page_limit > 0: 6279 req.meta.limit = self.parent.page_limit 6280 if self.parent.snapshot_datetime is not None: 6281 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6282 6283 req.filter = plumbing.quote_filter_args(filter, *args) 6284 6285 def generator(svc, req): 6286 tries = 0 6287 while True: 6288 t = None if deadline is None else deadline - time.time() 6289 try: 6290 plumbing_response = svc.stub.List( 6291 req, 6292 metadata=svc.parent.get_metadata( 6293 'RemoteIdentities.List', req), 6294 timeout=t) 6295 except Exception as e: 6296 if self.parent.shouldRetry(tries, e, deadline): 6297 tries += 1 6298 time.sleep( 6299 self.parent.exponentialBackoff(tries, deadline)) 6300 continue 6301 raise plumbing.convert_error_to_porcelain(e) from e 6302 tries = 0 6303 for plumbing_item in plumbing_response.remote_identities: 6304 yield plumbing.convert_remote_identity_to_porcelain( 6305 plumbing_item) 6306 if plumbing_response.meta.next_cursor == '': 6307 break 6308 req.meta.cursor = plumbing_response.meta.next_cursor 6309 6310 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)
6126 def create(self, remote_identity, timeout=None): 6127 ''' 6128 Create registers a new RemoteIdentity. 6129 ''' 6130 deadline = None if timeout is None else time.time() + timeout 6131 req = RemoteIdentityCreateRequest() 6132 6133 if remote_identity is not None: 6134 req.remote_identity.CopyFrom( 6135 plumbing.convert_remote_identity_to_plumbing(remote_identity)) 6136 tries = 0 6137 plumbing_response = None 6138 while True: 6139 t = None if deadline is None else deadline - time.time() 6140 try: 6141 plumbing_response = self.stub.Create( 6142 req, 6143 metadata=self.parent.get_metadata( 6144 'RemoteIdentities.Create', req), 6145 timeout=t) 6146 except Exception as e: 6147 if self.parent.shouldRetry(tries, e, deadline): 6148 tries += 1 6149 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6150 continue 6151 raise plumbing.convert_error_to_porcelain(e) from e 6152 break 6153 6154 resp = models.RemoteIdentityCreateResponse() 6155 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 6156 plumbing_response.meta) 6157 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6158 plumbing_response.rate_limit) 6159 resp.remote_identity = plumbing.convert_remote_identity_to_porcelain( 6160 plumbing_response.remote_identity) 6161 return resp
Create registers a new RemoteIdentity.
def
get(self, id, timeout=None)
6163 def get(self, id, timeout=None): 6164 ''' 6165 Get reads one RemoteIdentity by ID. 6166 ''' 6167 deadline = None if timeout is None else time.time() + timeout 6168 req = RemoteIdentityGetRequest() 6169 if self.parent.snapshot_datetime is not None: 6170 req.meta.CopyFrom(GetRequestMetadata()) 6171 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6172 6173 req.id = (id) 6174 tries = 0 6175 plumbing_response = None 6176 while True: 6177 t = None if deadline is None else deadline - time.time() 6178 try: 6179 plumbing_response = self.stub.Get( 6180 req, 6181 metadata=self.parent.get_metadata('RemoteIdentities.Get', 6182 req), 6183 timeout=t) 6184 except Exception as e: 6185 if self.parent.shouldRetry(tries, e, deadline): 6186 tries += 1 6187 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6188 continue 6189 raise plumbing.convert_error_to_porcelain(e) from e 6190 break 6191 6192 resp = models.RemoteIdentityGetResponse() 6193 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 6194 plumbing_response.meta) 6195 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6196 plumbing_response.rate_limit) 6197 resp.remote_identity = plumbing.convert_remote_identity_to_porcelain( 6198 plumbing_response.remote_identity) 6199 return resp
Get reads one RemoteIdentity by ID.
def
update(self, remote_identity, timeout=None)
6201 def update(self, remote_identity, timeout=None): 6202 ''' 6203 Update replaces all the fields of a RemoteIdentity by ID. 6204 ''' 6205 deadline = None if timeout is None else time.time() + timeout 6206 req = RemoteIdentityUpdateRequest() 6207 6208 if remote_identity is not None: 6209 req.remote_identity.CopyFrom( 6210 plumbing.convert_remote_identity_to_plumbing(remote_identity)) 6211 tries = 0 6212 plumbing_response = None 6213 while True: 6214 t = None if deadline is None else deadline - time.time() 6215 try: 6216 plumbing_response = self.stub.Update( 6217 req, 6218 metadata=self.parent.get_metadata( 6219 'RemoteIdentities.Update', req), 6220 timeout=t) 6221 except Exception as e: 6222 if self.parent.shouldRetry(tries, e, deadline): 6223 tries += 1 6224 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6225 continue 6226 raise plumbing.convert_error_to_porcelain(e) from e 6227 break 6228 6229 resp = models.RemoteIdentityUpdateResponse() 6230 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 6231 plumbing_response.meta) 6232 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6233 plumbing_response.rate_limit) 6234 resp.remote_identity = plumbing.convert_remote_identity_to_porcelain( 6235 plumbing_response.remote_identity) 6236 return resp
Update replaces all the fields of a RemoteIdentity by ID.
def
delete(self, id, timeout=None)
6238 def delete(self, id, timeout=None): 6239 ''' 6240 Delete removes a RemoteIdentity by ID. 6241 ''' 6242 deadline = None if timeout is None else time.time() + timeout 6243 req = RemoteIdentityDeleteRequest() 6244 6245 req.id = (id) 6246 tries = 0 6247 plumbing_response = None 6248 while True: 6249 t = None if deadline is None else deadline - time.time() 6250 try: 6251 plumbing_response = self.stub.Delete( 6252 req, 6253 metadata=self.parent.get_metadata( 6254 'RemoteIdentities.Delete', req), 6255 timeout=t) 6256 except Exception as e: 6257 if self.parent.shouldRetry(tries, e, deadline): 6258 tries += 1 6259 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6260 continue 6261 raise plumbing.convert_error_to_porcelain(e) from e 6262 break 6263 6264 resp = models.RemoteIdentityDeleteResponse() 6265 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 6266 plumbing_response.meta) 6267 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6268 plumbing_response.rate_limit) 6269 return resp
Delete removes a RemoteIdentity by ID.
def
list(self, filter, *args, timeout=None)
6271 def list(self, filter, *args, timeout=None): 6272 ''' 6273 List gets a list of RemoteIdentities matching a given set of criteria. 6274 ''' 6275 deadline = None if timeout is None else time.time() + timeout 6276 req = RemoteIdentityListRequest() 6277 req.meta.CopyFrom(ListRequestMetadata()) 6278 if self.parent.page_limit > 0: 6279 req.meta.limit = self.parent.page_limit 6280 if self.parent.snapshot_datetime is not None: 6281 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6282 6283 req.filter = plumbing.quote_filter_args(filter, *args) 6284 6285 def generator(svc, req): 6286 tries = 0 6287 while True: 6288 t = None if deadline is None else deadline - time.time() 6289 try: 6290 plumbing_response = svc.stub.List( 6291 req, 6292 metadata=svc.parent.get_metadata( 6293 'RemoteIdentities.List', req), 6294 timeout=t) 6295 except Exception as e: 6296 if self.parent.shouldRetry(tries, e, deadline): 6297 tries += 1 6298 time.sleep( 6299 self.parent.exponentialBackoff(tries, deadline)) 6300 continue 6301 raise plumbing.convert_error_to_porcelain(e) from e 6302 tries = 0 6303 for plumbing_item in plumbing_response.remote_identities: 6304 yield plumbing.convert_remote_identity_to_porcelain( 6305 plumbing_item) 6306 if plumbing_response.meta.next_cursor == '': 6307 break 6308 req.meta.cursor = plumbing_response.meta.next_cursor 6309 6310 return generator(self, req)
List gets a list of RemoteIdentities matching a given set of criteria.
class
SnapshotRemoteIdentities:
6313class SnapshotRemoteIdentities: 6314 ''' 6315 SnapshotRemoteIdentities exposes the read only methods of the RemoteIdentities 6316 service for historical queries. 6317 ''' 6318 def __init__(self, remote_identities): 6319 self.remote_identities = remote_identities 6320 6321 def get(self, id, timeout=None): 6322 ''' 6323 Get reads one RemoteIdentity by ID. 6324 ''' 6325 return self.remote_identities.get(id, timeout=timeout) 6326 6327 def list(self, filter, *args, timeout=None): 6328 ''' 6329 List gets a list of RemoteIdentities matching a given set of criteria. 6330 ''' 6331 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)
6321 def get(self, id, timeout=None): 6322 ''' 6323 Get reads one RemoteIdentity by ID. 6324 ''' 6325 return self.remote_identities.get(id, timeout=timeout)
Get reads one RemoteIdentity by ID.
def
list(self, filter, *args, timeout=None)
6327 def list(self, filter, *args, timeout=None): 6328 ''' 6329 List gets a list of RemoteIdentities matching a given set of criteria. 6330 ''' 6331 return self.remote_identities.list(filter, *args, timeout=timeout)
List gets a list of RemoteIdentities matching a given set of criteria.
class
RemoteIdentitiesHistory:
6334class RemoteIdentitiesHistory: 6335 ''' 6336 RemoteIdentitiesHistory records all changes to the state of a RemoteIdentity. 6337 See `strongdm.models.RemoteIdentityHistory`. 6338 ''' 6339 def __init__(self, channel, client): 6340 self.parent = client 6341 self.stub = RemoteIdentitiesHistoryStub(channel) 6342 6343 def list(self, filter, *args, timeout=None): 6344 ''' 6345 List gets a list of RemoteIdentityHistory records matching a given set of criteria. 6346 ''' 6347 deadline = None if timeout is None else time.time() + timeout 6348 req = RemoteIdentityHistoryListRequest() 6349 req.meta.CopyFrom(ListRequestMetadata()) 6350 if self.parent.page_limit > 0: 6351 req.meta.limit = self.parent.page_limit 6352 if self.parent.snapshot_datetime is not None: 6353 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6354 6355 req.filter = plumbing.quote_filter_args(filter, *args) 6356 6357 def generator(svc, req): 6358 tries = 0 6359 while True: 6360 t = None if deadline is None else deadline - time.time() 6361 try: 6362 plumbing_response = svc.stub.List( 6363 req, 6364 metadata=svc.parent.get_metadata( 6365 'RemoteIdentitiesHistory.List', req), 6366 timeout=t) 6367 except Exception as e: 6368 if self.parent.shouldRetry(tries, e, deadline): 6369 tries += 1 6370 time.sleep( 6371 self.parent.exponentialBackoff(tries, deadline)) 6372 continue 6373 raise plumbing.convert_error_to_porcelain(e) from e 6374 tries = 0 6375 for plumbing_item in plumbing_response.history: 6376 yield plumbing.convert_remote_identity_history_to_porcelain( 6377 plumbing_item) 6378 if plumbing_response.meta.next_cursor == '': 6379 break 6380 req.meta.cursor = plumbing_response.meta.next_cursor 6381 6382 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)
6343 def list(self, filter, *args, timeout=None): 6344 ''' 6345 List gets a list of RemoteIdentityHistory records matching a given set of criteria. 6346 ''' 6347 deadline = None if timeout is None else time.time() + timeout 6348 req = RemoteIdentityHistoryListRequest() 6349 req.meta.CopyFrom(ListRequestMetadata()) 6350 if self.parent.page_limit > 0: 6351 req.meta.limit = self.parent.page_limit 6352 if self.parent.snapshot_datetime is not None: 6353 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6354 6355 req.filter = plumbing.quote_filter_args(filter, *args) 6356 6357 def generator(svc, req): 6358 tries = 0 6359 while True: 6360 t = None if deadline is None else deadline - time.time() 6361 try: 6362 plumbing_response = svc.stub.List( 6363 req, 6364 metadata=svc.parent.get_metadata( 6365 'RemoteIdentitiesHistory.List', req), 6366 timeout=t) 6367 except Exception as e: 6368 if self.parent.shouldRetry(tries, e, deadline): 6369 tries += 1 6370 time.sleep( 6371 self.parent.exponentialBackoff(tries, deadline)) 6372 continue 6373 raise plumbing.convert_error_to_porcelain(e) from e 6374 tries = 0 6375 for plumbing_item in plumbing_response.history: 6376 yield plumbing.convert_remote_identity_history_to_porcelain( 6377 plumbing_item) 6378 if plumbing_response.meta.next_cursor == '': 6379 break 6380 req.meta.cursor = plumbing_response.meta.next_cursor 6381 6382 return generator(self, req)
List gets a list of RemoteIdentityHistory records matching a given set of criteria.
class
RemoteIdentityGroups:
6385class RemoteIdentityGroups: 6386 ''' 6387 A RemoteIdentityGroup is a named grouping of Remote Identities for Accounts. 6388 An Account's relationship to a RemoteIdentityGroup is defined via RemoteIdentity objects. 6389 See `strongdm.models.RemoteIdentityGroup`. 6390 ''' 6391 def __init__(self, channel, client): 6392 self.parent = client 6393 self.stub = RemoteIdentityGroupsStub(channel) 6394 6395 def get(self, id, timeout=None): 6396 ''' 6397 Get reads one RemoteIdentityGroup by ID. 6398 ''' 6399 deadline = None if timeout is None else time.time() + timeout 6400 req = RemoteIdentityGroupGetRequest() 6401 if self.parent.snapshot_datetime is not None: 6402 req.meta.CopyFrom(GetRequestMetadata()) 6403 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6404 6405 req.id = (id) 6406 tries = 0 6407 plumbing_response = None 6408 while True: 6409 t = None if deadline is None else deadline - time.time() 6410 try: 6411 plumbing_response = self.stub.Get( 6412 req, 6413 metadata=self.parent.get_metadata( 6414 'RemoteIdentityGroups.Get', req), 6415 timeout=t) 6416 except Exception as e: 6417 if self.parent.shouldRetry(tries, e, deadline): 6418 tries += 1 6419 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6420 continue 6421 raise plumbing.convert_error_to_porcelain(e) from e 6422 break 6423 6424 resp = models.RemoteIdentityGroupGetResponse() 6425 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 6426 plumbing_response.meta) 6427 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6428 plumbing_response.rate_limit) 6429 resp.remote_identity_group = plumbing.convert_remote_identity_group_to_porcelain( 6430 plumbing_response.remote_identity_group) 6431 return resp 6432 6433 def list(self, filter, *args, timeout=None): 6434 ''' 6435 List gets a list of RemoteIdentityGroups matching a given set of criteria. 6436 ''' 6437 deadline = None if timeout is None else time.time() + timeout 6438 req = RemoteIdentityGroupListRequest() 6439 req.meta.CopyFrom(ListRequestMetadata()) 6440 if self.parent.page_limit > 0: 6441 req.meta.limit = self.parent.page_limit 6442 if self.parent.snapshot_datetime is not None: 6443 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6444 6445 req.filter = plumbing.quote_filter_args(filter, *args) 6446 6447 def generator(svc, req): 6448 tries = 0 6449 while True: 6450 t = None if deadline is None else deadline - time.time() 6451 try: 6452 plumbing_response = svc.stub.List( 6453 req, 6454 metadata=svc.parent.get_metadata( 6455 'RemoteIdentityGroups.List', req), 6456 timeout=t) 6457 except Exception as e: 6458 if self.parent.shouldRetry(tries, e, deadline): 6459 tries += 1 6460 time.sleep( 6461 self.parent.exponentialBackoff(tries, deadline)) 6462 continue 6463 raise plumbing.convert_error_to_porcelain(e) from e 6464 tries = 0 6465 for plumbing_item in plumbing_response.remote_identity_groups: 6466 yield plumbing.convert_remote_identity_group_to_porcelain( 6467 plumbing_item) 6468 if plumbing_response.meta.next_cursor == '': 6469 break 6470 req.meta.cursor = plumbing_response.meta.next_cursor 6471 6472 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)
6395 def get(self, id, timeout=None): 6396 ''' 6397 Get reads one RemoteIdentityGroup by ID. 6398 ''' 6399 deadline = None if timeout is None else time.time() + timeout 6400 req = RemoteIdentityGroupGetRequest() 6401 if self.parent.snapshot_datetime is not None: 6402 req.meta.CopyFrom(GetRequestMetadata()) 6403 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6404 6405 req.id = (id) 6406 tries = 0 6407 plumbing_response = None 6408 while True: 6409 t = None if deadline is None else deadline - time.time() 6410 try: 6411 plumbing_response = self.stub.Get( 6412 req, 6413 metadata=self.parent.get_metadata( 6414 'RemoteIdentityGroups.Get', req), 6415 timeout=t) 6416 except Exception as e: 6417 if self.parent.shouldRetry(tries, e, deadline): 6418 tries += 1 6419 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6420 continue 6421 raise plumbing.convert_error_to_porcelain(e) from e 6422 break 6423 6424 resp = models.RemoteIdentityGroupGetResponse() 6425 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 6426 plumbing_response.meta) 6427 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6428 plumbing_response.rate_limit) 6429 resp.remote_identity_group = plumbing.convert_remote_identity_group_to_porcelain( 6430 plumbing_response.remote_identity_group) 6431 return resp
Get reads one RemoteIdentityGroup by ID.
def
list(self, filter, *args, timeout=None)
6433 def list(self, filter, *args, timeout=None): 6434 ''' 6435 List gets a list of RemoteIdentityGroups matching a given set of criteria. 6436 ''' 6437 deadline = None if timeout is None else time.time() + timeout 6438 req = RemoteIdentityGroupListRequest() 6439 req.meta.CopyFrom(ListRequestMetadata()) 6440 if self.parent.page_limit > 0: 6441 req.meta.limit = self.parent.page_limit 6442 if self.parent.snapshot_datetime is not None: 6443 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6444 6445 req.filter = plumbing.quote_filter_args(filter, *args) 6446 6447 def generator(svc, req): 6448 tries = 0 6449 while True: 6450 t = None if deadline is None else deadline - time.time() 6451 try: 6452 plumbing_response = svc.stub.List( 6453 req, 6454 metadata=svc.parent.get_metadata( 6455 'RemoteIdentityGroups.List', req), 6456 timeout=t) 6457 except Exception as e: 6458 if self.parent.shouldRetry(tries, e, deadline): 6459 tries += 1 6460 time.sleep( 6461 self.parent.exponentialBackoff(tries, deadline)) 6462 continue 6463 raise plumbing.convert_error_to_porcelain(e) from e 6464 tries = 0 6465 for plumbing_item in plumbing_response.remote_identity_groups: 6466 yield plumbing.convert_remote_identity_group_to_porcelain( 6467 plumbing_item) 6468 if plumbing_response.meta.next_cursor == '': 6469 break 6470 req.meta.cursor = plumbing_response.meta.next_cursor 6471 6472 return generator(self, req)
List gets a list of RemoteIdentityGroups matching a given set of criteria.
class
SnapshotRemoteIdentityGroups:
6475class SnapshotRemoteIdentityGroups: 6476 ''' 6477 SnapshotRemoteIdentityGroups exposes the read only methods of the RemoteIdentityGroups 6478 service for historical queries. 6479 ''' 6480 def __init__(self, remote_identity_groups): 6481 self.remote_identity_groups = remote_identity_groups 6482 6483 def get(self, id, timeout=None): 6484 ''' 6485 Get reads one RemoteIdentityGroup by ID. 6486 ''' 6487 return self.remote_identity_groups.get(id, timeout=timeout) 6488 6489 def list(self, filter, *args, timeout=None): 6490 ''' 6491 List gets a list of RemoteIdentityGroups matching a given set of criteria. 6492 ''' 6493 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)
6483 def get(self, id, timeout=None): 6484 ''' 6485 Get reads one RemoteIdentityGroup by ID. 6486 ''' 6487 return self.remote_identity_groups.get(id, timeout=timeout)
Get reads one RemoteIdentityGroup by ID.
def
list(self, filter, *args, timeout=None)
6489 def list(self, filter, *args, timeout=None): 6490 ''' 6491 List gets a list of RemoteIdentityGroups matching a given set of criteria. 6492 ''' 6493 return self.remote_identity_groups.list(filter, *args, timeout=timeout)
List gets a list of RemoteIdentityGroups matching a given set of criteria.
class
RemoteIdentityGroupsHistory:
6496class RemoteIdentityGroupsHistory: 6497 ''' 6498 RemoteIdentityGroupsHistory records all changes to the state of a RemoteIdentityGroup. 6499 See `strongdm.models.RemoteIdentityGroupHistory`. 6500 ''' 6501 def __init__(self, channel, client): 6502 self.parent = client 6503 self.stub = RemoteIdentityGroupsHistoryStub(channel) 6504 6505 def list(self, filter, *args, timeout=None): 6506 ''' 6507 List gets a list of RemoteIdentityGroupHistory records matching a given set of criteria. 6508 ''' 6509 deadline = None if timeout is None else time.time() + timeout 6510 req = RemoteIdentityGroupHistoryListRequest() 6511 req.meta.CopyFrom(ListRequestMetadata()) 6512 if self.parent.page_limit > 0: 6513 req.meta.limit = self.parent.page_limit 6514 if self.parent.snapshot_datetime is not None: 6515 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6516 6517 req.filter = plumbing.quote_filter_args(filter, *args) 6518 6519 def generator(svc, req): 6520 tries = 0 6521 while True: 6522 t = None if deadline is None else deadline - time.time() 6523 try: 6524 plumbing_response = svc.stub.List( 6525 req, 6526 metadata=svc.parent.get_metadata( 6527 'RemoteIdentityGroupsHistory.List', req), 6528 timeout=t) 6529 except Exception as e: 6530 if self.parent.shouldRetry(tries, e, deadline): 6531 tries += 1 6532 time.sleep( 6533 self.parent.exponentialBackoff(tries, deadline)) 6534 continue 6535 raise plumbing.convert_error_to_porcelain(e) from e 6536 tries = 0 6537 for plumbing_item in plumbing_response.history: 6538 yield plumbing.convert_remote_identity_group_history_to_porcelain( 6539 plumbing_item) 6540 if plumbing_response.meta.next_cursor == '': 6541 break 6542 req.meta.cursor = plumbing_response.meta.next_cursor 6543 6544 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)
6505 def list(self, filter, *args, timeout=None): 6506 ''' 6507 List gets a list of RemoteIdentityGroupHistory records matching a given set of criteria. 6508 ''' 6509 deadline = None if timeout is None else time.time() + timeout 6510 req = RemoteIdentityGroupHistoryListRequest() 6511 req.meta.CopyFrom(ListRequestMetadata()) 6512 if self.parent.page_limit > 0: 6513 req.meta.limit = self.parent.page_limit 6514 if self.parent.snapshot_datetime is not None: 6515 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6516 6517 req.filter = plumbing.quote_filter_args(filter, *args) 6518 6519 def generator(svc, req): 6520 tries = 0 6521 while True: 6522 t = None if deadline is None else deadline - time.time() 6523 try: 6524 plumbing_response = svc.stub.List( 6525 req, 6526 metadata=svc.parent.get_metadata( 6527 'RemoteIdentityGroupsHistory.List', req), 6528 timeout=t) 6529 except Exception as e: 6530 if self.parent.shouldRetry(tries, e, deadline): 6531 tries += 1 6532 time.sleep( 6533 self.parent.exponentialBackoff(tries, deadline)) 6534 continue 6535 raise plumbing.convert_error_to_porcelain(e) from e 6536 tries = 0 6537 for plumbing_item in plumbing_response.history: 6538 yield plumbing.convert_remote_identity_group_history_to_porcelain( 6539 plumbing_item) 6540 if plumbing_response.meta.next_cursor == '': 6541 break 6542 req.meta.cursor = plumbing_response.meta.next_cursor 6543 6544 return generator(self, req)
List gets a list of RemoteIdentityGroupHistory records matching a given set of criteria.
class
Replays:
6547class Replays: 6548 ''' 6549 A Replay captures the data transferred over a long-running SSH, RDP, or Kubernetes interactive session 6550 (otherwise referred to as a query). The Replays service is read-only. 6551 See `strongdm.models.ReplayChunk`. 6552 ''' 6553 def __init__(self, channel, client): 6554 self.parent = client 6555 self.stub = ReplaysStub(channel) 6556 6557 def list(self, filter, *args, timeout=None): 6558 ''' 6559 List gets a list of ReplayChunks for the Query ID specified by the filter criteria. 6560 ''' 6561 deadline = None if timeout is None else time.time() + timeout 6562 req = ReplayListRequest() 6563 req.meta.CopyFrom(ListRequestMetadata()) 6564 if self.parent.page_limit > 0: 6565 req.meta.limit = self.parent.page_limit 6566 if self.parent.snapshot_datetime is not None: 6567 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6568 6569 req.filter = plumbing.quote_filter_args(filter, *args) 6570 6571 def generator(svc, req): 6572 tries = 0 6573 while True: 6574 t = None if deadline is None else deadline - time.time() 6575 try: 6576 plumbing_response = svc.stub.List( 6577 req, 6578 metadata=svc.parent.get_metadata('Replays.List', req), 6579 timeout=t) 6580 except Exception as e: 6581 if self.parent.shouldRetry(tries, e, deadline): 6582 tries += 1 6583 time.sleep( 6584 self.parent.exponentialBackoff(tries, deadline)) 6585 continue 6586 raise plumbing.convert_error_to_porcelain(e) from e 6587 tries = 0 6588 for plumbing_item in plumbing_response.chunks: 6589 yield plumbing.convert_replay_chunk_to_porcelain( 6590 plumbing_item) 6591 if plumbing_response.meta.next_cursor == '': 6592 break 6593 req.meta.cursor = plumbing_response.meta.next_cursor 6594 6595 return generator(self, req)
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)
6557 def list(self, filter, *args, timeout=None): 6558 ''' 6559 List gets a list of ReplayChunks for the Query ID specified by the filter criteria. 6560 ''' 6561 deadline = None if timeout is None else time.time() + timeout 6562 req = ReplayListRequest() 6563 req.meta.CopyFrom(ListRequestMetadata()) 6564 if self.parent.page_limit > 0: 6565 req.meta.limit = self.parent.page_limit 6566 if self.parent.snapshot_datetime is not None: 6567 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6568 6569 req.filter = plumbing.quote_filter_args(filter, *args) 6570 6571 def generator(svc, req): 6572 tries = 0 6573 while True: 6574 t = None if deadline is None else deadline - time.time() 6575 try: 6576 plumbing_response = svc.stub.List( 6577 req, 6578 metadata=svc.parent.get_metadata('Replays.List', req), 6579 timeout=t) 6580 except Exception as e: 6581 if self.parent.shouldRetry(tries, e, deadline): 6582 tries += 1 6583 time.sleep( 6584 self.parent.exponentialBackoff(tries, deadline)) 6585 continue 6586 raise plumbing.convert_error_to_porcelain(e) from e 6587 tries = 0 6588 for plumbing_item in plumbing_response.chunks: 6589 yield plumbing.convert_replay_chunk_to_porcelain( 6590 plumbing_item) 6591 if plumbing_response.meta.next_cursor == '': 6592 break 6593 req.meta.cursor = plumbing_response.meta.next_cursor 6594 6595 return generator(self, req)
List gets a list of ReplayChunks for the Query ID specified by the filter criteria.
class
Resources:
6598class Resources: 6599 ''' 6600 Resources are databases, servers, clusters, websites, or clouds that strongDM 6601 delegates access to. 6602 See: 6603 `strongdm.models.Aerospike` 6604 `strongdm.models.AKS` 6605 `strongdm.models.AKSBasicAuth` 6606 `strongdm.models.AKSServiceAccount` 6607 `strongdm.models.AKSServiceAccountUserImpersonation` 6608 `strongdm.models.AKSUserImpersonation` 6609 `strongdm.models.AmazonEKS` 6610 `strongdm.models.AmazonEKSInstanceProfile` 6611 `strongdm.models.AmazonEKSInstanceProfileUserImpersonation` 6612 `strongdm.models.AmazonEKSUserImpersonation` 6613 `strongdm.models.AmazonES` 6614 `strongdm.models.AmazonESIAM` 6615 `strongdm.models.AmazonMQAMQP091` 6616 `strongdm.models.AMQP` 6617 `strongdm.models.Athena` 6618 `strongdm.models.AthenaIAM` 6619 `strongdm.models.AuroraMysql` 6620 `strongdm.models.AuroraMysqlIAM` 6621 `strongdm.models.AuroraPostgres` 6622 `strongdm.models.AuroraPostgresIAM` 6623 `strongdm.models.AWS` 6624 `strongdm.models.AWSConsole` 6625 `strongdm.models.AWSConsoleStaticKeyPair` 6626 `strongdm.models.AWSInstanceProfile` 6627 `strongdm.models.Azure` 6628 `strongdm.models.AzureCertificate` 6629 `strongdm.models.AzureMysql` 6630 `strongdm.models.AzureMysqlManagedIdentity` 6631 `strongdm.models.AzurePostgres` 6632 `strongdm.models.AzurePostgresManagedIdentity` 6633 `strongdm.models.BigQuery` 6634 `strongdm.models.Cassandra` 6635 `strongdm.models.Citus` 6636 `strongdm.models.ClickHouseHTTP` 6637 `strongdm.models.ClickHouseMySQL` 6638 `strongdm.models.ClickHouseTCP` 6639 `strongdm.models.Clustrix` 6640 `strongdm.models.Cockroach` 6641 `strongdm.models.CouchbaseDatabase` 6642 `strongdm.models.CouchbaseWebUI` 6643 `strongdm.models.Databricks` 6644 `strongdm.models.DB2I` 6645 `strongdm.models.DB2LUW` 6646 `strongdm.models.DocumentDBHost` 6647 `strongdm.models.DocumentDBHostIAM` 6648 `strongdm.models.DocumentDBReplicaSet` 6649 `strongdm.models.DocumentDBReplicaSetIAM` 6650 `strongdm.models.Druid` 6651 `strongdm.models.DynamoDB` 6652 `strongdm.models.DynamoDBIAM` 6653 `strongdm.models.Elastic` 6654 `strongdm.models.ElasticacheRedis` 6655 `strongdm.models.ElasticacheRedisIAM` 6656 `strongdm.models.EntraID` 6657 `strongdm.models.GCP` 6658 `strongdm.models.GCPConsole` 6659 `strongdm.models.GCPWIF` 6660 `strongdm.models.GoogleGKE` 6661 `strongdm.models.GoogleGKEUserImpersonation` 6662 `strongdm.models.GoogleSpanner` 6663 `strongdm.models.Greenplum` 6664 `strongdm.models.HTTPAuth` 6665 `strongdm.models.HTTPBasicAuth` 6666 `strongdm.models.HTTPNoAuth` 6667 `strongdm.models.Kubernetes` 6668 `strongdm.models.KubernetesBasicAuth` 6669 `strongdm.models.KubernetesPodIdentity` 6670 `strongdm.models.KubernetesServiceAccount` 6671 `strongdm.models.KubernetesServiceAccountUserImpersonation` 6672 `strongdm.models.KubernetesUserImpersonation` 6673 `strongdm.models.Maria` 6674 `strongdm.models.MCP` 6675 `strongdm.models.MCPDCR` 6676 `strongdm.models.Memcached` 6677 `strongdm.models.Memsql` 6678 `strongdm.models.MongoHost` 6679 `strongdm.models.MongoLegacyHost` 6680 `strongdm.models.MongoLegacyReplicaset` 6681 `strongdm.models.MongoReplicaSet` 6682 `strongdm.models.MongoShardedCluster` 6683 `strongdm.models.MTLSMysql` 6684 `strongdm.models.MTLSPostgres` 6685 `strongdm.models.Mysql` 6686 `strongdm.models.Neptune` 6687 `strongdm.models.NeptuneIAM` 6688 `strongdm.models.OktaGroups` 6689 `strongdm.models.Oracle` 6690 `strongdm.models.OracleNNE` 6691 `strongdm.models.Postgres` 6692 `strongdm.models.Presto` 6693 `strongdm.models.RabbitMQAMQP091` 6694 `strongdm.models.RawTCP` 6695 `strongdm.models.RDP` 6696 `strongdm.models.RDPCert` 6697 `strongdm.models.RDSPostgresIAM` 6698 `strongdm.models.Redis` 6699 `strongdm.models.RedisCluster` 6700 `strongdm.models.Redshift` 6701 `strongdm.models.RedshiftIAM` 6702 `strongdm.models.RedshiftServerlessIAM` 6703 `strongdm.models.SingleStore` 6704 `strongdm.models.Snowflake` 6705 `strongdm.models.Snowsight` 6706 `strongdm.models.SQLServer` 6707 `strongdm.models.SQLServerAzureAD` 6708 `strongdm.models.SQLServerKerberosAD` 6709 `strongdm.models.SSH` 6710 `strongdm.models.SSHCert` 6711 `strongdm.models.SSHCustomerKey` 6712 `strongdm.models.SSHPassword` 6713 `strongdm.models.Sybase` 6714 `strongdm.models.SybaseIQ` 6715 `strongdm.models.Teradata` 6716 `strongdm.models.Trino` 6717 `strongdm.models.Vertica` 6718 ''' 6719 def __init__(self, channel, client): 6720 self.parent = client 6721 self.stub = ResourcesStub(channel) 6722 6723 def enumerate_tags(self, filter, *args, timeout=None): 6724 ''' 6725 EnumerateTags gets a list of the filter matching tags. 6726 ''' 6727 deadline = None if timeout is None else time.time() + timeout 6728 req = EnumerateTagsRequest() 6729 req.meta.CopyFrom(ListRequestMetadata()) 6730 if self.parent.page_limit > 0: 6731 req.meta.limit = self.parent.page_limit 6732 if self.parent.snapshot_datetime is not None: 6733 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6734 6735 req.filter = plumbing.quote_filter_args(filter, *args) 6736 6737 def generator(svc, req): 6738 tries = 0 6739 while True: 6740 t = None if deadline is None else deadline - time.time() 6741 try: 6742 plumbing_response = svc.stub.EnumerateTags( 6743 req, 6744 metadata=svc.parent.get_metadata( 6745 'Resources.EnumerateTags', req), 6746 timeout=t) 6747 except Exception as e: 6748 if self.parent.shouldRetry(tries, e, deadline): 6749 tries += 1 6750 time.sleep( 6751 self.parent.exponentialBackoff(tries, deadline)) 6752 continue 6753 raise plumbing.convert_error_to_porcelain(e) from e 6754 tries = 0 6755 for plumbing_item in plumbing_response.matches: 6756 yield plumbing.convert_tag_to_porcelain(plumbing_item) 6757 if plumbing_response.meta.next_cursor == '': 6758 break 6759 req.meta.cursor = plumbing_response.meta.next_cursor 6760 6761 return generator(self, req) 6762 6763 def create(self, resource, timeout=None): 6764 ''' 6765 Create registers a new Resource. 6766 ''' 6767 deadline = None if timeout is None else time.time() + timeout 6768 req = ResourceCreateRequest() 6769 6770 if resource is not None: 6771 req.resource.CopyFrom( 6772 plumbing.convert_resource_to_plumbing(resource)) 6773 tries = 0 6774 plumbing_response = None 6775 while True: 6776 t = None if deadline is None else deadline - time.time() 6777 try: 6778 plumbing_response = self.stub.Create( 6779 req, 6780 metadata=self.parent.get_metadata('Resources.Create', req), 6781 timeout=t) 6782 except Exception as e: 6783 if self.parent.shouldRetry(tries, e, deadline): 6784 tries += 1 6785 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6786 continue 6787 raise plumbing.convert_error_to_porcelain(e) from e 6788 break 6789 6790 resp = models.ResourceCreateResponse() 6791 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 6792 plumbing_response.meta) 6793 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6794 plumbing_response.rate_limit) 6795 resp.resource = plumbing.convert_resource_to_porcelain( 6796 plumbing_response.resource) 6797 return resp 6798 6799 def get(self, id, timeout=None): 6800 ''' 6801 Get reads one Resource by ID. 6802 ''' 6803 deadline = None if timeout is None else time.time() + timeout 6804 req = ResourceGetRequest() 6805 if self.parent.snapshot_datetime is not None: 6806 req.meta.CopyFrom(GetRequestMetadata()) 6807 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6808 6809 req.id = (id) 6810 tries = 0 6811 plumbing_response = None 6812 while True: 6813 t = None if deadline is None else deadline - time.time() 6814 try: 6815 plumbing_response = self.stub.Get( 6816 req, 6817 metadata=self.parent.get_metadata('Resources.Get', req), 6818 timeout=t) 6819 except Exception as e: 6820 if self.parent.shouldRetry(tries, e, deadline): 6821 tries += 1 6822 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6823 continue 6824 raise plumbing.convert_error_to_porcelain(e) from e 6825 break 6826 6827 resp = models.ResourceGetResponse() 6828 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 6829 plumbing_response.meta) 6830 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6831 plumbing_response.rate_limit) 6832 resp.resource = plumbing.convert_resource_to_porcelain( 6833 plumbing_response.resource) 6834 return resp 6835 6836 def update(self, resource, timeout=None): 6837 ''' 6838 Update replaces all the fields of a Resource by ID. 6839 ''' 6840 deadline = None if timeout is None else time.time() + timeout 6841 req = ResourceUpdateRequest() 6842 6843 if resource is not None: 6844 req.resource.CopyFrom( 6845 plumbing.convert_resource_to_plumbing(resource)) 6846 tries = 0 6847 plumbing_response = None 6848 while True: 6849 t = None if deadline is None else deadline - time.time() 6850 try: 6851 plumbing_response = self.stub.Update( 6852 req, 6853 metadata=self.parent.get_metadata('Resources.Update', req), 6854 timeout=t) 6855 except Exception as e: 6856 if self.parent.shouldRetry(tries, e, deadline): 6857 tries += 1 6858 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6859 continue 6860 raise plumbing.convert_error_to_porcelain(e) from e 6861 break 6862 6863 resp = models.ResourceUpdateResponse() 6864 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 6865 plumbing_response.meta) 6866 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6867 plumbing_response.rate_limit) 6868 resp.resource = plumbing.convert_resource_to_porcelain( 6869 plumbing_response.resource) 6870 return resp 6871 6872 def delete(self, id, timeout=None): 6873 ''' 6874 Delete removes a Resource by ID. 6875 ''' 6876 deadline = None if timeout is None else time.time() + timeout 6877 req = ResourceDeleteRequest() 6878 6879 req.id = (id) 6880 tries = 0 6881 plumbing_response = None 6882 while True: 6883 t = None if deadline is None else deadline - time.time() 6884 try: 6885 plumbing_response = self.stub.Delete( 6886 req, 6887 metadata=self.parent.get_metadata('Resources.Delete', req), 6888 timeout=t) 6889 except Exception as e: 6890 if self.parent.shouldRetry(tries, e, deadline): 6891 tries += 1 6892 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6893 continue 6894 raise plumbing.convert_error_to_porcelain(e) from e 6895 break 6896 6897 resp = models.ResourceDeleteResponse() 6898 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 6899 plumbing_response.meta) 6900 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6901 plumbing_response.rate_limit) 6902 return resp 6903 6904 def list(self, filter, *args, timeout=None): 6905 ''' 6906 List gets a list of Resources matching a given set of criteria. 6907 ''' 6908 deadline = None if timeout is None else time.time() + timeout 6909 req = ResourceListRequest() 6910 req.meta.CopyFrom(ListRequestMetadata()) 6911 if self.parent.page_limit > 0: 6912 req.meta.limit = self.parent.page_limit 6913 if self.parent.snapshot_datetime is not None: 6914 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6915 6916 req.filter = plumbing.quote_filter_args(filter, *args) 6917 6918 def generator(svc, req): 6919 tries = 0 6920 while True: 6921 t = None if deadline is None else deadline - time.time() 6922 try: 6923 plumbing_response = svc.stub.List( 6924 req, 6925 metadata=svc.parent.get_metadata( 6926 'Resources.List', req), 6927 timeout=t) 6928 except Exception as e: 6929 if self.parent.shouldRetry(tries, e, deadline): 6930 tries += 1 6931 time.sleep( 6932 self.parent.exponentialBackoff(tries, deadline)) 6933 continue 6934 raise plumbing.convert_error_to_porcelain(e) from e 6935 tries = 0 6936 for plumbing_item in plumbing_response.resources: 6937 yield plumbing.convert_resource_to_porcelain(plumbing_item) 6938 if plumbing_response.meta.next_cursor == '': 6939 break 6940 req.meta.cursor = plumbing_response.meta.next_cursor 6941 6942 return generator(self, req) 6943 6944 def healthcheck(self, id, timeout=None): 6945 ''' 6946 Healthcheck triggers a remote healthcheck. It may take minutes to propagate across a 6947 large network of Nodes. The call will return immediately, and the updated health of the 6948 Resource can be retrieved via Get or List. 6949 ''' 6950 deadline = None if timeout is None else time.time() + timeout 6951 req = ResourceHealthcheckRequest() 6952 6953 req.id = (id) 6954 tries = 0 6955 plumbing_response = None 6956 while True: 6957 t = None if deadline is None else deadline - time.time() 6958 try: 6959 plumbing_response = self.stub.Healthcheck( 6960 req, 6961 metadata=self.parent.get_metadata('Resources.Healthcheck', 6962 req), 6963 timeout=t) 6964 except Exception as e: 6965 if self.parent.shouldRetry(tries, e, deadline): 6966 tries += 1 6967 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6968 continue 6969 raise plumbing.convert_error_to_porcelain(e) from e 6970 break 6971 6972 resp = models.ResourceHealthcheckResponse() 6973 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 6974 plumbing_response.meta) 6975 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6976 plumbing_response.rate_limit) 6977 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.MCP
strongdm.models.MCPDCR
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)
6763 def create(self, resource, timeout=None): 6764 ''' 6765 Create registers a new Resource. 6766 ''' 6767 deadline = None if timeout is None else time.time() + timeout 6768 req = ResourceCreateRequest() 6769 6770 if resource is not None: 6771 req.resource.CopyFrom( 6772 plumbing.convert_resource_to_plumbing(resource)) 6773 tries = 0 6774 plumbing_response = None 6775 while True: 6776 t = None if deadline is None else deadline - time.time() 6777 try: 6778 plumbing_response = self.stub.Create( 6779 req, 6780 metadata=self.parent.get_metadata('Resources.Create', req), 6781 timeout=t) 6782 except Exception as e: 6783 if self.parent.shouldRetry(tries, e, deadline): 6784 tries += 1 6785 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6786 continue 6787 raise plumbing.convert_error_to_porcelain(e) from e 6788 break 6789 6790 resp = models.ResourceCreateResponse() 6791 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 6792 plumbing_response.meta) 6793 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6794 plumbing_response.rate_limit) 6795 resp.resource = plumbing.convert_resource_to_porcelain( 6796 plumbing_response.resource) 6797 return resp
Create registers a new Resource.
def
get(self, id, timeout=None)
6799 def get(self, id, timeout=None): 6800 ''' 6801 Get reads one Resource by ID. 6802 ''' 6803 deadline = None if timeout is None else time.time() + timeout 6804 req = ResourceGetRequest() 6805 if self.parent.snapshot_datetime is not None: 6806 req.meta.CopyFrom(GetRequestMetadata()) 6807 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6808 6809 req.id = (id) 6810 tries = 0 6811 plumbing_response = None 6812 while True: 6813 t = None if deadline is None else deadline - time.time() 6814 try: 6815 plumbing_response = self.stub.Get( 6816 req, 6817 metadata=self.parent.get_metadata('Resources.Get', req), 6818 timeout=t) 6819 except Exception as e: 6820 if self.parent.shouldRetry(tries, e, deadline): 6821 tries += 1 6822 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6823 continue 6824 raise plumbing.convert_error_to_porcelain(e) from e 6825 break 6826 6827 resp = models.ResourceGetResponse() 6828 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 6829 plumbing_response.meta) 6830 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6831 plumbing_response.rate_limit) 6832 resp.resource = plumbing.convert_resource_to_porcelain( 6833 plumbing_response.resource) 6834 return resp
Get reads one Resource by ID.
def
update(self, resource, timeout=None)
6836 def update(self, resource, timeout=None): 6837 ''' 6838 Update replaces all the fields of a Resource by ID. 6839 ''' 6840 deadline = None if timeout is None else time.time() + timeout 6841 req = ResourceUpdateRequest() 6842 6843 if resource is not None: 6844 req.resource.CopyFrom( 6845 plumbing.convert_resource_to_plumbing(resource)) 6846 tries = 0 6847 plumbing_response = None 6848 while True: 6849 t = None if deadline is None else deadline - time.time() 6850 try: 6851 plumbing_response = self.stub.Update( 6852 req, 6853 metadata=self.parent.get_metadata('Resources.Update', req), 6854 timeout=t) 6855 except Exception as e: 6856 if self.parent.shouldRetry(tries, e, deadline): 6857 tries += 1 6858 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6859 continue 6860 raise plumbing.convert_error_to_porcelain(e) from e 6861 break 6862 6863 resp = models.ResourceUpdateResponse() 6864 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 6865 plumbing_response.meta) 6866 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6867 plumbing_response.rate_limit) 6868 resp.resource = plumbing.convert_resource_to_porcelain( 6869 plumbing_response.resource) 6870 return resp
Update replaces all the fields of a Resource by ID.
def
delete(self, id, timeout=None)
6872 def delete(self, id, timeout=None): 6873 ''' 6874 Delete removes a Resource by ID. 6875 ''' 6876 deadline = None if timeout is None else time.time() + timeout 6877 req = ResourceDeleteRequest() 6878 6879 req.id = (id) 6880 tries = 0 6881 plumbing_response = None 6882 while True: 6883 t = None if deadline is None else deadline - time.time() 6884 try: 6885 plumbing_response = self.stub.Delete( 6886 req, 6887 metadata=self.parent.get_metadata('Resources.Delete', req), 6888 timeout=t) 6889 except Exception as e: 6890 if self.parent.shouldRetry(tries, e, deadline): 6891 tries += 1 6892 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6893 continue 6894 raise plumbing.convert_error_to_porcelain(e) from e 6895 break 6896 6897 resp = models.ResourceDeleteResponse() 6898 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 6899 plumbing_response.meta) 6900 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6901 plumbing_response.rate_limit) 6902 return resp
Delete removes a Resource by ID.
def
list(self, filter, *args, timeout=None)
6904 def list(self, filter, *args, timeout=None): 6905 ''' 6906 List gets a list of Resources matching a given set of criteria. 6907 ''' 6908 deadline = None if timeout is None else time.time() + timeout 6909 req = ResourceListRequest() 6910 req.meta.CopyFrom(ListRequestMetadata()) 6911 if self.parent.page_limit > 0: 6912 req.meta.limit = self.parent.page_limit 6913 if self.parent.snapshot_datetime is not None: 6914 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6915 6916 req.filter = plumbing.quote_filter_args(filter, *args) 6917 6918 def generator(svc, req): 6919 tries = 0 6920 while True: 6921 t = None if deadline is None else deadline - time.time() 6922 try: 6923 plumbing_response = svc.stub.List( 6924 req, 6925 metadata=svc.parent.get_metadata( 6926 'Resources.List', req), 6927 timeout=t) 6928 except Exception as e: 6929 if self.parent.shouldRetry(tries, e, deadline): 6930 tries += 1 6931 time.sleep( 6932 self.parent.exponentialBackoff(tries, deadline)) 6933 continue 6934 raise plumbing.convert_error_to_porcelain(e) from e 6935 tries = 0 6936 for plumbing_item in plumbing_response.resources: 6937 yield plumbing.convert_resource_to_porcelain(plumbing_item) 6938 if plumbing_response.meta.next_cursor == '': 6939 break 6940 req.meta.cursor = plumbing_response.meta.next_cursor 6941 6942 return generator(self, req)
List gets a list of Resources matching a given set of criteria.
def
healthcheck(self, id, timeout=None)
6944 def healthcheck(self, id, timeout=None): 6945 ''' 6946 Healthcheck triggers a remote healthcheck. It may take minutes to propagate across a 6947 large network of Nodes. The call will return immediately, and the updated health of the 6948 Resource can be retrieved via Get or List. 6949 ''' 6950 deadline = None if timeout is None else time.time() + timeout 6951 req = ResourceHealthcheckRequest() 6952 6953 req.id = (id) 6954 tries = 0 6955 plumbing_response = None 6956 while True: 6957 t = None if deadline is None else deadline - time.time() 6958 try: 6959 plumbing_response = self.stub.Healthcheck( 6960 req, 6961 metadata=self.parent.get_metadata('Resources.Healthcheck', 6962 req), 6963 timeout=t) 6964 except Exception as e: 6965 if self.parent.shouldRetry(tries, e, deadline): 6966 tries += 1 6967 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6968 continue 6969 raise plumbing.convert_error_to_porcelain(e) from e 6970 break 6971 6972 resp = models.ResourceHealthcheckResponse() 6973 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 6974 plumbing_response.meta) 6975 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6976 plumbing_response.rate_limit) 6977 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:
6980class SnapshotResources: 6981 ''' 6982 SnapshotResources exposes the read only methods of the Resources 6983 service for historical queries. 6984 ''' 6985 def __init__(self, resources): 6986 self.resources = resources 6987 6988 def get(self, id, timeout=None): 6989 ''' 6990 Get reads one Resource by ID. 6991 ''' 6992 return self.resources.get(id, timeout=timeout) 6993 6994 def list(self, filter, *args, timeout=None): 6995 ''' 6996 List gets a list of Resources matching a given set of criteria. 6997 ''' 6998 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)
6988 def get(self, id, timeout=None): 6989 ''' 6990 Get reads one Resource by ID. 6991 ''' 6992 return self.resources.get(id, timeout=timeout)
Get reads one Resource by ID.
def
list(self, filter, *args, timeout=None)
6994 def list(self, filter, *args, timeout=None): 6995 ''' 6996 List gets a list of Resources matching a given set of criteria. 6997 ''' 6998 return self.resources.list(filter, *args, timeout=timeout)
List gets a list of Resources matching a given set of criteria.
class
ResourcesHistory:
7001class ResourcesHistory: 7002 ''' 7003 ResourcesHistory records all changes to the state of a Resource. 7004 See `strongdm.models.ResourceHistory`. 7005 ''' 7006 def __init__(self, channel, client): 7007 self.parent = client 7008 self.stub = ResourcesHistoryStub(channel) 7009 7010 def list(self, filter, *args, timeout=None): 7011 ''' 7012 List gets a list of ResourceHistory records matching a given set of criteria. 7013 ''' 7014 deadline = None if timeout is None else time.time() + timeout 7015 req = ResourceHistoryListRequest() 7016 req.meta.CopyFrom(ListRequestMetadata()) 7017 if self.parent.page_limit > 0: 7018 req.meta.limit = self.parent.page_limit 7019 if self.parent.snapshot_datetime is not None: 7020 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7021 7022 req.filter = plumbing.quote_filter_args(filter, *args) 7023 7024 def generator(svc, req): 7025 tries = 0 7026 while True: 7027 t = None if deadline is None else deadline - time.time() 7028 try: 7029 plumbing_response = svc.stub.List( 7030 req, 7031 metadata=svc.parent.get_metadata( 7032 'ResourcesHistory.List', req), 7033 timeout=t) 7034 except Exception as e: 7035 if self.parent.shouldRetry(tries, e, deadline): 7036 tries += 1 7037 time.sleep( 7038 self.parent.exponentialBackoff(tries, deadline)) 7039 continue 7040 raise plumbing.convert_error_to_porcelain(e) from e 7041 tries = 0 7042 for plumbing_item in plumbing_response.history: 7043 yield plumbing.convert_resource_history_to_porcelain( 7044 plumbing_item) 7045 if plumbing_response.meta.next_cursor == '': 7046 break 7047 req.meta.cursor = plumbing_response.meta.next_cursor 7048 7049 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)
7010 def list(self, filter, *args, timeout=None): 7011 ''' 7012 List gets a list of ResourceHistory records matching a given set of criteria. 7013 ''' 7014 deadline = None if timeout is None else time.time() + timeout 7015 req = ResourceHistoryListRequest() 7016 req.meta.CopyFrom(ListRequestMetadata()) 7017 if self.parent.page_limit > 0: 7018 req.meta.limit = self.parent.page_limit 7019 if self.parent.snapshot_datetime is not None: 7020 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7021 7022 req.filter = plumbing.quote_filter_args(filter, *args) 7023 7024 def generator(svc, req): 7025 tries = 0 7026 while True: 7027 t = None if deadline is None else deadline - time.time() 7028 try: 7029 plumbing_response = svc.stub.List( 7030 req, 7031 metadata=svc.parent.get_metadata( 7032 'ResourcesHistory.List', req), 7033 timeout=t) 7034 except Exception as e: 7035 if self.parent.shouldRetry(tries, e, deadline): 7036 tries += 1 7037 time.sleep( 7038 self.parent.exponentialBackoff(tries, deadline)) 7039 continue 7040 raise plumbing.convert_error_to_porcelain(e) from e 7041 tries = 0 7042 for plumbing_item in plumbing_response.history: 7043 yield plumbing.convert_resource_history_to_porcelain( 7044 plumbing_item) 7045 if plumbing_response.meta.next_cursor == '': 7046 break 7047 req.meta.cursor = plumbing_response.meta.next_cursor 7048 7049 return generator(self, req)
List gets a list of ResourceHistory records matching a given set of criteria.
class
RoleResources:
7052class RoleResources: 7053 ''' 7054 RoleResources enumerates the resources to which roles have access. 7055 The RoleResources service is read-only. 7056 See `strongdm.models.RoleResource`. 7057 ''' 7058 def __init__(self, channel, client): 7059 self.parent = client 7060 self.stub = RoleResourcesStub(channel) 7061 7062 def list(self, filter, *args, timeout=None): 7063 ''' 7064 List gets a list of RoleResource records matching a given set of criteria. 7065 ''' 7066 deadline = None if timeout is None else time.time() + timeout 7067 req = RoleResourceListRequest() 7068 req.meta.CopyFrom(ListRequestMetadata()) 7069 if self.parent.page_limit > 0: 7070 req.meta.limit = self.parent.page_limit 7071 if self.parent.snapshot_datetime is not None: 7072 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7073 7074 req.filter = plumbing.quote_filter_args(filter, *args) 7075 7076 def generator(svc, req): 7077 tries = 0 7078 while True: 7079 t = None if deadline is None else deadline - time.time() 7080 try: 7081 plumbing_response = svc.stub.List( 7082 req, 7083 metadata=svc.parent.get_metadata( 7084 'RoleResources.List', req), 7085 timeout=t) 7086 except Exception as e: 7087 if self.parent.shouldRetry(tries, e, deadline): 7088 tries += 1 7089 time.sleep( 7090 self.parent.exponentialBackoff(tries, deadline)) 7091 continue 7092 raise plumbing.convert_error_to_porcelain(e) from e 7093 tries = 0 7094 for plumbing_item in plumbing_response.role_resources: 7095 yield plumbing.convert_role_resource_to_porcelain( 7096 plumbing_item) 7097 if plumbing_response.meta.next_cursor == '': 7098 break 7099 req.meta.cursor = plumbing_response.meta.next_cursor 7100 7101 return generator(self, req)
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)
7062 def list(self, filter, *args, timeout=None): 7063 ''' 7064 List gets a list of RoleResource records matching a given set of criteria. 7065 ''' 7066 deadline = None if timeout is None else time.time() + timeout 7067 req = RoleResourceListRequest() 7068 req.meta.CopyFrom(ListRequestMetadata()) 7069 if self.parent.page_limit > 0: 7070 req.meta.limit = self.parent.page_limit 7071 if self.parent.snapshot_datetime is not None: 7072 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7073 7074 req.filter = plumbing.quote_filter_args(filter, *args) 7075 7076 def generator(svc, req): 7077 tries = 0 7078 while True: 7079 t = None if deadline is None else deadline - time.time() 7080 try: 7081 plumbing_response = svc.stub.List( 7082 req, 7083 metadata=svc.parent.get_metadata( 7084 'RoleResources.List', req), 7085 timeout=t) 7086 except Exception as e: 7087 if self.parent.shouldRetry(tries, e, deadline): 7088 tries += 1 7089 time.sleep( 7090 self.parent.exponentialBackoff(tries, deadline)) 7091 continue 7092 raise plumbing.convert_error_to_porcelain(e) from e 7093 tries = 0 7094 for plumbing_item in plumbing_response.role_resources: 7095 yield plumbing.convert_role_resource_to_porcelain( 7096 plumbing_item) 7097 if plumbing_response.meta.next_cursor == '': 7098 break 7099 req.meta.cursor = plumbing_response.meta.next_cursor 7100 7101 return generator(self, req)
List gets a list of RoleResource records matching a given set of criteria.
class
SnapshotRoleResources:
7104class SnapshotRoleResources: 7105 ''' 7106 SnapshotRoleResources exposes the read only methods of the RoleResources 7107 service for historical queries. 7108 ''' 7109 def __init__(self, role_resources): 7110 self.role_resources = role_resources 7111 7112 def list(self, filter, *args, timeout=None): 7113 ''' 7114 List gets a list of RoleResource records matching a given set of criteria. 7115 ''' 7116 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)
7112 def list(self, filter, *args, timeout=None): 7113 ''' 7114 List gets a list of RoleResource records matching a given set of criteria. 7115 ''' 7116 return self.role_resources.list(filter, *args, timeout=timeout)
List gets a list of RoleResource records matching a given set of criteria.
class
RoleResourcesHistory:
7119class RoleResourcesHistory: 7120 ''' 7121 RoleResourcesHistory records all changes to the state of a RoleResource. 7122 See `strongdm.models.RoleResourceHistory`. 7123 ''' 7124 def __init__(self, channel, client): 7125 self.parent = client 7126 self.stub = RoleResourcesHistoryStub(channel) 7127 7128 def list(self, filter, *args, timeout=None): 7129 ''' 7130 List gets a list of RoleResourceHistory records matching a given set of criteria. 7131 ''' 7132 deadline = None if timeout is None else time.time() + timeout 7133 req = RoleResourceHistoryListRequest() 7134 req.meta.CopyFrom(ListRequestMetadata()) 7135 if self.parent.page_limit > 0: 7136 req.meta.limit = self.parent.page_limit 7137 if self.parent.snapshot_datetime is not None: 7138 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7139 7140 req.filter = plumbing.quote_filter_args(filter, *args) 7141 7142 def generator(svc, req): 7143 tries = 0 7144 while True: 7145 t = None if deadline is None else deadline - time.time() 7146 try: 7147 plumbing_response = svc.stub.List( 7148 req, 7149 metadata=svc.parent.get_metadata( 7150 'RoleResourcesHistory.List', req), 7151 timeout=t) 7152 except Exception as e: 7153 if self.parent.shouldRetry(tries, e, deadline): 7154 tries += 1 7155 time.sleep( 7156 self.parent.exponentialBackoff(tries, deadline)) 7157 continue 7158 raise plumbing.convert_error_to_porcelain(e) from e 7159 tries = 0 7160 for plumbing_item in plumbing_response.history: 7161 yield plumbing.convert_role_resource_history_to_porcelain( 7162 plumbing_item) 7163 if plumbing_response.meta.next_cursor == '': 7164 break 7165 req.meta.cursor = plumbing_response.meta.next_cursor 7166 7167 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)
7128 def list(self, filter, *args, timeout=None): 7129 ''' 7130 List gets a list of RoleResourceHistory records matching a given set of criteria. 7131 ''' 7132 deadline = None if timeout is None else time.time() + timeout 7133 req = RoleResourceHistoryListRequest() 7134 req.meta.CopyFrom(ListRequestMetadata()) 7135 if self.parent.page_limit > 0: 7136 req.meta.limit = self.parent.page_limit 7137 if self.parent.snapshot_datetime is not None: 7138 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7139 7140 req.filter = plumbing.quote_filter_args(filter, *args) 7141 7142 def generator(svc, req): 7143 tries = 0 7144 while True: 7145 t = None if deadline is None else deadline - time.time() 7146 try: 7147 plumbing_response = svc.stub.List( 7148 req, 7149 metadata=svc.parent.get_metadata( 7150 'RoleResourcesHistory.List', req), 7151 timeout=t) 7152 except Exception as e: 7153 if self.parent.shouldRetry(tries, e, deadline): 7154 tries += 1 7155 time.sleep( 7156 self.parent.exponentialBackoff(tries, deadline)) 7157 continue 7158 raise plumbing.convert_error_to_porcelain(e) from e 7159 tries = 0 7160 for plumbing_item in plumbing_response.history: 7161 yield plumbing.convert_role_resource_history_to_porcelain( 7162 plumbing_item) 7163 if plumbing_response.meta.next_cursor == '': 7164 break 7165 req.meta.cursor = plumbing_response.meta.next_cursor 7166 7167 return generator(self, req)
List gets a list of RoleResourceHistory records matching a given set of criteria.
class
RolesHistory:
7170class RolesHistory: 7171 ''' 7172 RolesHistory records all changes to the state of a Role. 7173 See `strongdm.models.RoleHistory`. 7174 ''' 7175 def __init__(self, channel, client): 7176 self.parent = client 7177 self.stub = RolesHistoryStub(channel) 7178 7179 def list(self, filter, *args, timeout=None): 7180 ''' 7181 List gets a list of RoleHistory records matching a given set of criteria. 7182 ''' 7183 deadline = None if timeout is None else time.time() + timeout 7184 req = RoleHistoryListRequest() 7185 req.meta.CopyFrom(ListRequestMetadata()) 7186 if self.parent.page_limit > 0: 7187 req.meta.limit = self.parent.page_limit 7188 if self.parent.snapshot_datetime is not None: 7189 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7190 7191 req.filter = plumbing.quote_filter_args(filter, *args) 7192 7193 def generator(svc, req): 7194 tries = 0 7195 while True: 7196 t = None if deadline is None else deadline - time.time() 7197 try: 7198 plumbing_response = svc.stub.List( 7199 req, 7200 metadata=svc.parent.get_metadata( 7201 'RolesHistory.List', req), 7202 timeout=t) 7203 except Exception as e: 7204 if self.parent.shouldRetry(tries, e, deadline): 7205 tries += 1 7206 time.sleep( 7207 self.parent.exponentialBackoff(tries, deadline)) 7208 continue 7209 raise plumbing.convert_error_to_porcelain(e) from e 7210 tries = 0 7211 for plumbing_item in plumbing_response.history: 7212 yield plumbing.convert_role_history_to_porcelain( 7213 plumbing_item) 7214 if plumbing_response.meta.next_cursor == '': 7215 break 7216 req.meta.cursor = plumbing_response.meta.next_cursor 7217 7218 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)
7179 def list(self, filter, *args, timeout=None): 7180 ''' 7181 List gets a list of RoleHistory records matching a given set of criteria. 7182 ''' 7183 deadline = None if timeout is None else time.time() + timeout 7184 req = RoleHistoryListRequest() 7185 req.meta.CopyFrom(ListRequestMetadata()) 7186 if self.parent.page_limit > 0: 7187 req.meta.limit = self.parent.page_limit 7188 if self.parent.snapshot_datetime is not None: 7189 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7190 7191 req.filter = plumbing.quote_filter_args(filter, *args) 7192 7193 def generator(svc, req): 7194 tries = 0 7195 while True: 7196 t = None if deadline is None else deadline - time.time() 7197 try: 7198 plumbing_response = svc.stub.List( 7199 req, 7200 metadata=svc.parent.get_metadata( 7201 'RolesHistory.List', req), 7202 timeout=t) 7203 except Exception as e: 7204 if self.parent.shouldRetry(tries, e, deadline): 7205 tries += 1 7206 time.sleep( 7207 self.parent.exponentialBackoff(tries, deadline)) 7208 continue 7209 raise plumbing.convert_error_to_porcelain(e) from e 7210 tries = 0 7211 for plumbing_item in plumbing_response.history: 7212 yield plumbing.convert_role_history_to_porcelain( 7213 plumbing_item) 7214 if plumbing_response.meta.next_cursor == '': 7215 break 7216 req.meta.cursor = plumbing_response.meta.next_cursor 7217 7218 return generator(self, req)
List gets a list of RoleHistory records matching a given set of criteria.
class
SecretStores:
7221class SecretStores: 7222 ''' 7223 SecretStores are servers where resource secrets (passwords, keys) are stored. 7224 See: 7225 `strongdm.models.ActiveDirectoryStore` 7226 `strongdm.models.AWSStore` 7227 `strongdm.models.AWSCertX509Store` 7228 `strongdm.models.AzureStore` 7229 `strongdm.models.CyberarkConjurStore` 7230 `strongdm.models.CyberarkPAMStore` 7231 `strongdm.models.CyberarkPAMExperimentalStore` 7232 `strongdm.models.DelineaStore` 7233 `strongdm.models.GCPStore` 7234 `strongdm.models.GCPCertX509Store` 7235 `strongdm.models.KeyfactorSSHStore` 7236 `strongdm.models.KeyfactorX509Store` 7237 `strongdm.models.StrongVaultStore` 7238 `strongdm.models.VaultAppRoleStore` 7239 `strongdm.models.VaultAppRoleCertSSHStore` 7240 `strongdm.models.VaultAppRoleCertX509Store` 7241 `strongdm.models.VaultAWSEC2Store` 7242 `strongdm.models.VaultAWSEC2CertSSHStore` 7243 `strongdm.models.VaultAWSEC2CertX509Store` 7244 `strongdm.models.VaultAWSIAMStore` 7245 `strongdm.models.VaultAWSIAMCertSSHStore` 7246 `strongdm.models.VaultAWSIAMCertX509Store` 7247 `strongdm.models.VaultTLSStore` 7248 `strongdm.models.VaultTLSCertSSHStore` 7249 `strongdm.models.VaultTLSCertX509Store` 7250 `strongdm.models.VaultTokenStore` 7251 `strongdm.models.VaultTokenCertSSHStore` 7252 `strongdm.models.VaultTokenCertX509Store` 7253 ''' 7254 def __init__(self, channel, client): 7255 self.parent = client 7256 self.stub = SecretStoresStub(channel) 7257 7258 def create(self, secret_store, timeout=None): 7259 deadline = None if timeout is None else time.time() + timeout 7260 req = SecretStoreCreateRequest() 7261 7262 if secret_store is not None: 7263 req.secret_store.CopyFrom( 7264 plumbing.convert_secret_store_to_plumbing(secret_store)) 7265 tries = 0 7266 plumbing_response = None 7267 while True: 7268 t = None if deadline is None else deadline - time.time() 7269 try: 7270 plumbing_response = self.stub.Create( 7271 req, 7272 metadata=self.parent.get_metadata('SecretStores.Create', 7273 req), 7274 timeout=t) 7275 except Exception as e: 7276 if self.parent.shouldRetry(tries, e, deadline): 7277 tries += 1 7278 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7279 continue 7280 raise plumbing.convert_error_to_porcelain(e) from e 7281 break 7282 7283 resp = models.SecretStoreCreateResponse() 7284 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 7285 plumbing_response.meta) 7286 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7287 plumbing_response.rate_limit) 7288 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 7289 plumbing_response.secret_store) 7290 return resp 7291 7292 def get(self, id, timeout=None): 7293 ''' 7294 Get reads one SecretStore by ID. 7295 ''' 7296 deadline = None if timeout is None else time.time() + timeout 7297 req = SecretStoreGetRequest() 7298 if self.parent.snapshot_datetime is not None: 7299 req.meta.CopyFrom(GetRequestMetadata()) 7300 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7301 7302 req.id = (id) 7303 tries = 0 7304 plumbing_response = None 7305 while True: 7306 t = None if deadline is None else deadline - time.time() 7307 try: 7308 plumbing_response = self.stub.Get( 7309 req, 7310 metadata=self.parent.get_metadata('SecretStores.Get', req), 7311 timeout=t) 7312 except Exception as e: 7313 if self.parent.shouldRetry(tries, e, deadline): 7314 tries += 1 7315 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7316 continue 7317 raise plumbing.convert_error_to_porcelain(e) from e 7318 break 7319 7320 resp = models.SecretStoreGetResponse() 7321 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 7322 plumbing_response.meta) 7323 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7324 plumbing_response.rate_limit) 7325 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 7326 plumbing_response.secret_store) 7327 return resp 7328 7329 def update(self, secret_store, timeout=None): 7330 ''' 7331 Update replaces all the fields of a SecretStore by ID. 7332 ''' 7333 deadline = None if timeout is None else time.time() + timeout 7334 req = SecretStoreUpdateRequest() 7335 7336 if secret_store is not None: 7337 req.secret_store.CopyFrom( 7338 plumbing.convert_secret_store_to_plumbing(secret_store)) 7339 tries = 0 7340 plumbing_response = None 7341 while True: 7342 t = None if deadline is None else deadline - time.time() 7343 try: 7344 plumbing_response = self.stub.Update( 7345 req, 7346 metadata=self.parent.get_metadata('SecretStores.Update', 7347 req), 7348 timeout=t) 7349 except Exception as e: 7350 if self.parent.shouldRetry(tries, e, deadline): 7351 tries += 1 7352 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7353 continue 7354 raise plumbing.convert_error_to_porcelain(e) from e 7355 break 7356 7357 resp = models.SecretStoreUpdateResponse() 7358 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 7359 plumbing_response.meta) 7360 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7361 plumbing_response.rate_limit) 7362 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 7363 plumbing_response.secret_store) 7364 return resp 7365 7366 def delete(self, id, timeout=None): 7367 ''' 7368 Delete removes a SecretStore by ID. 7369 ''' 7370 deadline = None if timeout is None else time.time() + timeout 7371 req = SecretStoreDeleteRequest() 7372 7373 req.id = (id) 7374 tries = 0 7375 plumbing_response = None 7376 while True: 7377 t = None if deadline is None else deadline - time.time() 7378 try: 7379 plumbing_response = self.stub.Delete( 7380 req, 7381 metadata=self.parent.get_metadata('SecretStores.Delete', 7382 req), 7383 timeout=t) 7384 except Exception as e: 7385 if self.parent.shouldRetry(tries, e, deadline): 7386 tries += 1 7387 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7388 continue 7389 raise plumbing.convert_error_to_porcelain(e) from e 7390 break 7391 7392 resp = models.SecretStoreDeleteResponse() 7393 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 7394 plumbing_response.meta) 7395 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7396 plumbing_response.rate_limit) 7397 return resp 7398 7399 def list(self, filter, *args, timeout=None): 7400 ''' 7401 List gets a list of SecretStores matching a given set of criteria. 7402 ''' 7403 deadline = None if timeout is None else time.time() + timeout 7404 req = SecretStoreListRequest() 7405 req.meta.CopyFrom(ListRequestMetadata()) 7406 if self.parent.page_limit > 0: 7407 req.meta.limit = self.parent.page_limit 7408 if self.parent.snapshot_datetime is not None: 7409 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7410 7411 req.filter = plumbing.quote_filter_args(filter, *args) 7412 7413 def generator(svc, req): 7414 tries = 0 7415 while True: 7416 t = None if deadline is None else deadline - time.time() 7417 try: 7418 plumbing_response = svc.stub.List( 7419 req, 7420 metadata=svc.parent.get_metadata( 7421 'SecretStores.List', req), 7422 timeout=t) 7423 except Exception as e: 7424 if self.parent.shouldRetry(tries, e, deadline): 7425 tries += 1 7426 time.sleep( 7427 self.parent.exponentialBackoff(tries, deadline)) 7428 continue 7429 raise plumbing.convert_error_to_porcelain(e) from e 7430 tries = 0 7431 for plumbing_item in plumbing_response.secret_stores: 7432 yield plumbing.convert_secret_store_to_porcelain( 7433 plumbing_item) 7434 if plumbing_response.meta.next_cursor == '': 7435 break 7436 req.meta.cursor = plumbing_response.meta.next_cursor 7437 7438 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)
7258 def create(self, secret_store, timeout=None): 7259 deadline = None if timeout is None else time.time() + timeout 7260 req = SecretStoreCreateRequest() 7261 7262 if secret_store is not None: 7263 req.secret_store.CopyFrom( 7264 plumbing.convert_secret_store_to_plumbing(secret_store)) 7265 tries = 0 7266 plumbing_response = None 7267 while True: 7268 t = None if deadline is None else deadline - time.time() 7269 try: 7270 plumbing_response = self.stub.Create( 7271 req, 7272 metadata=self.parent.get_metadata('SecretStores.Create', 7273 req), 7274 timeout=t) 7275 except Exception as e: 7276 if self.parent.shouldRetry(tries, e, deadline): 7277 tries += 1 7278 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7279 continue 7280 raise plumbing.convert_error_to_porcelain(e) from e 7281 break 7282 7283 resp = models.SecretStoreCreateResponse() 7284 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 7285 plumbing_response.meta) 7286 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7287 plumbing_response.rate_limit) 7288 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 7289 plumbing_response.secret_store) 7290 return resp
def
get(self, id, timeout=None)
7292 def get(self, id, timeout=None): 7293 ''' 7294 Get reads one SecretStore by ID. 7295 ''' 7296 deadline = None if timeout is None else time.time() + timeout 7297 req = SecretStoreGetRequest() 7298 if self.parent.snapshot_datetime is not None: 7299 req.meta.CopyFrom(GetRequestMetadata()) 7300 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7301 7302 req.id = (id) 7303 tries = 0 7304 plumbing_response = None 7305 while True: 7306 t = None if deadline is None else deadline - time.time() 7307 try: 7308 plumbing_response = self.stub.Get( 7309 req, 7310 metadata=self.parent.get_metadata('SecretStores.Get', req), 7311 timeout=t) 7312 except Exception as e: 7313 if self.parent.shouldRetry(tries, e, deadline): 7314 tries += 1 7315 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7316 continue 7317 raise plumbing.convert_error_to_porcelain(e) from e 7318 break 7319 7320 resp = models.SecretStoreGetResponse() 7321 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 7322 plumbing_response.meta) 7323 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7324 plumbing_response.rate_limit) 7325 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 7326 plumbing_response.secret_store) 7327 return resp
Get reads one SecretStore by ID.
def
update(self, secret_store, timeout=None)
7329 def update(self, secret_store, timeout=None): 7330 ''' 7331 Update replaces all the fields of a SecretStore by ID. 7332 ''' 7333 deadline = None if timeout is None else time.time() + timeout 7334 req = SecretStoreUpdateRequest() 7335 7336 if secret_store is not None: 7337 req.secret_store.CopyFrom( 7338 plumbing.convert_secret_store_to_plumbing(secret_store)) 7339 tries = 0 7340 plumbing_response = None 7341 while True: 7342 t = None if deadline is None else deadline - time.time() 7343 try: 7344 plumbing_response = self.stub.Update( 7345 req, 7346 metadata=self.parent.get_metadata('SecretStores.Update', 7347 req), 7348 timeout=t) 7349 except Exception as e: 7350 if self.parent.shouldRetry(tries, e, deadline): 7351 tries += 1 7352 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7353 continue 7354 raise plumbing.convert_error_to_porcelain(e) from e 7355 break 7356 7357 resp = models.SecretStoreUpdateResponse() 7358 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 7359 plumbing_response.meta) 7360 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7361 plumbing_response.rate_limit) 7362 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 7363 plumbing_response.secret_store) 7364 return resp
Update replaces all the fields of a SecretStore by ID.
def
delete(self, id, timeout=None)
7366 def delete(self, id, timeout=None): 7367 ''' 7368 Delete removes a SecretStore by ID. 7369 ''' 7370 deadline = None if timeout is None else time.time() + timeout 7371 req = SecretStoreDeleteRequest() 7372 7373 req.id = (id) 7374 tries = 0 7375 plumbing_response = None 7376 while True: 7377 t = None if deadline is None else deadline - time.time() 7378 try: 7379 plumbing_response = self.stub.Delete( 7380 req, 7381 metadata=self.parent.get_metadata('SecretStores.Delete', 7382 req), 7383 timeout=t) 7384 except Exception as e: 7385 if self.parent.shouldRetry(tries, e, deadline): 7386 tries += 1 7387 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7388 continue 7389 raise plumbing.convert_error_to_porcelain(e) from e 7390 break 7391 7392 resp = models.SecretStoreDeleteResponse() 7393 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 7394 plumbing_response.meta) 7395 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7396 plumbing_response.rate_limit) 7397 return resp
Delete removes a SecretStore by ID.
def
list(self, filter, *args, timeout=None)
7399 def list(self, filter, *args, timeout=None): 7400 ''' 7401 List gets a list of SecretStores matching a given set of criteria. 7402 ''' 7403 deadline = None if timeout is None else time.time() + timeout 7404 req = SecretStoreListRequest() 7405 req.meta.CopyFrom(ListRequestMetadata()) 7406 if self.parent.page_limit > 0: 7407 req.meta.limit = self.parent.page_limit 7408 if self.parent.snapshot_datetime is not None: 7409 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7410 7411 req.filter = plumbing.quote_filter_args(filter, *args) 7412 7413 def generator(svc, req): 7414 tries = 0 7415 while True: 7416 t = None if deadline is None else deadline - time.time() 7417 try: 7418 plumbing_response = svc.stub.List( 7419 req, 7420 metadata=svc.parent.get_metadata( 7421 'SecretStores.List', req), 7422 timeout=t) 7423 except Exception as e: 7424 if self.parent.shouldRetry(tries, e, deadline): 7425 tries += 1 7426 time.sleep( 7427 self.parent.exponentialBackoff(tries, deadline)) 7428 continue 7429 raise plumbing.convert_error_to_porcelain(e) from e 7430 tries = 0 7431 for plumbing_item in plumbing_response.secret_stores: 7432 yield plumbing.convert_secret_store_to_porcelain( 7433 plumbing_item) 7434 if plumbing_response.meta.next_cursor == '': 7435 break 7436 req.meta.cursor = plumbing_response.meta.next_cursor 7437 7438 return generator(self, req)
List gets a list of SecretStores matching a given set of criteria.
class
SnapshotSecretStores:
7441class SnapshotSecretStores: 7442 ''' 7443 SnapshotSecretStores exposes the read only methods of the SecretStores 7444 service for historical queries. 7445 ''' 7446 def __init__(self, secret_stores): 7447 self.secret_stores = secret_stores 7448 7449 def get(self, id, timeout=None): 7450 ''' 7451 Get reads one SecretStore by ID. 7452 ''' 7453 return self.secret_stores.get(id, timeout=timeout) 7454 7455 def list(self, filter, *args, timeout=None): 7456 ''' 7457 List gets a list of SecretStores matching a given set of criteria. 7458 ''' 7459 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)
7449 def get(self, id, timeout=None): 7450 ''' 7451 Get reads one SecretStore by ID. 7452 ''' 7453 return self.secret_stores.get(id, timeout=timeout)
Get reads one SecretStore by ID.
def
list(self, filter, *args, timeout=None)
7455 def list(self, filter, *args, timeout=None): 7456 ''' 7457 List gets a list of SecretStores matching a given set of criteria. 7458 ''' 7459 return self.secret_stores.list(filter, *args, timeout=timeout)
List gets a list of SecretStores matching a given set of criteria.
class
SecretEngines:
7462class SecretEngines: 7463 ''' 7464 7465 See: 7466 `strongdm.models.ActiveDirectoryEngine` 7467 `strongdm.models.KeyValueEngine` 7468 `strongdm.models.MysqlEngine` 7469 `strongdm.models.PostgresEngine` 7470 `strongdm.models.SqlserverEngine` 7471 ''' 7472 def __init__(self, channel, client): 7473 self.parent = client 7474 self.stub = SecretEnginesStub(channel) 7475 7476 def list(self, filter, *args, timeout=None): 7477 ''' 7478 List returns a list of Secret Engines 7479 ''' 7480 deadline = None if timeout is None else time.time() + timeout 7481 req = SecretEngineListRequest() 7482 req.meta.CopyFrom(ListRequestMetadata()) 7483 if self.parent.page_limit > 0: 7484 req.meta.limit = self.parent.page_limit 7485 if self.parent.snapshot_datetime is not None: 7486 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7487 7488 req.filter = plumbing.quote_filter_args(filter, *args) 7489 7490 def generator(svc, req): 7491 tries = 0 7492 while True: 7493 t = None if deadline is None else deadline - time.time() 7494 try: 7495 plumbing_response = svc.stub.List( 7496 req, 7497 metadata=svc.parent.get_metadata( 7498 'SecretEngines.List', req), 7499 timeout=t) 7500 except Exception as e: 7501 if self.parent.shouldRetry(tries, e, deadline): 7502 tries += 1 7503 time.sleep( 7504 self.parent.exponentialBackoff(tries, deadline)) 7505 continue 7506 raise plumbing.convert_error_to_porcelain(e) from e 7507 tries = 0 7508 for plumbing_item in plumbing_response.secret_engines: 7509 yield plumbing.convert_secret_engine_to_porcelain( 7510 plumbing_item) 7511 if plumbing_response.meta.next_cursor == '': 7512 break 7513 req.meta.cursor = plumbing_response.meta.next_cursor 7514 7515 return generator(self, req) 7516 7517 def get(self, id, timeout=None): 7518 ''' 7519 Get returns a secret engine details 7520 ''' 7521 deadline = None if timeout is None else time.time() + timeout 7522 req = SecretEngineGetRequest() 7523 if self.parent.snapshot_datetime is not None: 7524 req.meta.CopyFrom(GetRequestMetadata()) 7525 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7526 7527 req.id = (id) 7528 tries = 0 7529 plumbing_response = None 7530 while True: 7531 t = None if deadline is None else deadline - time.time() 7532 try: 7533 plumbing_response = self.stub.Get( 7534 req, 7535 metadata=self.parent.get_metadata('SecretEngines.Get', 7536 req), 7537 timeout=t) 7538 except Exception as e: 7539 if self.parent.shouldRetry(tries, e, deadline): 7540 tries += 1 7541 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7542 continue 7543 raise plumbing.convert_error_to_porcelain(e) from e 7544 break 7545 7546 resp = models.SecretEngineGetResponse() 7547 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 7548 plumbing_response.meta) 7549 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7550 plumbing_response.rate_limit) 7551 resp.secret_engine = plumbing.convert_secret_engine_to_porcelain( 7552 plumbing_response.secret_engine) 7553 return resp 7554 7555 def create(self, secret_engine, timeout=None): 7556 ''' 7557 Create creates a secret engine 7558 ''' 7559 deadline = None if timeout is None else time.time() + timeout 7560 req = SecretEngineCreateRequest() 7561 7562 if secret_engine is not None: 7563 req.secret_engine.CopyFrom( 7564 plumbing.convert_secret_engine_to_plumbing(secret_engine)) 7565 tries = 0 7566 plumbing_response = None 7567 while True: 7568 t = None if deadline is None else deadline - time.time() 7569 try: 7570 plumbing_response = self.stub.Create( 7571 req, 7572 metadata=self.parent.get_metadata('SecretEngines.Create', 7573 req), 7574 timeout=t) 7575 except Exception as e: 7576 if self.parent.shouldRetry(tries, e, deadline): 7577 tries += 1 7578 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7579 continue 7580 raise plumbing.convert_error_to_porcelain(e) from e 7581 break 7582 7583 resp = models.SecretEngineCreateResponse() 7584 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 7585 plumbing_response.meta) 7586 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7587 plumbing_response.rate_limit) 7588 resp.secret_engine = plumbing.convert_secret_engine_to_porcelain( 7589 plumbing_response.secret_engine) 7590 return resp 7591 7592 def update(self, secret_engine, timeout=None): 7593 ''' 7594 Update updates a secret engine 7595 ''' 7596 deadline = None if timeout is None else time.time() + timeout 7597 req = SecretEngineUpdateRequest() 7598 7599 if secret_engine is not None: 7600 req.secret_engine.CopyFrom( 7601 plumbing.convert_secret_engine_to_plumbing(secret_engine)) 7602 tries = 0 7603 plumbing_response = None 7604 while True: 7605 t = None if deadline is None else deadline - time.time() 7606 try: 7607 plumbing_response = self.stub.Update( 7608 req, 7609 metadata=self.parent.get_metadata('SecretEngines.Update', 7610 req), 7611 timeout=t) 7612 except Exception as e: 7613 if self.parent.shouldRetry(tries, e, deadline): 7614 tries += 1 7615 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7616 continue 7617 raise plumbing.convert_error_to_porcelain(e) from e 7618 break 7619 7620 resp = models.SecretEngineUpdateResponse() 7621 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 7622 plumbing_response.meta) 7623 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7624 plumbing_response.rate_limit) 7625 resp.secret_engine = plumbing.convert_secret_engine_to_porcelain( 7626 plumbing_response.secret_engine) 7627 return resp 7628 7629 def delete(self, id, timeout=None): 7630 ''' 7631 Delete deletes a secret engine 7632 ''' 7633 deadline = None if timeout is None else time.time() + timeout 7634 req = SecretEngineDeleteRequest() 7635 7636 req.id = (id) 7637 tries = 0 7638 plumbing_response = None 7639 while True: 7640 t = None if deadline is None else deadline - time.time() 7641 try: 7642 plumbing_response = self.stub.Delete( 7643 req, 7644 metadata=self.parent.get_metadata('SecretEngines.Delete', 7645 req), 7646 timeout=t) 7647 except Exception as e: 7648 if self.parent.shouldRetry(tries, e, deadline): 7649 tries += 1 7650 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7651 continue 7652 raise plumbing.convert_error_to_porcelain(e) from e 7653 break 7654 7655 resp = models.SecretEngineDeleteResponse() 7656 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7657 plumbing_response.rate_limit) 7658 return resp 7659 7660 def list_secret_stores(self, filter, *args, timeout=None): 7661 ''' 7662 ListSecretStores returns a list of Secret Stores that can be used as a backing store 7663 for Secret Engine 7664 ''' 7665 deadline = None if timeout is None else time.time() + timeout 7666 req = SecretStoreListRequest() 7667 req.meta.CopyFrom(ListRequestMetadata()) 7668 if self.parent.page_limit > 0: 7669 req.meta.limit = self.parent.page_limit 7670 if self.parent.snapshot_datetime is not None: 7671 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7672 7673 req.filter = plumbing.quote_filter_args(filter, *args) 7674 7675 def generator(svc, req): 7676 tries = 0 7677 while True: 7678 t = None if deadline is None else deadline - time.time() 7679 try: 7680 plumbing_response = svc.stub.ListSecretStores( 7681 req, 7682 metadata=svc.parent.get_metadata( 7683 'SecretEngines.ListSecretStores', req), 7684 timeout=t) 7685 except Exception as e: 7686 if self.parent.shouldRetry(tries, e, deadline): 7687 tries += 1 7688 time.sleep( 7689 self.parent.exponentialBackoff(tries, deadline)) 7690 continue 7691 raise plumbing.convert_error_to_porcelain(e) from e 7692 tries = 0 7693 for plumbing_item in plumbing_response.secret_stores: 7694 yield plumbing.convert_secret_store_to_porcelain( 7695 plumbing_item) 7696 if plumbing_response.meta.next_cursor == '': 7697 break 7698 req.meta.cursor = plumbing_response.meta.next_cursor 7699 7700 return generator(self, req) 7701 7702 def generate_keys(self, secret_engine_id, timeout=None): 7703 ''' 7704 GenerateKeys generates a private key, stores it in a secret store and stores a public key in a secret engine 7705 ''' 7706 deadline = None if timeout is None else time.time() + timeout 7707 req = GenerateKeysRequest() 7708 7709 req.secret_engine_id = (secret_engine_id) 7710 tries = 0 7711 plumbing_response = None 7712 while True: 7713 t = None if deadline is None else deadline - time.time() 7714 try: 7715 plumbing_response = self.stub.GenerateKeys( 7716 req, 7717 metadata=self.parent.get_metadata( 7718 'SecretEngines.GenerateKeys', req), 7719 timeout=t) 7720 except Exception as e: 7721 if self.parent.shouldRetry(tries, e, deadline): 7722 tries += 1 7723 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7724 continue 7725 raise plumbing.convert_error_to_porcelain(e) from e 7726 break 7727 7728 resp = models.GenerateKeysResponse() 7729 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7730 plumbing_response.rate_limit) 7731 return resp 7732 7733 def healthcheck(self, secret_engine_id, timeout=None): 7734 ''' 7735 Healthcheck triggers a healthcheck for all nodes serving a secret engine 7736 ''' 7737 deadline = None if timeout is None else time.time() + timeout 7738 req = HealthcheckRequest() 7739 7740 req.secret_engine_id = (secret_engine_id) 7741 tries = 0 7742 plumbing_response = None 7743 while True: 7744 t = None if deadline is None else deadline - time.time() 7745 try: 7746 plumbing_response = self.stub.Healthcheck( 7747 req, 7748 metadata=self.parent.get_metadata( 7749 'SecretEngines.Healthcheck', req), 7750 timeout=t) 7751 except Exception as e: 7752 if self.parent.shouldRetry(tries, e, deadline): 7753 tries += 1 7754 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7755 continue 7756 raise plumbing.convert_error_to_porcelain(e) from e 7757 break 7758 7759 resp = models.HealthcheckResponse() 7760 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7761 plumbing_response.rate_limit) 7762 resp.status = plumbing.convert_repeated_healthcheck_status_to_porcelain( 7763 plumbing_response.status) 7764 return resp 7765 7766 def rotate(self, id, password_policy, timeout=None): 7767 ''' 7768 Rotate rotates secret engine's credentials 7769 ''' 7770 deadline = None if timeout is None else time.time() + timeout 7771 req = SecretEngineRotateRequest() 7772 7773 req.id = (id) 7774 if password_policy is not None: 7775 req.password_policy.CopyFrom( 7776 plumbing.convert_secret_engine_password_policy_to_plumbing( 7777 password_policy)) 7778 tries = 0 7779 plumbing_response = None 7780 while True: 7781 t = None if deadline is None else deadline - time.time() 7782 try: 7783 plumbing_response = self.stub.Rotate( 7784 req, 7785 metadata=self.parent.get_metadata('SecretEngines.Rotate', 7786 req), 7787 timeout=t) 7788 except Exception as e: 7789 if self.parent.shouldRetry(tries, e, deadline): 7790 tries += 1 7791 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7792 continue 7793 raise plumbing.convert_error_to_porcelain(e) from e 7794 break 7795 7796 resp = models.SecretEngineRotateResponse() 7797 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7798 plumbing_response.rate_limit) 7799 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)
7476 def list(self, filter, *args, timeout=None): 7477 ''' 7478 List returns a list of Secret Engines 7479 ''' 7480 deadline = None if timeout is None else time.time() + timeout 7481 req = SecretEngineListRequest() 7482 req.meta.CopyFrom(ListRequestMetadata()) 7483 if self.parent.page_limit > 0: 7484 req.meta.limit = self.parent.page_limit 7485 if self.parent.snapshot_datetime is not None: 7486 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7487 7488 req.filter = plumbing.quote_filter_args(filter, *args) 7489 7490 def generator(svc, req): 7491 tries = 0 7492 while True: 7493 t = None if deadline is None else deadline - time.time() 7494 try: 7495 plumbing_response = svc.stub.List( 7496 req, 7497 metadata=svc.parent.get_metadata( 7498 'SecretEngines.List', req), 7499 timeout=t) 7500 except Exception as e: 7501 if self.parent.shouldRetry(tries, e, deadline): 7502 tries += 1 7503 time.sleep( 7504 self.parent.exponentialBackoff(tries, deadline)) 7505 continue 7506 raise plumbing.convert_error_to_porcelain(e) from e 7507 tries = 0 7508 for plumbing_item in plumbing_response.secret_engines: 7509 yield plumbing.convert_secret_engine_to_porcelain( 7510 plumbing_item) 7511 if plumbing_response.meta.next_cursor == '': 7512 break 7513 req.meta.cursor = plumbing_response.meta.next_cursor 7514 7515 return generator(self, req)
List returns a list of Secret Engines
def
get(self, id, timeout=None)
7517 def get(self, id, timeout=None): 7518 ''' 7519 Get returns a secret engine details 7520 ''' 7521 deadline = None if timeout is None else time.time() + timeout 7522 req = SecretEngineGetRequest() 7523 if self.parent.snapshot_datetime is not None: 7524 req.meta.CopyFrom(GetRequestMetadata()) 7525 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7526 7527 req.id = (id) 7528 tries = 0 7529 plumbing_response = None 7530 while True: 7531 t = None if deadline is None else deadline - time.time() 7532 try: 7533 plumbing_response = self.stub.Get( 7534 req, 7535 metadata=self.parent.get_metadata('SecretEngines.Get', 7536 req), 7537 timeout=t) 7538 except Exception as e: 7539 if self.parent.shouldRetry(tries, e, deadline): 7540 tries += 1 7541 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7542 continue 7543 raise plumbing.convert_error_to_porcelain(e) from e 7544 break 7545 7546 resp = models.SecretEngineGetResponse() 7547 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 7548 plumbing_response.meta) 7549 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7550 plumbing_response.rate_limit) 7551 resp.secret_engine = plumbing.convert_secret_engine_to_porcelain( 7552 plumbing_response.secret_engine) 7553 return resp
Get returns a secret engine details
def
create(self, secret_engine, timeout=None)
7555 def create(self, secret_engine, timeout=None): 7556 ''' 7557 Create creates a secret engine 7558 ''' 7559 deadline = None if timeout is None else time.time() + timeout 7560 req = SecretEngineCreateRequest() 7561 7562 if secret_engine is not None: 7563 req.secret_engine.CopyFrom( 7564 plumbing.convert_secret_engine_to_plumbing(secret_engine)) 7565 tries = 0 7566 plumbing_response = None 7567 while True: 7568 t = None if deadline is None else deadline - time.time() 7569 try: 7570 plumbing_response = self.stub.Create( 7571 req, 7572 metadata=self.parent.get_metadata('SecretEngines.Create', 7573 req), 7574 timeout=t) 7575 except Exception as e: 7576 if self.parent.shouldRetry(tries, e, deadline): 7577 tries += 1 7578 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7579 continue 7580 raise plumbing.convert_error_to_porcelain(e) from e 7581 break 7582 7583 resp = models.SecretEngineCreateResponse() 7584 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 7585 plumbing_response.meta) 7586 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7587 plumbing_response.rate_limit) 7588 resp.secret_engine = plumbing.convert_secret_engine_to_porcelain( 7589 plumbing_response.secret_engine) 7590 return resp
Create creates a secret engine
def
update(self, secret_engine, timeout=None)
7592 def update(self, secret_engine, timeout=None): 7593 ''' 7594 Update updates a secret engine 7595 ''' 7596 deadline = None if timeout is None else time.time() + timeout 7597 req = SecretEngineUpdateRequest() 7598 7599 if secret_engine is not None: 7600 req.secret_engine.CopyFrom( 7601 plumbing.convert_secret_engine_to_plumbing(secret_engine)) 7602 tries = 0 7603 plumbing_response = None 7604 while True: 7605 t = None if deadline is None else deadline - time.time() 7606 try: 7607 plumbing_response = self.stub.Update( 7608 req, 7609 metadata=self.parent.get_metadata('SecretEngines.Update', 7610 req), 7611 timeout=t) 7612 except Exception as e: 7613 if self.parent.shouldRetry(tries, e, deadline): 7614 tries += 1 7615 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7616 continue 7617 raise plumbing.convert_error_to_porcelain(e) from e 7618 break 7619 7620 resp = models.SecretEngineUpdateResponse() 7621 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 7622 plumbing_response.meta) 7623 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7624 plumbing_response.rate_limit) 7625 resp.secret_engine = plumbing.convert_secret_engine_to_porcelain( 7626 plumbing_response.secret_engine) 7627 return resp
Update updates a secret engine
def
delete(self, id, timeout=None)
7629 def delete(self, id, timeout=None): 7630 ''' 7631 Delete deletes a secret engine 7632 ''' 7633 deadline = None if timeout is None else time.time() + timeout 7634 req = SecretEngineDeleteRequest() 7635 7636 req.id = (id) 7637 tries = 0 7638 plumbing_response = None 7639 while True: 7640 t = None if deadline is None else deadline - time.time() 7641 try: 7642 plumbing_response = self.stub.Delete( 7643 req, 7644 metadata=self.parent.get_metadata('SecretEngines.Delete', 7645 req), 7646 timeout=t) 7647 except Exception as e: 7648 if self.parent.shouldRetry(tries, e, deadline): 7649 tries += 1 7650 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7651 continue 7652 raise plumbing.convert_error_to_porcelain(e) from e 7653 break 7654 7655 resp = models.SecretEngineDeleteResponse() 7656 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7657 plumbing_response.rate_limit) 7658 return resp
Delete deletes a secret engine
def
list_secret_stores(self, filter, *args, timeout=None)
7660 def list_secret_stores(self, filter, *args, timeout=None): 7661 ''' 7662 ListSecretStores returns a list of Secret Stores that can be used as a backing store 7663 for Secret Engine 7664 ''' 7665 deadline = None if timeout is None else time.time() + timeout 7666 req = SecretStoreListRequest() 7667 req.meta.CopyFrom(ListRequestMetadata()) 7668 if self.parent.page_limit > 0: 7669 req.meta.limit = self.parent.page_limit 7670 if self.parent.snapshot_datetime is not None: 7671 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7672 7673 req.filter = plumbing.quote_filter_args(filter, *args) 7674 7675 def generator(svc, req): 7676 tries = 0 7677 while True: 7678 t = None if deadline is None else deadline - time.time() 7679 try: 7680 plumbing_response = svc.stub.ListSecretStores( 7681 req, 7682 metadata=svc.parent.get_metadata( 7683 'SecretEngines.ListSecretStores', req), 7684 timeout=t) 7685 except Exception as e: 7686 if self.parent.shouldRetry(tries, e, deadline): 7687 tries += 1 7688 time.sleep( 7689 self.parent.exponentialBackoff(tries, deadline)) 7690 continue 7691 raise plumbing.convert_error_to_porcelain(e) from e 7692 tries = 0 7693 for plumbing_item in plumbing_response.secret_stores: 7694 yield plumbing.convert_secret_store_to_porcelain( 7695 plumbing_item) 7696 if plumbing_response.meta.next_cursor == '': 7697 break 7698 req.meta.cursor = plumbing_response.meta.next_cursor 7699 7700 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)
7702 def generate_keys(self, secret_engine_id, timeout=None): 7703 ''' 7704 GenerateKeys generates a private key, stores it in a secret store and stores a public key in a secret engine 7705 ''' 7706 deadline = None if timeout is None else time.time() + timeout 7707 req = GenerateKeysRequest() 7708 7709 req.secret_engine_id = (secret_engine_id) 7710 tries = 0 7711 plumbing_response = None 7712 while True: 7713 t = None if deadline is None else deadline - time.time() 7714 try: 7715 plumbing_response = self.stub.GenerateKeys( 7716 req, 7717 metadata=self.parent.get_metadata( 7718 'SecretEngines.GenerateKeys', req), 7719 timeout=t) 7720 except Exception as e: 7721 if self.parent.shouldRetry(tries, e, deadline): 7722 tries += 1 7723 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7724 continue 7725 raise plumbing.convert_error_to_porcelain(e) from e 7726 break 7727 7728 resp = models.GenerateKeysResponse() 7729 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7730 plumbing_response.rate_limit) 7731 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)
7733 def healthcheck(self, secret_engine_id, timeout=None): 7734 ''' 7735 Healthcheck triggers a healthcheck for all nodes serving a secret engine 7736 ''' 7737 deadline = None if timeout is None else time.time() + timeout 7738 req = HealthcheckRequest() 7739 7740 req.secret_engine_id = (secret_engine_id) 7741 tries = 0 7742 plumbing_response = None 7743 while True: 7744 t = None if deadline is None else deadline - time.time() 7745 try: 7746 plumbing_response = self.stub.Healthcheck( 7747 req, 7748 metadata=self.parent.get_metadata( 7749 'SecretEngines.Healthcheck', req), 7750 timeout=t) 7751 except Exception as e: 7752 if self.parent.shouldRetry(tries, e, deadline): 7753 tries += 1 7754 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7755 continue 7756 raise plumbing.convert_error_to_porcelain(e) from e 7757 break 7758 7759 resp = models.HealthcheckResponse() 7760 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7761 plumbing_response.rate_limit) 7762 resp.status = plumbing.convert_repeated_healthcheck_status_to_porcelain( 7763 plumbing_response.status) 7764 return resp
Healthcheck triggers a healthcheck for all nodes serving a secret engine
def
rotate(self, id, password_policy, timeout=None)
7766 def rotate(self, id, password_policy, timeout=None): 7767 ''' 7768 Rotate rotates secret engine's credentials 7769 ''' 7770 deadline = None if timeout is None else time.time() + timeout 7771 req = SecretEngineRotateRequest() 7772 7773 req.id = (id) 7774 if password_policy is not None: 7775 req.password_policy.CopyFrom( 7776 plumbing.convert_secret_engine_password_policy_to_plumbing( 7777 password_policy)) 7778 tries = 0 7779 plumbing_response = None 7780 while True: 7781 t = None if deadline is None else deadline - time.time() 7782 try: 7783 plumbing_response = self.stub.Rotate( 7784 req, 7785 metadata=self.parent.get_metadata('SecretEngines.Rotate', 7786 req), 7787 timeout=t) 7788 except Exception as e: 7789 if self.parent.shouldRetry(tries, e, deadline): 7790 tries += 1 7791 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7792 continue 7793 raise plumbing.convert_error_to_porcelain(e) from e 7794 break 7795 7796 resp = models.SecretEngineRotateResponse() 7797 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7798 plumbing_response.rate_limit) 7799 return resp
Rotate rotates secret engine's credentials
class
SecretStoreHealths:
7802class SecretStoreHealths: 7803 ''' 7804 SecretStoreHealths exposes health states for secret stores. 7805 See `strongdm.models.SecretStoreHealth`. 7806 ''' 7807 def __init__(self, channel, client): 7808 self.parent = client 7809 self.stub = SecretStoreHealthsStub(channel) 7810 7811 def list(self, filter, *args, timeout=None): 7812 ''' 7813 List reports the health status of node to secret store pairs. 7814 ''' 7815 deadline = None if timeout is None else time.time() + timeout 7816 req = SecretStoreHealthListRequest() 7817 req.meta.CopyFrom(ListRequestMetadata()) 7818 if self.parent.page_limit > 0: 7819 req.meta.limit = self.parent.page_limit 7820 if self.parent.snapshot_datetime is not None: 7821 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7822 7823 req.filter = plumbing.quote_filter_args(filter, *args) 7824 7825 def generator(svc, req): 7826 tries = 0 7827 while True: 7828 t = None if deadline is None else deadline - time.time() 7829 try: 7830 plumbing_response = svc.stub.List( 7831 req, 7832 metadata=svc.parent.get_metadata( 7833 'SecretStoreHealths.List', req), 7834 timeout=t) 7835 except Exception as e: 7836 if self.parent.shouldRetry(tries, e, deadline): 7837 tries += 1 7838 time.sleep( 7839 self.parent.exponentialBackoff(tries, deadline)) 7840 continue 7841 raise plumbing.convert_error_to_porcelain(e) from e 7842 tries = 0 7843 for plumbing_item in plumbing_response.secret_store_healths: 7844 yield plumbing.convert_secret_store_health_to_porcelain( 7845 plumbing_item) 7846 if plumbing_response.meta.next_cursor == '': 7847 break 7848 req.meta.cursor = plumbing_response.meta.next_cursor 7849 7850 return generator(self, req) 7851 7852 def healthcheck(self, secret_store_id, timeout=None): 7853 ''' 7854 Healthcheck triggers a remote healthcheck request for a secret store. It may take minutes 7855 to propagate across a large network of Nodes. The call will return immediately, and the 7856 updated health of the Secret Store can be retrieved via List. 7857 ''' 7858 deadline = None if timeout is None else time.time() + timeout 7859 req = SecretStoreHealthcheckRequest() 7860 7861 req.secret_store_id = (secret_store_id) 7862 tries = 0 7863 plumbing_response = None 7864 while True: 7865 t = None if deadline is None else deadline - time.time() 7866 try: 7867 plumbing_response = self.stub.Healthcheck( 7868 req, 7869 metadata=self.parent.get_metadata( 7870 'SecretStoreHealths.Healthcheck', req), 7871 timeout=t) 7872 except Exception as e: 7873 if self.parent.shouldRetry(tries, e, deadline): 7874 tries += 1 7875 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7876 continue 7877 raise plumbing.convert_error_to_porcelain(e) from e 7878 break 7879 7880 resp = models.SecretStoreHealthcheckResponse() 7881 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7882 plumbing_response.rate_limit) 7883 return resp
SecretStoreHealths exposes health states for secret stores.
See strongdm.models.SecretStoreHealth.
def
list(self, filter, *args, timeout=None)
7811 def list(self, filter, *args, timeout=None): 7812 ''' 7813 List reports the health status of node to secret store pairs. 7814 ''' 7815 deadline = None if timeout is None else time.time() + timeout 7816 req = SecretStoreHealthListRequest() 7817 req.meta.CopyFrom(ListRequestMetadata()) 7818 if self.parent.page_limit > 0: 7819 req.meta.limit = self.parent.page_limit 7820 if self.parent.snapshot_datetime is not None: 7821 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7822 7823 req.filter = plumbing.quote_filter_args(filter, *args) 7824 7825 def generator(svc, req): 7826 tries = 0 7827 while True: 7828 t = None if deadline is None else deadline - time.time() 7829 try: 7830 plumbing_response = svc.stub.List( 7831 req, 7832 metadata=svc.parent.get_metadata( 7833 'SecretStoreHealths.List', req), 7834 timeout=t) 7835 except Exception as e: 7836 if self.parent.shouldRetry(tries, e, deadline): 7837 tries += 1 7838 time.sleep( 7839 self.parent.exponentialBackoff(tries, deadline)) 7840 continue 7841 raise plumbing.convert_error_to_porcelain(e) from e 7842 tries = 0 7843 for plumbing_item in plumbing_response.secret_store_healths: 7844 yield plumbing.convert_secret_store_health_to_porcelain( 7845 plumbing_item) 7846 if plumbing_response.meta.next_cursor == '': 7847 break 7848 req.meta.cursor = plumbing_response.meta.next_cursor 7849 7850 return generator(self, req)
List reports the health status of node to secret store pairs.
def
healthcheck(self, secret_store_id, timeout=None)
7852 def healthcheck(self, secret_store_id, timeout=None): 7853 ''' 7854 Healthcheck triggers a remote healthcheck request for a secret store. It may take minutes 7855 to propagate across a large network of Nodes. The call will return immediately, and the 7856 updated health of the Secret Store can be retrieved via List. 7857 ''' 7858 deadline = None if timeout is None else time.time() + timeout 7859 req = SecretStoreHealthcheckRequest() 7860 7861 req.secret_store_id = (secret_store_id) 7862 tries = 0 7863 plumbing_response = None 7864 while True: 7865 t = None if deadline is None else deadline - time.time() 7866 try: 7867 plumbing_response = self.stub.Healthcheck( 7868 req, 7869 metadata=self.parent.get_metadata( 7870 'SecretStoreHealths.Healthcheck', req), 7871 timeout=t) 7872 except Exception as e: 7873 if self.parent.shouldRetry(tries, e, deadline): 7874 tries += 1 7875 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7876 continue 7877 raise plumbing.convert_error_to_porcelain(e) from e 7878 break 7879 7880 resp = models.SecretStoreHealthcheckResponse() 7881 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7882 plumbing_response.rate_limit) 7883 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:
7886class SecretStoresHistory: 7887 ''' 7888 SecretStoresHistory records all changes to the state of a SecretStore. 7889 See `strongdm.models.SecretStoreHistory`. 7890 ''' 7891 def __init__(self, channel, client): 7892 self.parent = client 7893 self.stub = SecretStoresHistoryStub(channel) 7894 7895 def list(self, filter, *args, timeout=None): 7896 ''' 7897 List gets a list of SecretStoreHistory records matching a given set of criteria. 7898 ''' 7899 deadline = None if timeout is None else time.time() + timeout 7900 req = SecretStoreHistoryListRequest() 7901 req.meta.CopyFrom(ListRequestMetadata()) 7902 if self.parent.page_limit > 0: 7903 req.meta.limit = self.parent.page_limit 7904 if self.parent.snapshot_datetime is not None: 7905 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7906 7907 req.filter = plumbing.quote_filter_args(filter, *args) 7908 7909 def generator(svc, req): 7910 tries = 0 7911 while True: 7912 t = None if deadline is None else deadline - time.time() 7913 try: 7914 plumbing_response = svc.stub.List( 7915 req, 7916 metadata=svc.parent.get_metadata( 7917 'SecretStoresHistory.List', req), 7918 timeout=t) 7919 except Exception as e: 7920 if self.parent.shouldRetry(tries, e, deadline): 7921 tries += 1 7922 time.sleep( 7923 self.parent.exponentialBackoff(tries, deadline)) 7924 continue 7925 raise plumbing.convert_error_to_porcelain(e) from e 7926 tries = 0 7927 for plumbing_item in plumbing_response.history: 7928 yield plumbing.convert_secret_store_history_to_porcelain( 7929 plumbing_item) 7930 if plumbing_response.meta.next_cursor == '': 7931 break 7932 req.meta.cursor = plumbing_response.meta.next_cursor 7933 7934 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)
7895 def list(self, filter, *args, timeout=None): 7896 ''' 7897 List gets a list of SecretStoreHistory records matching a given set of criteria. 7898 ''' 7899 deadline = None if timeout is None else time.time() + timeout 7900 req = SecretStoreHistoryListRequest() 7901 req.meta.CopyFrom(ListRequestMetadata()) 7902 if self.parent.page_limit > 0: 7903 req.meta.limit = self.parent.page_limit 7904 if self.parent.snapshot_datetime is not None: 7905 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7906 7907 req.filter = plumbing.quote_filter_args(filter, *args) 7908 7909 def generator(svc, req): 7910 tries = 0 7911 while True: 7912 t = None if deadline is None else deadline - time.time() 7913 try: 7914 plumbing_response = svc.stub.List( 7915 req, 7916 metadata=svc.parent.get_metadata( 7917 'SecretStoresHistory.List', req), 7918 timeout=t) 7919 except Exception as e: 7920 if self.parent.shouldRetry(tries, e, deadline): 7921 tries += 1 7922 time.sleep( 7923 self.parent.exponentialBackoff(tries, deadline)) 7924 continue 7925 raise plumbing.convert_error_to_porcelain(e) from e 7926 tries = 0 7927 for plumbing_item in plumbing_response.history: 7928 yield plumbing.convert_secret_store_history_to_porcelain( 7929 plumbing_item) 7930 if plumbing_response.meta.next_cursor == '': 7931 break 7932 req.meta.cursor = plumbing_response.meta.next_cursor 7933 7934 return generator(self, req)
List gets a list of SecretStoreHistory records matching a given set of criteria.
class
WorkflowApprovers:
7937class WorkflowApprovers: 7938 ''' 7939 WorkflowApprovers is an account or a role with the ability to approve requests bound to a workflow. 7940 See `strongdm.models.WorkflowApprover`. 7941 ''' 7942 def __init__(self, channel, client): 7943 self.parent = client 7944 self.stub = WorkflowApproversStub(channel) 7945 7946 def create(self, workflow_approver, timeout=None): 7947 ''' 7948 Create creates a new workflow approver 7949 ''' 7950 deadline = None if timeout is None else time.time() + timeout 7951 req = WorkflowApproversCreateRequest() 7952 7953 if workflow_approver is not None: 7954 req.workflow_approver.CopyFrom( 7955 plumbing.convert_workflow_approver_to_plumbing( 7956 workflow_approver)) 7957 tries = 0 7958 plumbing_response = None 7959 while True: 7960 t = None if deadline is None else deadline - time.time() 7961 try: 7962 plumbing_response = self.stub.Create( 7963 req, 7964 metadata=self.parent.get_metadata( 7965 'WorkflowApprovers.Create', req), 7966 timeout=t) 7967 except Exception as e: 7968 if self.parent.shouldRetry(tries, e, deadline): 7969 tries += 1 7970 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7971 continue 7972 raise plumbing.convert_error_to_porcelain(e) from e 7973 break 7974 7975 resp = models.WorkflowApproversCreateResponse() 7976 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7977 plumbing_response.rate_limit) 7978 resp.workflow_approver = plumbing.convert_workflow_approver_to_porcelain( 7979 plumbing_response.workflow_approver) 7980 return resp 7981 7982 def get(self, id, timeout=None): 7983 ''' 7984 Get reads one workflow approver by ID. 7985 ''' 7986 deadline = None if timeout is None else time.time() + timeout 7987 req = WorkflowApproverGetRequest() 7988 if self.parent.snapshot_datetime is not None: 7989 req.meta.CopyFrom(GetRequestMetadata()) 7990 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7991 7992 req.id = (id) 7993 tries = 0 7994 plumbing_response = None 7995 while True: 7996 t = None if deadline is None else deadline - time.time() 7997 try: 7998 plumbing_response = self.stub.Get( 7999 req, 8000 metadata=self.parent.get_metadata('WorkflowApprovers.Get', 8001 req), 8002 timeout=t) 8003 except Exception as e: 8004 if self.parent.shouldRetry(tries, e, deadline): 8005 tries += 1 8006 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8007 continue 8008 raise plumbing.convert_error_to_porcelain(e) from e 8009 break 8010 8011 resp = models.WorkflowApproverGetResponse() 8012 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 8013 plumbing_response.meta) 8014 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8015 plumbing_response.rate_limit) 8016 resp.workflow_approver = plumbing.convert_workflow_approver_to_porcelain( 8017 plumbing_response.workflow_approver) 8018 return resp 8019 8020 def delete(self, id, timeout=None): 8021 ''' 8022 Delete deletes a workflow approver 8023 ''' 8024 deadline = None if timeout is None else time.time() + timeout 8025 req = WorkflowApproversDeleteRequest() 8026 8027 req.id = (id) 8028 tries = 0 8029 plumbing_response = None 8030 while True: 8031 t = None if deadline is None else deadline - time.time() 8032 try: 8033 plumbing_response = self.stub.Delete( 8034 req, 8035 metadata=self.parent.get_metadata( 8036 'WorkflowApprovers.Delete', req), 8037 timeout=t) 8038 except Exception as e: 8039 if self.parent.shouldRetry(tries, e, deadline): 8040 tries += 1 8041 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8042 continue 8043 raise plumbing.convert_error_to_porcelain(e) from e 8044 break 8045 8046 resp = models.WorkflowApproversDeleteResponse() 8047 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8048 plumbing_response.rate_limit) 8049 return resp 8050 8051 def list(self, filter, *args, timeout=None): 8052 ''' 8053 Lists existing workflow approvers. 8054 ''' 8055 deadline = None if timeout is None else time.time() + timeout 8056 req = WorkflowApproversListRequest() 8057 req.meta.CopyFrom(ListRequestMetadata()) 8058 if self.parent.page_limit > 0: 8059 req.meta.limit = self.parent.page_limit 8060 if self.parent.snapshot_datetime is not None: 8061 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8062 8063 req.filter = plumbing.quote_filter_args(filter, *args) 8064 8065 def generator(svc, req): 8066 tries = 0 8067 while True: 8068 t = None if deadline is None else deadline - time.time() 8069 try: 8070 plumbing_response = svc.stub.List( 8071 req, 8072 metadata=svc.parent.get_metadata( 8073 'WorkflowApprovers.List', req), 8074 timeout=t) 8075 except Exception as e: 8076 if self.parent.shouldRetry(tries, e, deadline): 8077 tries += 1 8078 time.sleep( 8079 self.parent.exponentialBackoff(tries, deadline)) 8080 continue 8081 raise plumbing.convert_error_to_porcelain(e) from e 8082 tries = 0 8083 for plumbing_item in plumbing_response.workflow_approvers: 8084 yield plumbing.convert_workflow_approver_to_porcelain( 8085 plumbing_item) 8086 if plumbing_response.meta.next_cursor == '': 8087 break 8088 req.meta.cursor = plumbing_response.meta.next_cursor 8089 8090 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)
7946 def create(self, workflow_approver, timeout=None): 7947 ''' 7948 Create creates a new workflow approver 7949 ''' 7950 deadline = None if timeout is None else time.time() + timeout 7951 req = WorkflowApproversCreateRequest() 7952 7953 if workflow_approver is not None: 7954 req.workflow_approver.CopyFrom( 7955 plumbing.convert_workflow_approver_to_plumbing( 7956 workflow_approver)) 7957 tries = 0 7958 plumbing_response = None 7959 while True: 7960 t = None if deadline is None else deadline - time.time() 7961 try: 7962 plumbing_response = self.stub.Create( 7963 req, 7964 metadata=self.parent.get_metadata( 7965 'WorkflowApprovers.Create', req), 7966 timeout=t) 7967 except Exception as e: 7968 if self.parent.shouldRetry(tries, e, deadline): 7969 tries += 1 7970 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7971 continue 7972 raise plumbing.convert_error_to_porcelain(e) from e 7973 break 7974 7975 resp = models.WorkflowApproversCreateResponse() 7976 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7977 plumbing_response.rate_limit) 7978 resp.workflow_approver = plumbing.convert_workflow_approver_to_porcelain( 7979 plumbing_response.workflow_approver) 7980 return resp
Create creates a new workflow approver
def
get(self, id, timeout=None)
7982 def get(self, id, timeout=None): 7983 ''' 7984 Get reads one workflow approver by ID. 7985 ''' 7986 deadline = None if timeout is None else time.time() + timeout 7987 req = WorkflowApproverGetRequest() 7988 if self.parent.snapshot_datetime is not None: 7989 req.meta.CopyFrom(GetRequestMetadata()) 7990 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7991 7992 req.id = (id) 7993 tries = 0 7994 plumbing_response = None 7995 while True: 7996 t = None if deadline is None else deadline - time.time() 7997 try: 7998 plumbing_response = self.stub.Get( 7999 req, 8000 metadata=self.parent.get_metadata('WorkflowApprovers.Get', 8001 req), 8002 timeout=t) 8003 except Exception as e: 8004 if self.parent.shouldRetry(tries, e, deadline): 8005 tries += 1 8006 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8007 continue 8008 raise plumbing.convert_error_to_porcelain(e) from e 8009 break 8010 8011 resp = models.WorkflowApproverGetResponse() 8012 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 8013 plumbing_response.meta) 8014 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8015 plumbing_response.rate_limit) 8016 resp.workflow_approver = plumbing.convert_workflow_approver_to_porcelain( 8017 plumbing_response.workflow_approver) 8018 return resp
Get reads one workflow approver by ID.
def
delete(self, id, timeout=None)
8020 def delete(self, id, timeout=None): 8021 ''' 8022 Delete deletes a workflow approver 8023 ''' 8024 deadline = None if timeout is None else time.time() + timeout 8025 req = WorkflowApproversDeleteRequest() 8026 8027 req.id = (id) 8028 tries = 0 8029 plumbing_response = None 8030 while True: 8031 t = None if deadline is None else deadline - time.time() 8032 try: 8033 plumbing_response = self.stub.Delete( 8034 req, 8035 metadata=self.parent.get_metadata( 8036 'WorkflowApprovers.Delete', req), 8037 timeout=t) 8038 except Exception as e: 8039 if self.parent.shouldRetry(tries, e, deadline): 8040 tries += 1 8041 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8042 continue 8043 raise plumbing.convert_error_to_porcelain(e) from e 8044 break 8045 8046 resp = models.WorkflowApproversDeleteResponse() 8047 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8048 plumbing_response.rate_limit) 8049 return resp
Delete deletes a workflow approver
def
list(self, filter, *args, timeout=None)
8051 def list(self, filter, *args, timeout=None): 8052 ''' 8053 Lists existing workflow approvers. 8054 ''' 8055 deadline = None if timeout is None else time.time() + timeout 8056 req = WorkflowApproversListRequest() 8057 req.meta.CopyFrom(ListRequestMetadata()) 8058 if self.parent.page_limit > 0: 8059 req.meta.limit = self.parent.page_limit 8060 if self.parent.snapshot_datetime is not None: 8061 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8062 8063 req.filter = plumbing.quote_filter_args(filter, *args) 8064 8065 def generator(svc, req): 8066 tries = 0 8067 while True: 8068 t = None if deadline is None else deadline - time.time() 8069 try: 8070 plumbing_response = svc.stub.List( 8071 req, 8072 metadata=svc.parent.get_metadata( 8073 'WorkflowApprovers.List', req), 8074 timeout=t) 8075 except Exception as e: 8076 if self.parent.shouldRetry(tries, e, deadline): 8077 tries += 1 8078 time.sleep( 8079 self.parent.exponentialBackoff(tries, deadline)) 8080 continue 8081 raise plumbing.convert_error_to_porcelain(e) from e 8082 tries = 0 8083 for plumbing_item in plumbing_response.workflow_approvers: 8084 yield plumbing.convert_workflow_approver_to_porcelain( 8085 plumbing_item) 8086 if plumbing_response.meta.next_cursor == '': 8087 break 8088 req.meta.cursor = plumbing_response.meta.next_cursor 8089 8090 return generator(self, req)
Lists existing workflow approvers.
class
SnapshotWorkflowApprovers:
8093class SnapshotWorkflowApprovers: 8094 ''' 8095 SnapshotWorkflowApprovers exposes the read only methods of the WorkflowApprovers 8096 service for historical queries. 8097 ''' 8098 def __init__(self, workflow_approvers): 8099 self.workflow_approvers = workflow_approvers 8100 8101 def get(self, id, timeout=None): 8102 ''' 8103 Get reads one workflow approver by ID. 8104 ''' 8105 return self.workflow_approvers.get(id, timeout=timeout) 8106 8107 def list(self, filter, *args, timeout=None): 8108 ''' 8109 Lists existing workflow approvers. 8110 ''' 8111 return self.workflow_approvers.list(filter, *args, timeout=timeout)
SnapshotWorkflowApprovers exposes the read only methods of the WorkflowApprovers service for historical queries.
class
WorkflowApproversHistory:
8114class WorkflowApproversHistory: 8115 ''' 8116 WorkflowApproversHistory provides records of all changes to the state of a WorkflowApprover. 8117 See `strongdm.models.WorkflowApproverHistory`. 8118 ''' 8119 def __init__(self, channel, client): 8120 self.parent = client 8121 self.stub = WorkflowApproversHistoryStub(channel) 8122 8123 def list(self, filter, *args, timeout=None): 8124 ''' 8125 List gets a list of WorkflowApproversHistory records matching a given set of criteria. 8126 ''' 8127 deadline = None if timeout is None else time.time() + timeout 8128 req = WorkflowApproversHistoryListRequest() 8129 req.meta.CopyFrom(ListRequestMetadata()) 8130 if self.parent.page_limit > 0: 8131 req.meta.limit = self.parent.page_limit 8132 if self.parent.snapshot_datetime is not None: 8133 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8134 8135 req.filter = plumbing.quote_filter_args(filter, *args) 8136 8137 def generator(svc, req): 8138 tries = 0 8139 while True: 8140 t = None if deadline is None else deadline - time.time() 8141 try: 8142 plumbing_response = svc.stub.List( 8143 req, 8144 metadata=svc.parent.get_metadata( 8145 'WorkflowApproversHistory.List', req), 8146 timeout=t) 8147 except Exception as e: 8148 if self.parent.shouldRetry(tries, e, deadline): 8149 tries += 1 8150 time.sleep( 8151 self.parent.exponentialBackoff(tries, deadline)) 8152 continue 8153 raise plumbing.convert_error_to_porcelain(e) from e 8154 tries = 0 8155 for plumbing_item in plumbing_response.history: 8156 yield plumbing.convert_workflow_approver_history_to_porcelain( 8157 plumbing_item) 8158 if plumbing_response.meta.next_cursor == '': 8159 break 8160 req.meta.cursor = plumbing_response.meta.next_cursor 8161 8162 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)
8123 def list(self, filter, *args, timeout=None): 8124 ''' 8125 List gets a list of WorkflowApproversHistory records matching a given set of criteria. 8126 ''' 8127 deadline = None if timeout is None else time.time() + timeout 8128 req = WorkflowApproversHistoryListRequest() 8129 req.meta.CopyFrom(ListRequestMetadata()) 8130 if self.parent.page_limit > 0: 8131 req.meta.limit = self.parent.page_limit 8132 if self.parent.snapshot_datetime is not None: 8133 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8134 8135 req.filter = plumbing.quote_filter_args(filter, *args) 8136 8137 def generator(svc, req): 8138 tries = 0 8139 while True: 8140 t = None if deadline is None else deadline - time.time() 8141 try: 8142 plumbing_response = svc.stub.List( 8143 req, 8144 metadata=svc.parent.get_metadata( 8145 'WorkflowApproversHistory.List', req), 8146 timeout=t) 8147 except Exception as e: 8148 if self.parent.shouldRetry(tries, e, deadline): 8149 tries += 1 8150 time.sleep( 8151 self.parent.exponentialBackoff(tries, deadline)) 8152 continue 8153 raise plumbing.convert_error_to_porcelain(e) from e 8154 tries = 0 8155 for plumbing_item in plumbing_response.history: 8156 yield plumbing.convert_workflow_approver_history_to_porcelain( 8157 plumbing_item) 8158 if plumbing_response.meta.next_cursor == '': 8159 break 8160 req.meta.cursor = plumbing_response.meta.next_cursor 8161 8162 return generator(self, req)
List gets a list of WorkflowApproversHistory records matching a given set of criteria.
class
WorkflowRoles:
8165class WorkflowRoles: 8166 ''' 8167 WorkflowRole links a role to a workflow. The linked roles indicate which roles a user must be a part of 8168 to request access to a resource via the workflow. 8169 See `strongdm.models.WorkflowRole`. 8170 ''' 8171 def __init__(self, channel, client): 8172 self.parent = client 8173 self.stub = WorkflowRolesStub(channel) 8174 8175 def create(self, workflow_role, timeout=None): 8176 ''' 8177 Create creates a new workflow role 8178 ''' 8179 deadline = None if timeout is None else time.time() + timeout 8180 req = WorkflowRolesCreateRequest() 8181 8182 if workflow_role is not None: 8183 req.workflow_role.CopyFrom( 8184 plumbing.convert_workflow_role_to_plumbing(workflow_role)) 8185 tries = 0 8186 plumbing_response = None 8187 while True: 8188 t = None if deadline is None else deadline - time.time() 8189 try: 8190 plumbing_response = self.stub.Create( 8191 req, 8192 metadata=self.parent.get_metadata('WorkflowRoles.Create', 8193 req), 8194 timeout=t) 8195 except Exception as e: 8196 if self.parent.shouldRetry(tries, e, deadline): 8197 tries += 1 8198 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8199 continue 8200 raise plumbing.convert_error_to_porcelain(e) from e 8201 break 8202 8203 resp = models.WorkflowRolesCreateResponse() 8204 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8205 plumbing_response.rate_limit) 8206 resp.workflow_role = plumbing.convert_workflow_role_to_porcelain( 8207 plumbing_response.workflow_role) 8208 return resp 8209 8210 def get(self, id, timeout=None): 8211 ''' 8212 Get reads one workflow role by ID. 8213 ''' 8214 deadline = None if timeout is None else time.time() + timeout 8215 req = WorkflowRoleGetRequest() 8216 if self.parent.snapshot_datetime is not None: 8217 req.meta.CopyFrom(GetRequestMetadata()) 8218 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8219 8220 req.id = (id) 8221 tries = 0 8222 plumbing_response = None 8223 while True: 8224 t = None if deadline is None else deadline - time.time() 8225 try: 8226 plumbing_response = self.stub.Get( 8227 req, 8228 metadata=self.parent.get_metadata('WorkflowRoles.Get', 8229 req), 8230 timeout=t) 8231 except Exception as e: 8232 if self.parent.shouldRetry(tries, e, deadline): 8233 tries += 1 8234 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8235 continue 8236 raise plumbing.convert_error_to_porcelain(e) from e 8237 break 8238 8239 resp = models.WorkflowRoleGetResponse() 8240 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 8241 plumbing_response.meta) 8242 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8243 plumbing_response.rate_limit) 8244 resp.workflow_role = plumbing.convert_workflow_role_to_porcelain( 8245 plumbing_response.workflow_role) 8246 return resp 8247 8248 def delete(self, id, timeout=None): 8249 ''' 8250 Delete deletes a workflow role 8251 ''' 8252 deadline = None if timeout is None else time.time() + timeout 8253 req = WorkflowRolesDeleteRequest() 8254 8255 req.id = (id) 8256 tries = 0 8257 plumbing_response = None 8258 while True: 8259 t = None if deadline is None else deadline - time.time() 8260 try: 8261 plumbing_response = self.stub.Delete( 8262 req, 8263 metadata=self.parent.get_metadata('WorkflowRoles.Delete', 8264 req), 8265 timeout=t) 8266 except Exception as e: 8267 if self.parent.shouldRetry(tries, e, deadline): 8268 tries += 1 8269 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8270 continue 8271 raise plumbing.convert_error_to_porcelain(e) from e 8272 break 8273 8274 resp = models.WorkflowRolesDeleteResponse() 8275 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8276 plumbing_response.rate_limit) 8277 return resp 8278 8279 def list(self, filter, *args, timeout=None): 8280 ''' 8281 Lists existing workflow roles. 8282 ''' 8283 deadline = None if timeout is None else time.time() + timeout 8284 req = WorkflowRolesListRequest() 8285 req.meta.CopyFrom(ListRequestMetadata()) 8286 if self.parent.page_limit > 0: 8287 req.meta.limit = self.parent.page_limit 8288 if self.parent.snapshot_datetime is not None: 8289 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8290 8291 req.filter = plumbing.quote_filter_args(filter, *args) 8292 8293 def generator(svc, req): 8294 tries = 0 8295 while True: 8296 t = None if deadline is None else deadline - time.time() 8297 try: 8298 plumbing_response = svc.stub.List( 8299 req, 8300 metadata=svc.parent.get_metadata( 8301 'WorkflowRoles.List', req), 8302 timeout=t) 8303 except Exception as e: 8304 if self.parent.shouldRetry(tries, e, deadline): 8305 tries += 1 8306 time.sleep( 8307 self.parent.exponentialBackoff(tries, deadline)) 8308 continue 8309 raise plumbing.convert_error_to_porcelain(e) from e 8310 tries = 0 8311 for plumbing_item in plumbing_response.workflow_role: 8312 yield plumbing.convert_workflow_role_to_porcelain( 8313 plumbing_item) 8314 if plumbing_response.meta.next_cursor == '': 8315 break 8316 req.meta.cursor = plumbing_response.meta.next_cursor 8317 8318 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)
8175 def create(self, workflow_role, timeout=None): 8176 ''' 8177 Create creates a new workflow role 8178 ''' 8179 deadline = None if timeout is None else time.time() + timeout 8180 req = WorkflowRolesCreateRequest() 8181 8182 if workflow_role is not None: 8183 req.workflow_role.CopyFrom( 8184 plumbing.convert_workflow_role_to_plumbing(workflow_role)) 8185 tries = 0 8186 plumbing_response = None 8187 while True: 8188 t = None if deadline is None else deadline - time.time() 8189 try: 8190 plumbing_response = self.stub.Create( 8191 req, 8192 metadata=self.parent.get_metadata('WorkflowRoles.Create', 8193 req), 8194 timeout=t) 8195 except Exception as e: 8196 if self.parent.shouldRetry(tries, e, deadline): 8197 tries += 1 8198 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8199 continue 8200 raise plumbing.convert_error_to_porcelain(e) from e 8201 break 8202 8203 resp = models.WorkflowRolesCreateResponse() 8204 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8205 plumbing_response.rate_limit) 8206 resp.workflow_role = plumbing.convert_workflow_role_to_porcelain( 8207 plumbing_response.workflow_role) 8208 return resp
Create creates a new workflow role
def
get(self, id, timeout=None)
8210 def get(self, id, timeout=None): 8211 ''' 8212 Get reads one workflow role by ID. 8213 ''' 8214 deadline = None if timeout is None else time.time() + timeout 8215 req = WorkflowRoleGetRequest() 8216 if self.parent.snapshot_datetime is not None: 8217 req.meta.CopyFrom(GetRequestMetadata()) 8218 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8219 8220 req.id = (id) 8221 tries = 0 8222 plumbing_response = None 8223 while True: 8224 t = None if deadline is None else deadline - time.time() 8225 try: 8226 plumbing_response = self.stub.Get( 8227 req, 8228 metadata=self.parent.get_metadata('WorkflowRoles.Get', 8229 req), 8230 timeout=t) 8231 except Exception as e: 8232 if self.parent.shouldRetry(tries, e, deadline): 8233 tries += 1 8234 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8235 continue 8236 raise plumbing.convert_error_to_porcelain(e) from e 8237 break 8238 8239 resp = models.WorkflowRoleGetResponse() 8240 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 8241 plumbing_response.meta) 8242 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8243 plumbing_response.rate_limit) 8244 resp.workflow_role = plumbing.convert_workflow_role_to_porcelain( 8245 plumbing_response.workflow_role) 8246 return resp
Get reads one workflow role by ID.
def
delete(self, id, timeout=None)
8248 def delete(self, id, timeout=None): 8249 ''' 8250 Delete deletes a workflow role 8251 ''' 8252 deadline = None if timeout is None else time.time() + timeout 8253 req = WorkflowRolesDeleteRequest() 8254 8255 req.id = (id) 8256 tries = 0 8257 plumbing_response = None 8258 while True: 8259 t = None if deadline is None else deadline - time.time() 8260 try: 8261 plumbing_response = self.stub.Delete( 8262 req, 8263 metadata=self.parent.get_metadata('WorkflowRoles.Delete', 8264 req), 8265 timeout=t) 8266 except Exception as e: 8267 if self.parent.shouldRetry(tries, e, deadline): 8268 tries += 1 8269 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8270 continue 8271 raise plumbing.convert_error_to_porcelain(e) from e 8272 break 8273 8274 resp = models.WorkflowRolesDeleteResponse() 8275 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8276 plumbing_response.rate_limit) 8277 return resp
Delete deletes a workflow role
def
list(self, filter, *args, timeout=None)
8279 def list(self, filter, *args, timeout=None): 8280 ''' 8281 Lists existing workflow roles. 8282 ''' 8283 deadline = None if timeout is None else time.time() + timeout 8284 req = WorkflowRolesListRequest() 8285 req.meta.CopyFrom(ListRequestMetadata()) 8286 if self.parent.page_limit > 0: 8287 req.meta.limit = self.parent.page_limit 8288 if self.parent.snapshot_datetime is not None: 8289 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8290 8291 req.filter = plumbing.quote_filter_args(filter, *args) 8292 8293 def generator(svc, req): 8294 tries = 0 8295 while True: 8296 t = None if deadline is None else deadline - time.time() 8297 try: 8298 plumbing_response = svc.stub.List( 8299 req, 8300 metadata=svc.parent.get_metadata( 8301 'WorkflowRoles.List', req), 8302 timeout=t) 8303 except Exception as e: 8304 if self.parent.shouldRetry(tries, e, deadline): 8305 tries += 1 8306 time.sleep( 8307 self.parent.exponentialBackoff(tries, deadline)) 8308 continue 8309 raise plumbing.convert_error_to_porcelain(e) from e 8310 tries = 0 8311 for plumbing_item in plumbing_response.workflow_role: 8312 yield plumbing.convert_workflow_role_to_porcelain( 8313 plumbing_item) 8314 if plumbing_response.meta.next_cursor == '': 8315 break 8316 req.meta.cursor = plumbing_response.meta.next_cursor 8317 8318 return generator(self, req)
Lists existing workflow roles.
class
SnapshotWorkflowRoles:
8321class SnapshotWorkflowRoles: 8322 ''' 8323 SnapshotWorkflowRoles exposes the read only methods of the WorkflowRoles 8324 service for historical queries. 8325 ''' 8326 def __init__(self, workflow_roles): 8327 self.workflow_roles = workflow_roles 8328 8329 def get(self, id, timeout=None): 8330 ''' 8331 Get reads one workflow role by ID. 8332 ''' 8333 return self.workflow_roles.get(id, timeout=timeout) 8334 8335 def list(self, filter, *args, timeout=None): 8336 ''' 8337 Lists existing workflow roles. 8338 ''' 8339 return self.workflow_roles.list(filter, *args, timeout=timeout)
SnapshotWorkflowRoles exposes the read only methods of the WorkflowRoles service for historical queries.
class
WorkflowRolesHistory:
8342class WorkflowRolesHistory: 8343 ''' 8344 WorkflowRolesHistory provides records of all changes to the state of a WorkflowRole 8345 See `strongdm.models.WorkflowRoleHistory`. 8346 ''' 8347 def __init__(self, channel, client): 8348 self.parent = client 8349 self.stub = WorkflowRolesHistoryStub(channel) 8350 8351 def list(self, filter, *args, timeout=None): 8352 ''' 8353 List gets a list of WorkflowRolesHistory records matching a given set of criteria. 8354 ''' 8355 deadline = None if timeout is None else time.time() + timeout 8356 req = WorkflowRolesHistoryListRequest() 8357 req.meta.CopyFrom(ListRequestMetadata()) 8358 if self.parent.page_limit > 0: 8359 req.meta.limit = self.parent.page_limit 8360 if self.parent.snapshot_datetime is not None: 8361 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8362 8363 req.filter = plumbing.quote_filter_args(filter, *args) 8364 8365 def generator(svc, req): 8366 tries = 0 8367 while True: 8368 t = None if deadline is None else deadline - time.time() 8369 try: 8370 plumbing_response = svc.stub.List( 8371 req, 8372 metadata=svc.parent.get_metadata( 8373 'WorkflowRolesHistory.List', req), 8374 timeout=t) 8375 except Exception as e: 8376 if self.parent.shouldRetry(tries, e, deadline): 8377 tries += 1 8378 time.sleep( 8379 self.parent.exponentialBackoff(tries, deadline)) 8380 continue 8381 raise plumbing.convert_error_to_porcelain(e) from e 8382 tries = 0 8383 for plumbing_item in plumbing_response.history: 8384 yield plumbing.convert_workflow_role_history_to_porcelain( 8385 plumbing_item) 8386 if plumbing_response.meta.next_cursor == '': 8387 break 8388 req.meta.cursor = plumbing_response.meta.next_cursor 8389 8390 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)
8351 def list(self, filter, *args, timeout=None): 8352 ''' 8353 List gets a list of WorkflowRolesHistory records matching a given set of criteria. 8354 ''' 8355 deadline = None if timeout is None else time.time() + timeout 8356 req = WorkflowRolesHistoryListRequest() 8357 req.meta.CopyFrom(ListRequestMetadata()) 8358 if self.parent.page_limit > 0: 8359 req.meta.limit = self.parent.page_limit 8360 if self.parent.snapshot_datetime is not None: 8361 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8362 8363 req.filter = plumbing.quote_filter_args(filter, *args) 8364 8365 def generator(svc, req): 8366 tries = 0 8367 while True: 8368 t = None if deadline is None else deadline - time.time() 8369 try: 8370 plumbing_response = svc.stub.List( 8371 req, 8372 metadata=svc.parent.get_metadata( 8373 'WorkflowRolesHistory.List', req), 8374 timeout=t) 8375 except Exception as e: 8376 if self.parent.shouldRetry(tries, e, deadline): 8377 tries += 1 8378 time.sleep( 8379 self.parent.exponentialBackoff(tries, deadline)) 8380 continue 8381 raise plumbing.convert_error_to_porcelain(e) from e 8382 tries = 0 8383 for plumbing_item in plumbing_response.history: 8384 yield plumbing.convert_workflow_role_history_to_porcelain( 8385 plumbing_item) 8386 if plumbing_response.meta.next_cursor == '': 8387 break 8388 req.meta.cursor = plumbing_response.meta.next_cursor 8389 8390 return generator(self, req)
List gets a list of WorkflowRolesHistory records matching a given set of criteria.
class
Workflows:
8393class Workflows: 8394 ''' 8395 Workflows are the collection of rules that define the resources to which access can be requested, 8396 the users that can request that access, and the mechanism for approving those requests which can either 8397 be automatic approval or a set of users authorized to approve the requests. 8398 See `strongdm.models.Workflow`. 8399 ''' 8400 def __init__(self, channel, client): 8401 self.parent = client 8402 self.stub = WorkflowsStub(channel) 8403 8404 def create(self, workflow, timeout=None): 8405 ''' 8406 Create creates a new workflow and requires a name for the workflow. 8407 ''' 8408 deadline = None if timeout is None else time.time() + timeout 8409 req = WorkflowCreateRequest() 8410 8411 if workflow is not None: 8412 req.workflow.CopyFrom( 8413 plumbing.convert_workflow_to_plumbing(workflow)) 8414 tries = 0 8415 plumbing_response = None 8416 while True: 8417 t = None if deadline is None else deadline - time.time() 8418 try: 8419 plumbing_response = self.stub.Create( 8420 req, 8421 metadata=self.parent.get_metadata('Workflows.Create', req), 8422 timeout=t) 8423 except Exception as e: 8424 if self.parent.shouldRetry(tries, e, deadline): 8425 tries += 1 8426 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8427 continue 8428 raise plumbing.convert_error_to_porcelain(e) from e 8429 break 8430 8431 resp = models.WorkflowCreateResponse() 8432 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8433 plumbing_response.rate_limit) 8434 resp.workflow = plumbing.convert_workflow_to_porcelain( 8435 plumbing_response.workflow) 8436 return resp 8437 8438 def get(self, id, timeout=None): 8439 ''' 8440 Get reads one workflow by ID. 8441 ''' 8442 deadline = None if timeout is None else time.time() + timeout 8443 req = WorkflowGetRequest() 8444 if self.parent.snapshot_datetime is not None: 8445 req.meta.CopyFrom(GetRequestMetadata()) 8446 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8447 8448 req.id = (id) 8449 tries = 0 8450 plumbing_response = None 8451 while True: 8452 t = None if deadline is None else deadline - time.time() 8453 try: 8454 plumbing_response = self.stub.Get( 8455 req, 8456 metadata=self.parent.get_metadata('Workflows.Get', req), 8457 timeout=t) 8458 except Exception as e: 8459 if self.parent.shouldRetry(tries, e, deadline): 8460 tries += 1 8461 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8462 continue 8463 raise plumbing.convert_error_to_porcelain(e) from e 8464 break 8465 8466 resp = models.WorkflowGetResponse() 8467 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 8468 plumbing_response.meta) 8469 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8470 plumbing_response.rate_limit) 8471 resp.workflow = plumbing.convert_workflow_to_porcelain( 8472 plumbing_response.workflow) 8473 return resp 8474 8475 def delete(self, id, timeout=None): 8476 ''' 8477 Delete deletes an existing workflow. 8478 ''' 8479 deadline = None if timeout is None else time.time() + timeout 8480 req = WorkflowDeleteRequest() 8481 8482 req.id = (id) 8483 tries = 0 8484 plumbing_response = None 8485 while True: 8486 t = None if deadline is None else deadline - time.time() 8487 try: 8488 plumbing_response = self.stub.Delete( 8489 req, 8490 metadata=self.parent.get_metadata('Workflows.Delete', req), 8491 timeout=t) 8492 except Exception as e: 8493 if self.parent.shouldRetry(tries, e, deadline): 8494 tries += 1 8495 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8496 continue 8497 raise plumbing.convert_error_to_porcelain(e) from e 8498 break 8499 8500 resp = models.WorkflowDeleteResponse() 8501 resp.id = (plumbing_response.id) 8502 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8503 plumbing_response.rate_limit) 8504 return resp 8505 8506 def update(self, workflow, timeout=None): 8507 ''' 8508 Update updates an existing workflow. 8509 ''' 8510 deadline = None if timeout is None else time.time() + timeout 8511 req = WorkflowUpdateRequest() 8512 8513 if workflow is not None: 8514 req.workflow.CopyFrom( 8515 plumbing.convert_workflow_to_plumbing(workflow)) 8516 tries = 0 8517 plumbing_response = None 8518 while True: 8519 t = None if deadline is None else deadline - time.time() 8520 try: 8521 plumbing_response = self.stub.Update( 8522 req, 8523 metadata=self.parent.get_metadata('Workflows.Update', req), 8524 timeout=t) 8525 except Exception as e: 8526 if self.parent.shouldRetry(tries, e, deadline): 8527 tries += 1 8528 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8529 continue 8530 raise plumbing.convert_error_to_porcelain(e) from e 8531 break 8532 8533 resp = models.WorkflowUpdateResponse() 8534 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8535 plumbing_response.rate_limit) 8536 resp.workflow = plumbing.convert_workflow_to_porcelain( 8537 plumbing_response.workflow) 8538 return resp 8539 8540 def list(self, filter, *args, timeout=None): 8541 ''' 8542 Lists existing workflows. 8543 ''' 8544 deadline = None if timeout is None else time.time() + timeout 8545 req = WorkflowListRequest() 8546 req.meta.CopyFrom(ListRequestMetadata()) 8547 if self.parent.page_limit > 0: 8548 req.meta.limit = self.parent.page_limit 8549 if self.parent.snapshot_datetime is not None: 8550 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8551 8552 req.filter = plumbing.quote_filter_args(filter, *args) 8553 8554 def generator(svc, req): 8555 tries = 0 8556 while True: 8557 t = None if deadline is None else deadline - time.time() 8558 try: 8559 plumbing_response = svc.stub.List( 8560 req, 8561 metadata=svc.parent.get_metadata( 8562 'Workflows.List', req), 8563 timeout=t) 8564 except Exception as e: 8565 if self.parent.shouldRetry(tries, e, deadline): 8566 tries += 1 8567 time.sleep( 8568 self.parent.exponentialBackoff(tries, deadline)) 8569 continue 8570 raise plumbing.convert_error_to_porcelain(e) from e 8571 tries = 0 8572 for plumbing_item in plumbing_response.workflows: 8573 yield plumbing.convert_workflow_to_porcelain(plumbing_item) 8574 if plumbing_response.meta.next_cursor == '': 8575 break 8576 req.meta.cursor = plumbing_response.meta.next_cursor 8577 8578 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)
8404 def create(self, workflow, timeout=None): 8405 ''' 8406 Create creates a new workflow and requires a name for the workflow. 8407 ''' 8408 deadline = None if timeout is None else time.time() + timeout 8409 req = WorkflowCreateRequest() 8410 8411 if workflow is not None: 8412 req.workflow.CopyFrom( 8413 plumbing.convert_workflow_to_plumbing(workflow)) 8414 tries = 0 8415 plumbing_response = None 8416 while True: 8417 t = None if deadline is None else deadline - time.time() 8418 try: 8419 plumbing_response = self.stub.Create( 8420 req, 8421 metadata=self.parent.get_metadata('Workflows.Create', req), 8422 timeout=t) 8423 except Exception as e: 8424 if self.parent.shouldRetry(tries, e, deadline): 8425 tries += 1 8426 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8427 continue 8428 raise plumbing.convert_error_to_porcelain(e) from e 8429 break 8430 8431 resp = models.WorkflowCreateResponse() 8432 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8433 plumbing_response.rate_limit) 8434 resp.workflow = plumbing.convert_workflow_to_porcelain( 8435 plumbing_response.workflow) 8436 return resp
Create creates a new workflow and requires a name for the workflow.
def
get(self, id, timeout=None)
8438 def get(self, id, timeout=None): 8439 ''' 8440 Get reads one workflow by ID. 8441 ''' 8442 deadline = None if timeout is None else time.time() + timeout 8443 req = WorkflowGetRequest() 8444 if self.parent.snapshot_datetime is not None: 8445 req.meta.CopyFrom(GetRequestMetadata()) 8446 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8447 8448 req.id = (id) 8449 tries = 0 8450 plumbing_response = None 8451 while True: 8452 t = None if deadline is None else deadline - time.time() 8453 try: 8454 plumbing_response = self.stub.Get( 8455 req, 8456 metadata=self.parent.get_metadata('Workflows.Get', req), 8457 timeout=t) 8458 except Exception as e: 8459 if self.parent.shouldRetry(tries, e, deadline): 8460 tries += 1 8461 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8462 continue 8463 raise plumbing.convert_error_to_porcelain(e) from e 8464 break 8465 8466 resp = models.WorkflowGetResponse() 8467 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 8468 plumbing_response.meta) 8469 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8470 plumbing_response.rate_limit) 8471 resp.workflow = plumbing.convert_workflow_to_porcelain( 8472 plumbing_response.workflow) 8473 return resp
Get reads one workflow by ID.
def
delete(self, id, timeout=None)
8475 def delete(self, id, timeout=None): 8476 ''' 8477 Delete deletes an existing workflow. 8478 ''' 8479 deadline = None if timeout is None else time.time() + timeout 8480 req = WorkflowDeleteRequest() 8481 8482 req.id = (id) 8483 tries = 0 8484 plumbing_response = None 8485 while True: 8486 t = None if deadline is None else deadline - time.time() 8487 try: 8488 plumbing_response = self.stub.Delete( 8489 req, 8490 metadata=self.parent.get_metadata('Workflows.Delete', req), 8491 timeout=t) 8492 except Exception as e: 8493 if self.parent.shouldRetry(tries, e, deadline): 8494 tries += 1 8495 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8496 continue 8497 raise plumbing.convert_error_to_porcelain(e) from e 8498 break 8499 8500 resp = models.WorkflowDeleteResponse() 8501 resp.id = (plumbing_response.id) 8502 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8503 plumbing_response.rate_limit) 8504 return resp
Delete deletes an existing workflow.
def
update(self, workflow, timeout=None)
8506 def update(self, workflow, timeout=None): 8507 ''' 8508 Update updates an existing workflow. 8509 ''' 8510 deadline = None if timeout is None else time.time() + timeout 8511 req = WorkflowUpdateRequest() 8512 8513 if workflow is not None: 8514 req.workflow.CopyFrom( 8515 plumbing.convert_workflow_to_plumbing(workflow)) 8516 tries = 0 8517 plumbing_response = None 8518 while True: 8519 t = None if deadline is None else deadline - time.time() 8520 try: 8521 plumbing_response = self.stub.Update( 8522 req, 8523 metadata=self.parent.get_metadata('Workflows.Update', req), 8524 timeout=t) 8525 except Exception as e: 8526 if self.parent.shouldRetry(tries, e, deadline): 8527 tries += 1 8528 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8529 continue 8530 raise plumbing.convert_error_to_porcelain(e) from e 8531 break 8532 8533 resp = models.WorkflowUpdateResponse() 8534 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8535 plumbing_response.rate_limit) 8536 resp.workflow = plumbing.convert_workflow_to_porcelain( 8537 plumbing_response.workflow) 8538 return resp
Update updates an existing workflow.
def
list(self, filter, *args, timeout=None)
8540 def list(self, filter, *args, timeout=None): 8541 ''' 8542 Lists existing workflows. 8543 ''' 8544 deadline = None if timeout is None else time.time() + timeout 8545 req = WorkflowListRequest() 8546 req.meta.CopyFrom(ListRequestMetadata()) 8547 if self.parent.page_limit > 0: 8548 req.meta.limit = self.parent.page_limit 8549 if self.parent.snapshot_datetime is not None: 8550 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8551 8552 req.filter = plumbing.quote_filter_args(filter, *args) 8553 8554 def generator(svc, req): 8555 tries = 0 8556 while True: 8557 t = None if deadline is None else deadline - time.time() 8558 try: 8559 plumbing_response = svc.stub.List( 8560 req, 8561 metadata=svc.parent.get_metadata( 8562 'Workflows.List', req), 8563 timeout=t) 8564 except Exception as e: 8565 if self.parent.shouldRetry(tries, e, deadline): 8566 tries += 1 8567 time.sleep( 8568 self.parent.exponentialBackoff(tries, deadline)) 8569 continue 8570 raise plumbing.convert_error_to_porcelain(e) from e 8571 tries = 0 8572 for plumbing_item in plumbing_response.workflows: 8573 yield plumbing.convert_workflow_to_porcelain(plumbing_item) 8574 if plumbing_response.meta.next_cursor == '': 8575 break 8576 req.meta.cursor = plumbing_response.meta.next_cursor 8577 8578 return generator(self, req)
Lists existing workflows.
class
SnapshotWorkflows:
8581class SnapshotWorkflows: 8582 ''' 8583 SnapshotWorkflows exposes the read only methods of the Workflows 8584 service for historical queries. 8585 ''' 8586 def __init__(self, workflows): 8587 self.workflows = workflows 8588 8589 def get(self, id, timeout=None): 8590 ''' 8591 Get reads one workflow by ID. 8592 ''' 8593 return self.workflows.get(id, timeout=timeout) 8594 8595 def list(self, filter, *args, timeout=None): 8596 ''' 8597 Lists existing workflows. 8598 ''' 8599 return self.workflows.list(filter, *args, timeout=timeout)
SnapshotWorkflows exposes the read only methods of the Workflows service for historical queries.
class
WorkflowsHistory:
8602class WorkflowsHistory: 8603 ''' 8604 WorkflowsHistory provides records of all changes to the state of a Workflow. 8605 See `strongdm.models.WorkflowHistory`. 8606 ''' 8607 def __init__(self, channel, client): 8608 self.parent = client 8609 self.stub = WorkflowsHistoryStub(channel) 8610 8611 def list(self, filter, *args, timeout=None): 8612 ''' 8613 List gets a list of WorkflowHistory records matching a given set of criteria. 8614 ''' 8615 deadline = None if timeout is None else time.time() + timeout 8616 req = WorkflowHistoryListRequest() 8617 req.meta.CopyFrom(ListRequestMetadata()) 8618 if self.parent.page_limit > 0: 8619 req.meta.limit = self.parent.page_limit 8620 if self.parent.snapshot_datetime is not None: 8621 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8622 8623 req.filter = plumbing.quote_filter_args(filter, *args) 8624 8625 def generator(svc, req): 8626 tries = 0 8627 while True: 8628 t = None if deadline is None else deadline - time.time() 8629 try: 8630 plumbing_response = svc.stub.List( 8631 req, 8632 metadata=svc.parent.get_metadata( 8633 'WorkflowsHistory.List', req), 8634 timeout=t) 8635 except Exception as e: 8636 if self.parent.shouldRetry(tries, e, deadline): 8637 tries += 1 8638 time.sleep( 8639 self.parent.exponentialBackoff(tries, deadline)) 8640 continue 8641 raise plumbing.convert_error_to_porcelain(e) from e 8642 tries = 0 8643 for plumbing_item in plumbing_response.history: 8644 yield plumbing.convert_workflow_history_to_porcelain( 8645 plumbing_item) 8646 if plumbing_response.meta.next_cursor == '': 8647 break 8648 req.meta.cursor = plumbing_response.meta.next_cursor 8649 8650 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)
8611 def list(self, filter, *args, timeout=None): 8612 ''' 8613 List gets a list of WorkflowHistory records matching a given set of criteria. 8614 ''' 8615 deadline = None if timeout is None else time.time() + timeout 8616 req = WorkflowHistoryListRequest() 8617 req.meta.CopyFrom(ListRequestMetadata()) 8618 if self.parent.page_limit > 0: 8619 req.meta.limit = self.parent.page_limit 8620 if self.parent.snapshot_datetime is not None: 8621 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8622 8623 req.filter = plumbing.quote_filter_args(filter, *args) 8624 8625 def generator(svc, req): 8626 tries = 0 8627 while True: 8628 t = None if deadline is None else deadline - time.time() 8629 try: 8630 plumbing_response = svc.stub.List( 8631 req, 8632 metadata=svc.parent.get_metadata( 8633 'WorkflowsHistory.List', req), 8634 timeout=t) 8635 except Exception as e: 8636 if self.parent.shouldRetry(tries, e, deadline): 8637 tries += 1 8638 time.sleep( 8639 self.parent.exponentialBackoff(tries, deadline)) 8640 continue 8641 raise plumbing.convert_error_to_porcelain(e) from e 8642 tries = 0 8643 for plumbing_item in plumbing_response.history: 8644 yield plumbing.convert_workflow_history_to_porcelain( 8645 plumbing_item) 8646 if plumbing_response.meta.next_cursor == '': 8647 break 8648 req.meta.cursor = plumbing_response.meta.next_cursor 8649 8650 return generator(self, req)
List gets a list of WorkflowHistory records matching a given set of criteria.