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 .control_panel_pb2 import * 74from .control_panel_pb2_grpc import * 75from .discovery_connectors_pb2 import * 76from .discovery_connectors_pb2_grpc import * 77from .roles_pb2 import * 78from .roles_pb2_grpc import * 79from .groups_pb2 import * 80from .groups_pb2_grpc import * 81from .groups_history_pb2 import * 82from .groups_history_pb2_grpc import * 83from .groups_roles_pb2 import * 84from .groups_roles_pb2_grpc import * 85from .groups_roles_history_pb2 import * 86from .groups_roles_history_pb2_grpc import * 87from .health_checks_pb2 import * 88from .health_checks_pb2_grpc import * 89from .identity_aliases_pb2 import * 90from .identity_aliases_pb2_grpc import * 91from .identity_aliases_history_pb2 import * 92from .identity_aliases_history_pb2_grpc import * 93from .identity_sets_pb2 import * 94from .identity_sets_pb2_grpc import * 95from .identity_sets_history_pb2 import * 96from .identity_sets_history_pb2_grpc import * 97from .managed_secrets_pb2 import * 98from .managed_secrets_pb2_grpc import * 99from .nodes_pb2 import * 100from .nodes_pb2_grpc import * 101from .nodes_history_pb2 import * 102from .nodes_history_pb2_grpc import * 103from .organization_history_pb2 import * 104from .organization_history_pb2_grpc import * 105from .peering_group_nodes_pb2 import * 106from .peering_group_nodes_pb2_grpc import * 107from .peering_group_peers_pb2 import * 108from .peering_group_peers_pb2_grpc import * 109from .peering_group_resources_pb2 import * 110from .peering_group_resources_pb2_grpc import * 111from .peering_groups_pb2 import * 112from .peering_groups_pb2_grpc import * 113from .policies_pb2 import * 114from .policies_pb2_grpc import * 115from .policies_history_pb2 import * 116from .policies_history_pb2_grpc import * 117from .proxy_cluster_keys_pb2 import * 118from .proxy_cluster_keys_pb2_grpc import * 119from .queries_pb2 import * 120from .queries_pb2_grpc import * 121from .remote_identities_pb2 import * 122from .remote_identities_pb2_grpc import * 123from .remote_identities_history_pb2 import * 124from .remote_identities_history_pb2_grpc import * 125from .remote_identity_groups_pb2 import * 126from .remote_identity_groups_pb2_grpc import * 127from .remote_identity_groups_history_pb2 import * 128from .remote_identity_groups_history_pb2_grpc import * 129from .replays_pb2 import * 130from .replays_pb2_grpc import * 131from .resources_pb2 import * 132from .resources_pb2_grpc import * 133from .resources_history_pb2 import * 134from .resources_history_pb2_grpc import * 135from .role_resources_pb2 import * 136from .role_resources_pb2_grpc import * 137from .role_resources_history_pb2 import * 138from .role_resources_history_pb2_grpc import * 139from .roles_history_pb2 import * 140from .roles_history_pb2_grpc import * 141from .secret_engine_policy_pb2 import * 142from .secret_engine_policy_pb2_grpc import * 143from .secret_engine_types_pb2 import * 144from .secret_engine_types_pb2_grpc import * 145from .secret_store_types_pb2 import * 146from .secret_store_types_pb2_grpc import * 147from .secret_stores_pb2 import * 148from .secret_stores_pb2_grpc import * 149from .secret_engines_pb2 import * 150from .secret_engines_pb2_grpc import * 151from .secret_store_healths_pb2 import * 152from .secret_store_healths_pb2_grpc import * 153from .secret_stores_history_pb2 import * 154from .secret_stores_history_pb2_grpc import * 155from .workflow_approvers_pb2 import * 156from .workflow_approvers_pb2_grpc import * 157from .workflow_approvers_history_pb2 import * 158from .workflow_approvers_history_pb2_grpc import * 159from .workflow_roles_pb2 import * 160from .workflow_roles_pb2_grpc import * 161from .workflow_roles_history_pb2 import * 162from .workflow_roles_history_pb2_grpc import * 163from .workflows_pb2 import * 164from .workflows_pb2_grpc import * 165from .workflows_history_pb2 import * 166from .workflows_history_pb2_grpc import * 167import warnings 168import functools 169import time 170 171 172def deprecated(func): 173 """This is a decorator which can be used to mark functions 174 as deprecated. It will result in a warning being emitted 175 when the function is used.""" 176 @functools.wraps(func) 177 def new_func(*args, **kwargs): 178 warnings.warn("Call to deprecated function {}.".format(func.__name__), 179 category=DeprecationWarning, 180 stacklevel=2) 181 return func(*args, **kwargs) 182 183 return new_func 184 185 186class AccessRequests: 187 ''' 188 AccessRequests are requests for access to a resource that may match a Workflow. 189 See `strongdm.models.AccessRequest`. 190 ''' 191 def __init__(self, channel, client): 192 self.parent = client 193 self.stub = AccessRequestsStub(channel) 194 195 def list(self, filter, *args, timeout=None): 196 ''' 197 Lists existing access requests. 198 ''' 199 deadline = None if timeout is None else time.time() + timeout 200 req = AccessRequestListRequest() 201 req.meta.CopyFrom(ListRequestMetadata()) 202 if self.parent.page_limit > 0: 203 req.meta.limit = self.parent.page_limit 204 if self.parent.snapshot_datetime is not None: 205 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 206 207 req.filter = plumbing.quote_filter_args(filter, *args) 208 209 def generator(svc, req): 210 tries = 0 211 while True: 212 t = None if deadline is None else deadline - time.time() 213 try: 214 plumbing_response = svc.stub.List( 215 req, 216 metadata=svc.parent.get_metadata( 217 'AccessRequests.List', req), 218 timeout=t) 219 except Exception as e: 220 if self.parent.shouldRetry(tries, e, deadline): 221 tries += 1 222 time.sleep( 223 self.parent.exponentialBackoff(tries, deadline)) 224 continue 225 raise plumbing.convert_error_to_porcelain(e) from e 226 tries = 0 227 for plumbing_item in plumbing_response.access_requests: 228 yield plumbing.convert_access_request_to_porcelain( 229 plumbing_item) 230 if plumbing_response.meta.next_cursor == '': 231 break 232 req.meta.cursor = plumbing_response.meta.next_cursor 233 234 return generator(self, req) 235 236 237class SnapshotAccessRequests: 238 ''' 239 SnapshotAccessRequests exposes the read only methods of the AccessRequests 240 service for historical queries. 241 ''' 242 def __init__(self, access_requests): 243 self.access_requests = access_requests 244 245 def list(self, filter, *args, timeout=None): 246 ''' 247 Lists existing access requests. 248 ''' 249 return self.access_requests.list(filter, *args, timeout=timeout) 250 251 252class AccessRequestEventsHistory: 253 ''' 254 AccessRequestEventsHistory provides records of all changes to the state of an AccessRequest. 255 See `strongdm.models.AccessRequestEventHistory`. 256 ''' 257 def __init__(self, channel, client): 258 self.parent = client 259 self.stub = AccessRequestEventsHistoryStub(channel) 260 261 def list(self, filter, *args, timeout=None): 262 ''' 263 List gets a list of AccessRequestEventHistory records matching a given set of criteria. 264 ''' 265 deadline = None if timeout is None else time.time() + timeout 266 req = AccessRequestEventHistoryListRequest() 267 req.meta.CopyFrom(ListRequestMetadata()) 268 if self.parent.page_limit > 0: 269 req.meta.limit = self.parent.page_limit 270 if self.parent.snapshot_datetime is not None: 271 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 272 273 req.filter = plumbing.quote_filter_args(filter, *args) 274 275 def generator(svc, req): 276 tries = 0 277 while True: 278 t = None if deadline is None else deadline - time.time() 279 try: 280 plumbing_response = svc.stub.List( 281 req, 282 metadata=svc.parent.get_metadata( 283 'AccessRequestEventsHistory.List', req), 284 timeout=t) 285 except Exception as e: 286 if self.parent.shouldRetry(tries, e, deadline): 287 tries += 1 288 time.sleep( 289 self.parent.exponentialBackoff(tries, deadline)) 290 continue 291 raise plumbing.convert_error_to_porcelain(e) from e 292 tries = 0 293 for plumbing_item in plumbing_response.history: 294 yield plumbing.convert_access_request_event_history_to_porcelain( 295 plumbing_item) 296 if plumbing_response.meta.next_cursor == '': 297 break 298 req.meta.cursor = plumbing_response.meta.next_cursor 299 300 return generator(self, req) 301 302 303class AccessRequestsHistory: 304 ''' 305 AccessRequestsHistory provides records of all changes to the state of an AccessRequest. 306 See `strongdm.models.AccessRequestHistory`. 307 ''' 308 def __init__(self, channel, client): 309 self.parent = client 310 self.stub = AccessRequestsHistoryStub(channel) 311 312 def list(self, filter, *args, timeout=None): 313 ''' 314 List gets a list of AccessRequestHistory records matching a given set of criteria. 315 ''' 316 deadline = None if timeout is None else time.time() + timeout 317 req = AccessRequestHistoryListRequest() 318 req.meta.CopyFrom(ListRequestMetadata()) 319 if self.parent.page_limit > 0: 320 req.meta.limit = self.parent.page_limit 321 if self.parent.snapshot_datetime is not None: 322 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 323 324 req.filter = plumbing.quote_filter_args(filter, *args) 325 326 def generator(svc, req): 327 tries = 0 328 while True: 329 t = None if deadline is None else deadline - time.time() 330 try: 331 plumbing_response = svc.stub.List( 332 req, 333 metadata=svc.parent.get_metadata( 334 'AccessRequestsHistory.List', req), 335 timeout=t) 336 except Exception as e: 337 if self.parent.shouldRetry(tries, e, deadline): 338 tries += 1 339 time.sleep( 340 self.parent.exponentialBackoff(tries, deadline)) 341 continue 342 raise plumbing.convert_error_to_porcelain(e) from e 343 tries = 0 344 for plumbing_item in plumbing_response.history: 345 yield plumbing.convert_access_request_history_to_porcelain( 346 plumbing_item) 347 if plumbing_response.meta.next_cursor == '': 348 break 349 req.meta.cursor = plumbing_response.meta.next_cursor 350 351 return generator(self, req) 352 353 354class AccountAttachments: 355 ''' 356 AccountAttachments assign an account to a role. 357 See `strongdm.models.AccountAttachment`. 358 ''' 359 def __init__(self, channel, client): 360 self.parent = client 361 self.stub = AccountAttachmentsStub(channel) 362 363 def create(self, account_attachment, timeout=None): 364 ''' 365 Create registers a new AccountAttachment. 366 ''' 367 deadline = None if timeout is None else time.time() + timeout 368 req = AccountAttachmentCreateRequest() 369 370 if account_attachment is not None: 371 req.account_attachment.CopyFrom( 372 plumbing.convert_account_attachment_to_plumbing( 373 account_attachment)) 374 tries = 0 375 plumbing_response = None 376 while True: 377 t = None if deadline is None else deadline - time.time() 378 try: 379 plumbing_response = self.stub.Create( 380 req, 381 metadata=self.parent.get_metadata( 382 'AccountAttachments.Create', req), 383 timeout=t) 384 except Exception as e: 385 if self.parent.shouldRetry(tries, e, deadline): 386 tries += 1 387 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 388 continue 389 raise plumbing.convert_error_to_porcelain(e) from e 390 break 391 392 resp = models.AccountAttachmentCreateResponse() 393 resp.account_attachment = plumbing.convert_account_attachment_to_porcelain( 394 plumbing_response.account_attachment) 395 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 396 plumbing_response.meta) 397 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 398 plumbing_response.rate_limit) 399 return resp 400 401 def get(self, id, timeout=None): 402 ''' 403 Get reads one AccountAttachment by ID. 404 ''' 405 deadline = None if timeout is None else time.time() + timeout 406 req = AccountAttachmentGetRequest() 407 if self.parent.snapshot_datetime is not None: 408 req.meta.CopyFrom(GetRequestMetadata()) 409 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 410 411 req.id = (id) 412 tries = 0 413 plumbing_response = None 414 while True: 415 t = None if deadline is None else deadline - time.time() 416 try: 417 plumbing_response = self.stub.Get( 418 req, 419 metadata=self.parent.get_metadata('AccountAttachments.Get', 420 req), 421 timeout=t) 422 except Exception as e: 423 if self.parent.shouldRetry(tries, e, deadline): 424 tries += 1 425 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 426 continue 427 raise plumbing.convert_error_to_porcelain(e) from e 428 break 429 430 resp = models.AccountAttachmentGetResponse() 431 resp.account_attachment = plumbing.convert_account_attachment_to_porcelain( 432 plumbing_response.account_attachment) 433 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 434 plumbing_response.meta) 435 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 436 plumbing_response.rate_limit) 437 return resp 438 439 def delete(self, id, timeout=None): 440 ''' 441 Delete removes a AccountAttachment by ID. 442 ''' 443 deadline = None if timeout is None else time.time() + timeout 444 req = AccountAttachmentDeleteRequest() 445 446 req.id = (id) 447 tries = 0 448 plumbing_response = None 449 while True: 450 t = None if deadline is None else deadline - time.time() 451 try: 452 plumbing_response = self.stub.Delete( 453 req, 454 metadata=self.parent.get_metadata( 455 'AccountAttachments.Delete', req), 456 timeout=t) 457 except Exception as e: 458 if self.parent.shouldRetry(tries, e, deadline): 459 tries += 1 460 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 461 continue 462 raise plumbing.convert_error_to_porcelain(e) from e 463 break 464 465 resp = models.AccountAttachmentDeleteResponse() 466 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 467 plumbing_response.meta) 468 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 469 plumbing_response.rate_limit) 470 return resp 471 472 def list(self, filter, *args, timeout=None): 473 ''' 474 List gets a list of AccountAttachments matching a given set of criteria. 475 ''' 476 deadline = None if timeout is None else time.time() + timeout 477 req = AccountAttachmentListRequest() 478 req.meta.CopyFrom(ListRequestMetadata()) 479 if self.parent.page_limit > 0: 480 req.meta.limit = self.parent.page_limit 481 if self.parent.snapshot_datetime is not None: 482 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 483 484 req.filter = plumbing.quote_filter_args(filter, *args) 485 486 def generator(svc, req): 487 tries = 0 488 while True: 489 t = None if deadline is None else deadline - time.time() 490 try: 491 plumbing_response = svc.stub.List( 492 req, 493 metadata=svc.parent.get_metadata( 494 'AccountAttachments.List', req), 495 timeout=t) 496 except Exception as e: 497 if self.parent.shouldRetry(tries, e, deadline): 498 tries += 1 499 time.sleep( 500 self.parent.exponentialBackoff(tries, deadline)) 501 continue 502 raise plumbing.convert_error_to_porcelain(e) from e 503 tries = 0 504 for plumbing_item in plumbing_response.account_attachments: 505 yield plumbing.convert_account_attachment_to_porcelain( 506 plumbing_item) 507 if plumbing_response.meta.next_cursor == '': 508 break 509 req.meta.cursor = plumbing_response.meta.next_cursor 510 511 return generator(self, req) 512 513 514class SnapshotAccountAttachments: 515 ''' 516 SnapshotAccountAttachments exposes the read only methods of the AccountAttachments 517 service for historical queries. 518 ''' 519 def __init__(self, account_attachments): 520 self.account_attachments = account_attachments 521 522 def get(self, id, timeout=None): 523 ''' 524 Get reads one AccountAttachment by ID. 525 ''' 526 return self.account_attachments.get(id, timeout=timeout) 527 528 def list(self, filter, *args, timeout=None): 529 ''' 530 List gets a list of AccountAttachments matching a given set of criteria. 531 ''' 532 return self.account_attachments.list(filter, *args, timeout=timeout) 533 534 535class AccountAttachmentsHistory: 536 ''' 537 AccountAttachmentsHistory records all changes to the state of an AccountAttachment. 538 See `strongdm.models.AccountAttachmentHistory`. 539 ''' 540 def __init__(self, channel, client): 541 self.parent = client 542 self.stub = AccountAttachmentsHistoryStub(channel) 543 544 def list(self, filter, *args, timeout=None): 545 ''' 546 List gets a list of AccountAttachmentHistory records matching a given set of criteria. 547 ''' 548 deadline = None if timeout is None else time.time() + timeout 549 req = AccountAttachmentHistoryListRequest() 550 req.meta.CopyFrom(ListRequestMetadata()) 551 if self.parent.page_limit > 0: 552 req.meta.limit = self.parent.page_limit 553 if self.parent.snapshot_datetime is not None: 554 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 555 556 req.filter = plumbing.quote_filter_args(filter, *args) 557 558 def generator(svc, req): 559 tries = 0 560 while True: 561 t = None if deadline is None else deadline - time.time() 562 try: 563 plumbing_response = svc.stub.List( 564 req, 565 metadata=svc.parent.get_metadata( 566 'AccountAttachmentsHistory.List', req), 567 timeout=t) 568 except Exception as e: 569 if self.parent.shouldRetry(tries, e, deadline): 570 tries += 1 571 time.sleep( 572 self.parent.exponentialBackoff(tries, deadline)) 573 continue 574 raise plumbing.convert_error_to_porcelain(e) from e 575 tries = 0 576 for plumbing_item in plumbing_response.history: 577 yield plumbing.convert_account_attachment_history_to_porcelain( 578 plumbing_item) 579 if plumbing_response.meta.next_cursor == '': 580 break 581 req.meta.cursor = plumbing_response.meta.next_cursor 582 583 return generator(self, req) 584 585 586class AccountGrants: 587 ''' 588 AccountGrants assign a resource directly to an account, giving the account the permission to connect to that resource. 589 See `strongdm.models.AccountGrant`. 590 ''' 591 def __init__(self, channel, client): 592 self.parent = client 593 self.stub = AccountGrantsStub(channel) 594 595 def create(self, account_grant, timeout=None): 596 ''' 597 Create registers a new AccountGrant. 598 ''' 599 deadline = None if timeout is None else time.time() + timeout 600 req = AccountGrantCreateRequest() 601 602 if account_grant is not None: 603 req.account_grant.CopyFrom( 604 plumbing.convert_account_grant_to_plumbing(account_grant)) 605 tries = 0 606 plumbing_response = None 607 while True: 608 t = None if deadline is None else deadline - time.time() 609 try: 610 plumbing_response = self.stub.Create( 611 req, 612 metadata=self.parent.get_metadata('AccountGrants.Create', 613 req), 614 timeout=t) 615 except Exception as e: 616 if self.parent.shouldRetry(tries, e, deadline): 617 tries += 1 618 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 619 continue 620 raise plumbing.convert_error_to_porcelain(e) from e 621 break 622 623 resp = models.AccountGrantCreateResponse() 624 resp.account_grant = plumbing.convert_account_grant_to_porcelain( 625 plumbing_response.account_grant) 626 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 627 plumbing_response.meta) 628 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 629 plumbing_response.rate_limit) 630 return resp 631 632 def get(self, id, timeout=None): 633 ''' 634 Get reads one AccountGrant by ID. 635 ''' 636 deadline = None if timeout is None else time.time() + timeout 637 req = AccountGrantGetRequest() 638 if self.parent.snapshot_datetime is not None: 639 req.meta.CopyFrom(GetRequestMetadata()) 640 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 641 642 req.id = (id) 643 tries = 0 644 plumbing_response = None 645 while True: 646 t = None if deadline is None else deadline - time.time() 647 try: 648 plumbing_response = self.stub.Get( 649 req, 650 metadata=self.parent.get_metadata('AccountGrants.Get', 651 req), 652 timeout=t) 653 except Exception as e: 654 if self.parent.shouldRetry(tries, e, deadline): 655 tries += 1 656 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 657 continue 658 raise plumbing.convert_error_to_porcelain(e) from e 659 break 660 661 resp = models.AccountGrantGetResponse() 662 resp.account_grant = plumbing.convert_account_grant_to_porcelain( 663 plumbing_response.account_grant) 664 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 665 plumbing_response.meta) 666 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 667 plumbing_response.rate_limit) 668 return resp 669 670 def delete(self, id, timeout=None): 671 ''' 672 Delete removes a AccountGrant by ID. 673 ''' 674 deadline = None if timeout is None else time.time() + timeout 675 req = AccountGrantDeleteRequest() 676 677 req.id = (id) 678 tries = 0 679 plumbing_response = None 680 while True: 681 t = None if deadline is None else deadline - time.time() 682 try: 683 plumbing_response = self.stub.Delete( 684 req, 685 metadata=self.parent.get_metadata('AccountGrants.Delete', 686 req), 687 timeout=t) 688 except Exception as e: 689 if self.parent.shouldRetry(tries, e, deadline): 690 tries += 1 691 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 692 continue 693 raise plumbing.convert_error_to_porcelain(e) from e 694 break 695 696 resp = models.AccountGrantDeleteResponse() 697 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 698 plumbing_response.meta) 699 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 700 plumbing_response.rate_limit) 701 return resp 702 703 def list(self, filter, *args, timeout=None): 704 ''' 705 List gets a list of AccountGrants matching a given set of criteria. 706 ''' 707 deadline = None if timeout is None else time.time() + timeout 708 req = AccountGrantListRequest() 709 req.meta.CopyFrom(ListRequestMetadata()) 710 if self.parent.page_limit > 0: 711 req.meta.limit = self.parent.page_limit 712 if self.parent.snapshot_datetime is not None: 713 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 714 715 req.filter = plumbing.quote_filter_args(filter, *args) 716 717 def generator(svc, req): 718 tries = 0 719 while True: 720 t = None if deadline is None else deadline - time.time() 721 try: 722 plumbing_response = svc.stub.List( 723 req, 724 metadata=svc.parent.get_metadata( 725 'AccountGrants.List', req), 726 timeout=t) 727 except Exception as e: 728 if self.parent.shouldRetry(tries, e, deadline): 729 tries += 1 730 time.sleep( 731 self.parent.exponentialBackoff(tries, deadline)) 732 continue 733 raise plumbing.convert_error_to_porcelain(e) from e 734 tries = 0 735 for plumbing_item in plumbing_response.account_grants: 736 yield plumbing.convert_account_grant_to_porcelain( 737 plumbing_item) 738 if plumbing_response.meta.next_cursor == '': 739 break 740 req.meta.cursor = plumbing_response.meta.next_cursor 741 742 return generator(self, req) 743 744 745class SnapshotAccountGrants: 746 ''' 747 SnapshotAccountGrants exposes the read only methods of the AccountGrants 748 service for historical queries. 749 ''' 750 def __init__(self, account_grants): 751 self.account_grants = account_grants 752 753 def get(self, id, timeout=None): 754 ''' 755 Get reads one AccountGrant by ID. 756 ''' 757 return self.account_grants.get(id, timeout=timeout) 758 759 def list(self, filter, *args, timeout=None): 760 ''' 761 List gets a list of AccountGrants matching a given set of criteria. 762 ''' 763 return self.account_grants.list(filter, *args, timeout=timeout) 764 765 766class AccountGrantsHistory: 767 ''' 768 AccountGrantsHistory records all changes to the state of an AccountGrant. 769 See `strongdm.models.AccountGrantHistory`. 770 ''' 771 def __init__(self, channel, client): 772 self.parent = client 773 self.stub = AccountGrantsHistoryStub(channel) 774 775 def list(self, filter, *args, timeout=None): 776 ''' 777 List gets a list of AccountGrantHistory records matching a given set of criteria. 778 ''' 779 deadline = None if timeout is None else time.time() + timeout 780 req = AccountGrantHistoryListRequest() 781 req.meta.CopyFrom(ListRequestMetadata()) 782 if self.parent.page_limit > 0: 783 req.meta.limit = self.parent.page_limit 784 if self.parent.snapshot_datetime is not None: 785 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 786 787 req.filter = plumbing.quote_filter_args(filter, *args) 788 789 def generator(svc, req): 790 tries = 0 791 while True: 792 t = None if deadline is None else deadline - time.time() 793 try: 794 plumbing_response = svc.stub.List( 795 req, 796 metadata=svc.parent.get_metadata( 797 'AccountGrantsHistory.List', req), 798 timeout=t) 799 except Exception as e: 800 if self.parent.shouldRetry(tries, e, deadline): 801 tries += 1 802 time.sleep( 803 self.parent.exponentialBackoff(tries, deadline)) 804 continue 805 raise plumbing.convert_error_to_porcelain(e) from e 806 tries = 0 807 for plumbing_item in plumbing_response.history: 808 yield plumbing.convert_account_grant_history_to_porcelain( 809 plumbing_item) 810 if plumbing_response.meta.next_cursor == '': 811 break 812 req.meta.cursor = plumbing_response.meta.next_cursor 813 814 return generator(self, req) 815 816 817class AccountPermissions: 818 ''' 819 AccountPermissions records the granular permissions accounts have, allowing them to execute 820 relevant commands via StrongDM's APIs. 821 See `strongdm.models.AccountPermission`. 822 ''' 823 def __init__(self, channel, client): 824 self.parent = client 825 self.stub = AccountPermissionsStub(channel) 826 827 def list(self, filter, *args, timeout=None): 828 ''' 829 List gets a list of Permission records matching a given set of criteria. 830 ''' 831 deadline = None if timeout is None else time.time() + timeout 832 req = AccountPermissionListRequest() 833 req.meta.CopyFrom(ListRequestMetadata()) 834 if self.parent.page_limit > 0: 835 req.meta.limit = self.parent.page_limit 836 if self.parent.snapshot_datetime is not None: 837 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 838 839 req.filter = plumbing.quote_filter_args(filter, *args) 840 841 def generator(svc, req): 842 tries = 0 843 while True: 844 t = None if deadline is None else deadline - time.time() 845 try: 846 plumbing_response = svc.stub.List( 847 req, 848 metadata=svc.parent.get_metadata( 849 'AccountPermissions.List', req), 850 timeout=t) 851 except Exception as e: 852 if self.parent.shouldRetry(tries, e, deadline): 853 tries += 1 854 time.sleep( 855 self.parent.exponentialBackoff(tries, deadline)) 856 continue 857 raise plumbing.convert_error_to_porcelain(e) from e 858 tries = 0 859 for plumbing_item in plumbing_response.permissions: 860 yield plumbing.convert_account_permission_to_porcelain( 861 plumbing_item) 862 if plumbing_response.meta.next_cursor == '': 863 break 864 req.meta.cursor = plumbing_response.meta.next_cursor 865 866 return generator(self, req) 867 868 869class SnapshotAccountPermissions: 870 ''' 871 SnapshotAccountPermissions exposes the read only methods of the AccountPermissions 872 service for historical queries. 873 ''' 874 def __init__(self, account_permissions): 875 self.account_permissions = account_permissions 876 877 def list(self, filter, *args, timeout=None): 878 ''' 879 List gets a list of Permission records matching a given set of criteria. 880 ''' 881 return self.account_permissions.list(filter, *args, timeout=timeout) 882 883 884class AccountResources: 885 ''' 886 AccountResources enumerates the resources to which accounts have access. 887 The AccountResources service is read-only. 888 See `strongdm.models.AccountResource`. 889 ''' 890 def __init__(self, channel, client): 891 self.parent = client 892 self.stub = AccountResourcesStub(channel) 893 894 def list(self, filter, *args, timeout=None): 895 ''' 896 List gets a list of AccountResource records matching a given set of criteria. 897 ''' 898 deadline = None if timeout is None else time.time() + timeout 899 req = AccountResourceListRequest() 900 req.meta.CopyFrom(ListRequestMetadata()) 901 if self.parent.page_limit > 0: 902 req.meta.limit = self.parent.page_limit 903 if self.parent.snapshot_datetime is not None: 904 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 905 906 req.filter = plumbing.quote_filter_args(filter, *args) 907 908 def generator(svc, req): 909 tries = 0 910 while True: 911 t = None if deadline is None else deadline - time.time() 912 try: 913 plumbing_response = svc.stub.List( 914 req, 915 metadata=svc.parent.get_metadata( 916 'AccountResources.List', req), 917 timeout=t) 918 except Exception as e: 919 if self.parent.shouldRetry(tries, e, deadline): 920 tries += 1 921 time.sleep( 922 self.parent.exponentialBackoff(tries, deadline)) 923 continue 924 raise plumbing.convert_error_to_porcelain(e) from e 925 tries = 0 926 for plumbing_item in plumbing_response.account_resources: 927 yield plumbing.convert_account_resource_to_porcelain( 928 plumbing_item) 929 if plumbing_response.meta.next_cursor == '': 930 break 931 req.meta.cursor = plumbing_response.meta.next_cursor 932 933 return generator(self, req) 934 935 936class SnapshotAccountResources: 937 ''' 938 SnapshotAccountResources exposes the read only methods of the AccountResources 939 service for historical queries. 940 ''' 941 def __init__(self, account_resources): 942 self.account_resources = account_resources 943 944 def list(self, filter, *args, timeout=None): 945 ''' 946 List gets a list of AccountResource records matching a given set of criteria. 947 ''' 948 return self.account_resources.list(filter, *args, timeout=timeout) 949 950 951class AccountResourcesHistory: 952 ''' 953 AccountResourcesHistory records all changes to the state of a AccountResource. 954 See `strongdm.models.AccountResourceHistory`. 955 ''' 956 def __init__(self, channel, client): 957 self.parent = client 958 self.stub = AccountResourcesHistoryStub(channel) 959 960 def list(self, filter, *args, timeout=None): 961 ''' 962 List gets a list of AccountResourceHistory records matching a given set of criteria. 963 ''' 964 deadline = None if timeout is None else time.time() + timeout 965 req = AccountResourceHistoryListRequest() 966 req.meta.CopyFrom(ListRequestMetadata()) 967 if self.parent.page_limit > 0: 968 req.meta.limit = self.parent.page_limit 969 if self.parent.snapshot_datetime is not None: 970 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 971 972 req.filter = plumbing.quote_filter_args(filter, *args) 973 974 def generator(svc, req): 975 tries = 0 976 while True: 977 t = None if deadline is None else deadline - time.time() 978 try: 979 plumbing_response = svc.stub.List( 980 req, 981 metadata=svc.parent.get_metadata( 982 'AccountResourcesHistory.List', req), 983 timeout=t) 984 except Exception as e: 985 if self.parent.shouldRetry(tries, e, deadline): 986 tries += 1 987 time.sleep( 988 self.parent.exponentialBackoff(tries, deadline)) 989 continue 990 raise plumbing.convert_error_to_porcelain(e) from e 991 tries = 0 992 for plumbing_item in plumbing_response.history: 993 yield plumbing.convert_account_resource_history_to_porcelain( 994 plumbing_item) 995 if plumbing_response.meta.next_cursor == '': 996 break 997 req.meta.cursor = plumbing_response.meta.next_cursor 998 999 return generator(self, req) 1000 1001 1002class Accounts: 1003 ''' 1004 Accounts are users that have access to strongDM. There are two types of accounts: 1005 1. **Users:** humans who are authenticated through username and password or SSO. 1006 2. **Service Accounts:** machines that are authenticated using a service token. 1007 3. **Tokens** are access keys with permissions that can be used for authentication. 1008 See: 1009 `strongdm.models.Service` 1010 `strongdm.models.Token` 1011 `strongdm.models.User` 1012 ''' 1013 def __init__(self, channel, client): 1014 self.parent = client 1015 self.stub = AccountsStub(channel) 1016 1017 def create(self, account, timeout=None): 1018 ''' 1019 Create registers a new Account. 1020 ''' 1021 deadline = None if timeout is None else time.time() + timeout 1022 req = AccountCreateRequest() 1023 1024 if account is not None: 1025 req.account.CopyFrom(plumbing.convert_account_to_plumbing(account)) 1026 tries = 0 1027 plumbing_response = None 1028 while True: 1029 t = None if deadline is None else deadline - time.time() 1030 try: 1031 plumbing_response = self.stub.Create( 1032 req, 1033 metadata=self.parent.get_metadata('Accounts.Create', req), 1034 timeout=t) 1035 except Exception as e: 1036 if self.parent.shouldRetry(tries, e, deadline): 1037 tries += 1 1038 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1039 continue 1040 raise plumbing.convert_error_to_porcelain(e) from e 1041 break 1042 1043 resp = models.AccountCreateResponse() 1044 resp.access_key = (plumbing_response.access_key) 1045 resp.account = plumbing.convert_account_to_porcelain( 1046 plumbing_response.account) 1047 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 1048 plumbing_response.meta) 1049 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1050 plumbing_response.rate_limit) 1051 resp.secret_key = (plumbing_response.secret_key) 1052 resp.token = (plumbing_response.token) 1053 return resp 1054 1055 def get(self, id, timeout=None): 1056 ''' 1057 Get reads one Account by ID. 1058 ''' 1059 deadline = None if timeout is None else time.time() + timeout 1060 req = AccountGetRequest() 1061 if self.parent.snapshot_datetime is not None: 1062 req.meta.CopyFrom(GetRequestMetadata()) 1063 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1064 1065 req.id = (id) 1066 tries = 0 1067 plumbing_response = None 1068 while True: 1069 t = None if deadline is None else deadline - time.time() 1070 try: 1071 plumbing_response = self.stub.Get( 1072 req, 1073 metadata=self.parent.get_metadata('Accounts.Get', req), 1074 timeout=t) 1075 except Exception as e: 1076 if self.parent.shouldRetry(tries, e, deadline): 1077 tries += 1 1078 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1079 continue 1080 raise plumbing.convert_error_to_porcelain(e) from e 1081 break 1082 1083 resp = models.AccountGetResponse() 1084 resp.account = plumbing.convert_account_to_porcelain( 1085 plumbing_response.account) 1086 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1087 plumbing_response.meta) 1088 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1089 plumbing_response.rate_limit) 1090 return resp 1091 1092 def update(self, account, timeout=None): 1093 ''' 1094 Update replaces all the fields of an Account by ID. 1095 ''' 1096 deadline = None if timeout is None else time.time() + timeout 1097 req = AccountUpdateRequest() 1098 1099 if account is not None: 1100 req.account.CopyFrom(plumbing.convert_account_to_plumbing(account)) 1101 tries = 0 1102 plumbing_response = None 1103 while True: 1104 t = None if deadline is None else deadline - time.time() 1105 try: 1106 plumbing_response = self.stub.Update( 1107 req, 1108 metadata=self.parent.get_metadata('Accounts.Update', req), 1109 timeout=t) 1110 except Exception as e: 1111 if self.parent.shouldRetry(tries, e, deadline): 1112 tries += 1 1113 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1114 continue 1115 raise plumbing.convert_error_to_porcelain(e) from e 1116 break 1117 1118 resp = models.AccountUpdateResponse() 1119 resp.account = plumbing.convert_account_to_porcelain( 1120 plumbing_response.account) 1121 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 1122 plumbing_response.meta) 1123 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1124 plumbing_response.rate_limit) 1125 return resp 1126 1127 def delete(self, id, timeout=None): 1128 ''' 1129 Delete removes an Account by ID. 1130 ''' 1131 deadline = None if timeout is None else time.time() + timeout 1132 req = AccountDeleteRequest() 1133 1134 req.id = (id) 1135 tries = 0 1136 plumbing_response = None 1137 while True: 1138 t = None if deadline is None else deadline - time.time() 1139 try: 1140 plumbing_response = self.stub.Delete( 1141 req, 1142 metadata=self.parent.get_metadata('Accounts.Delete', req), 1143 timeout=t) 1144 except Exception as e: 1145 if self.parent.shouldRetry(tries, e, deadline): 1146 tries += 1 1147 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1148 continue 1149 raise plumbing.convert_error_to_porcelain(e) from e 1150 break 1151 1152 resp = models.AccountDeleteResponse() 1153 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 1154 plumbing_response.meta) 1155 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1156 plumbing_response.rate_limit) 1157 return resp 1158 1159 def list(self, filter, *args, timeout=None): 1160 ''' 1161 List gets a list of Accounts matching a given set of criteria. 1162 ''' 1163 deadline = None if timeout is None else time.time() + timeout 1164 req = AccountListRequest() 1165 req.meta.CopyFrom(ListRequestMetadata()) 1166 if self.parent.page_limit > 0: 1167 req.meta.limit = self.parent.page_limit 1168 if self.parent.snapshot_datetime is not None: 1169 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1170 1171 req.filter = plumbing.quote_filter_args(filter, *args) 1172 1173 def generator(svc, req): 1174 tries = 0 1175 while True: 1176 t = None if deadline is None else deadline - time.time() 1177 try: 1178 plumbing_response = svc.stub.List( 1179 req, 1180 metadata=svc.parent.get_metadata('Accounts.List', req), 1181 timeout=t) 1182 except Exception as e: 1183 if self.parent.shouldRetry(tries, e, deadline): 1184 tries += 1 1185 time.sleep( 1186 self.parent.exponentialBackoff(tries, deadline)) 1187 continue 1188 raise plumbing.convert_error_to_porcelain(e) from e 1189 tries = 0 1190 for plumbing_item in plumbing_response.accounts: 1191 yield plumbing.convert_account_to_porcelain(plumbing_item) 1192 if plumbing_response.meta.next_cursor == '': 1193 break 1194 req.meta.cursor = plumbing_response.meta.next_cursor 1195 1196 return generator(self, req) 1197 1198 1199class SnapshotAccounts: 1200 ''' 1201 SnapshotAccounts exposes the read only methods of the Accounts 1202 service for historical queries. 1203 ''' 1204 def __init__(self, accounts): 1205 self.accounts = accounts 1206 1207 def get(self, id, timeout=None): 1208 ''' 1209 Get reads one Account by ID. 1210 ''' 1211 return self.accounts.get(id, timeout=timeout) 1212 1213 def list(self, filter, *args, timeout=None): 1214 ''' 1215 List gets a list of Accounts matching a given set of criteria. 1216 ''' 1217 return self.accounts.list(filter, *args, timeout=timeout) 1218 1219 1220class AccountsGroups: 1221 ''' 1222 An AccountGroup links an account and a group. 1223 See `strongdm.models.AccountGroup`. 1224 ''' 1225 def __init__(self, channel, client): 1226 self.parent = client 1227 self.stub = AccountsGroupsStub(channel) 1228 1229 def create(self, account_group, timeout=None): 1230 ''' 1231 Create create a new AccountGroup. 1232 ''' 1233 deadline = None if timeout is None else time.time() + timeout 1234 req = AccountGroupCreateRequest() 1235 1236 if account_group is not None: 1237 req.account_group.CopyFrom( 1238 plumbing.convert_account_group_to_plumbing(account_group)) 1239 tries = 0 1240 plumbing_response = None 1241 while True: 1242 t = None if deadline is None else deadline - time.time() 1243 try: 1244 plumbing_response = self.stub.Create( 1245 req, 1246 metadata=self.parent.get_metadata('AccountsGroups.Create', 1247 req), 1248 timeout=t) 1249 except Exception as e: 1250 if self.parent.shouldRetry(tries, e, deadline): 1251 tries += 1 1252 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1253 continue 1254 raise plumbing.convert_error_to_porcelain(e) from e 1255 break 1256 1257 resp = models.AccountGroupCreateResponse() 1258 resp.account_group = plumbing.convert_account_group_to_porcelain( 1259 plumbing_response.account_group) 1260 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1261 plumbing_response.rate_limit) 1262 return resp 1263 1264 def get(self, id, timeout=None): 1265 ''' 1266 Get reads one AccountGroup by ID. 1267 ''' 1268 deadline = None if timeout is None else time.time() + timeout 1269 req = AccountGroupGetRequest() 1270 if self.parent.snapshot_datetime is not None: 1271 req.meta.CopyFrom(GetRequestMetadata()) 1272 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1273 1274 req.id = (id) 1275 tries = 0 1276 plumbing_response = None 1277 while True: 1278 t = None if deadline is None else deadline - time.time() 1279 try: 1280 plumbing_response = self.stub.Get( 1281 req, 1282 metadata=self.parent.get_metadata('AccountsGroups.Get', 1283 req), 1284 timeout=t) 1285 except Exception as e: 1286 if self.parent.shouldRetry(tries, e, deadline): 1287 tries += 1 1288 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1289 continue 1290 raise plumbing.convert_error_to_porcelain(e) from e 1291 break 1292 1293 resp = models.AccountGroupGetResponse() 1294 resp.account_group = plumbing.convert_account_group_to_porcelain( 1295 plumbing_response.account_group) 1296 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1297 plumbing_response.meta) 1298 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1299 plumbing_response.rate_limit) 1300 return resp 1301 1302 def delete(self, id, timeout=None): 1303 ''' 1304 Delete removes an AccountGroup by ID. 1305 ''' 1306 deadline = None if timeout is None else time.time() + timeout 1307 req = AccountGroupDeleteRequest() 1308 1309 req.id = (id) 1310 tries = 0 1311 plumbing_response = None 1312 while True: 1313 t = None if deadline is None else deadline - time.time() 1314 try: 1315 plumbing_response = self.stub.Delete( 1316 req, 1317 metadata=self.parent.get_metadata('AccountsGroups.Delete', 1318 req), 1319 timeout=t) 1320 except Exception as e: 1321 if self.parent.shouldRetry(tries, e, deadline): 1322 tries += 1 1323 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1324 continue 1325 raise plumbing.convert_error_to_porcelain(e) from e 1326 break 1327 1328 resp = models.AccountGroupDeleteResponse() 1329 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 1330 plumbing_response.meta) 1331 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1332 plumbing_response.rate_limit) 1333 return resp 1334 1335 def list(self, filter, *args, timeout=None): 1336 ''' 1337 List gets a list of AccountGroups matching a given set of criteria. 1338 ''' 1339 deadline = None if timeout is None else time.time() + timeout 1340 req = AccountGroupListRequest() 1341 req.meta.CopyFrom(ListRequestMetadata()) 1342 if self.parent.page_limit > 0: 1343 req.meta.limit = self.parent.page_limit 1344 if self.parent.snapshot_datetime is not None: 1345 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1346 1347 req.filter = plumbing.quote_filter_args(filter, *args) 1348 1349 def generator(svc, req): 1350 tries = 0 1351 while True: 1352 t = None if deadline is None else deadline - time.time() 1353 try: 1354 plumbing_response = svc.stub.List( 1355 req, 1356 metadata=svc.parent.get_metadata( 1357 'AccountsGroups.List', req), 1358 timeout=t) 1359 except Exception as e: 1360 if self.parent.shouldRetry(tries, e, deadline): 1361 tries += 1 1362 time.sleep( 1363 self.parent.exponentialBackoff(tries, deadline)) 1364 continue 1365 raise plumbing.convert_error_to_porcelain(e) from e 1366 tries = 0 1367 for plumbing_item in plumbing_response.account_groups: 1368 yield plumbing.convert_account_group_to_porcelain( 1369 plumbing_item) 1370 if plumbing_response.meta.next_cursor == '': 1371 break 1372 req.meta.cursor = plumbing_response.meta.next_cursor 1373 1374 return generator(self, req) 1375 1376 1377class SnapshotAccountsGroups: 1378 ''' 1379 SnapshotAccountsGroups exposes the read only methods of the AccountsGroups 1380 service for historical queries. 1381 ''' 1382 def __init__(self, accounts_groups): 1383 self.accounts_groups = accounts_groups 1384 1385 def get(self, id, timeout=None): 1386 ''' 1387 Get reads one AccountGroup by ID. 1388 ''' 1389 return self.accounts_groups.get(id, timeout=timeout) 1390 1391 def list(self, filter, *args, timeout=None): 1392 ''' 1393 List gets a list of AccountGroups matching a given set of criteria. 1394 ''' 1395 return self.accounts_groups.list(filter, *args, timeout=timeout) 1396 1397 1398class AccountsGroupsHistory: 1399 ''' 1400 AccountsGroupsHistory records all changes to the state of an AccountGroup. 1401 See `strongdm.models.AccountGroupHistory`. 1402 ''' 1403 def __init__(self, channel, client): 1404 self.parent = client 1405 self.stub = AccountsGroupsHistoryStub(channel) 1406 1407 def list(self, filter, *args, timeout=None): 1408 ''' 1409 List gets a list of AccountGroupHistory records matching a given set of criteria. 1410 ''' 1411 deadline = None if timeout is None else time.time() + timeout 1412 req = AccountGroupHistoryListRequest() 1413 req.meta.CopyFrom(ListRequestMetadata()) 1414 if self.parent.page_limit > 0: 1415 req.meta.limit = self.parent.page_limit 1416 if self.parent.snapshot_datetime is not None: 1417 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1418 1419 req.filter = plumbing.quote_filter_args(filter, *args) 1420 1421 def generator(svc, req): 1422 tries = 0 1423 while True: 1424 t = None if deadline is None else deadline - time.time() 1425 try: 1426 plumbing_response = svc.stub.List( 1427 req, 1428 metadata=svc.parent.get_metadata( 1429 'AccountsGroupsHistory.List', req), 1430 timeout=t) 1431 except Exception as e: 1432 if self.parent.shouldRetry(tries, e, deadline): 1433 tries += 1 1434 time.sleep( 1435 self.parent.exponentialBackoff(tries, deadline)) 1436 continue 1437 raise plumbing.convert_error_to_porcelain(e) from e 1438 tries = 0 1439 for plumbing_item in plumbing_response.history: 1440 yield plumbing.convert_account_group_history_to_porcelain( 1441 plumbing_item) 1442 if plumbing_response.meta.next_cursor == '': 1443 break 1444 req.meta.cursor = plumbing_response.meta.next_cursor 1445 1446 return generator(self, req) 1447 1448 1449class AccountsHistory: 1450 ''' 1451 AccountsHistory records all changes to the state of an Account. 1452 See `strongdm.models.AccountHistory`. 1453 ''' 1454 def __init__(self, channel, client): 1455 self.parent = client 1456 self.stub = AccountsHistoryStub(channel) 1457 1458 def list(self, filter, *args, timeout=None): 1459 ''' 1460 List gets a list of AccountHistory records matching a given set of criteria. 1461 ''' 1462 deadline = None if timeout is None else time.time() + timeout 1463 req = AccountHistoryListRequest() 1464 req.meta.CopyFrom(ListRequestMetadata()) 1465 if self.parent.page_limit > 0: 1466 req.meta.limit = self.parent.page_limit 1467 if self.parent.snapshot_datetime is not None: 1468 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1469 1470 req.filter = plumbing.quote_filter_args(filter, *args) 1471 1472 def generator(svc, req): 1473 tries = 0 1474 while True: 1475 t = None if deadline is None else deadline - time.time() 1476 try: 1477 plumbing_response = svc.stub.List( 1478 req, 1479 metadata=svc.parent.get_metadata( 1480 'AccountsHistory.List', req), 1481 timeout=t) 1482 except Exception as e: 1483 if self.parent.shouldRetry(tries, e, deadline): 1484 tries += 1 1485 time.sleep( 1486 self.parent.exponentialBackoff(tries, deadline)) 1487 continue 1488 raise plumbing.convert_error_to_porcelain(e) from e 1489 tries = 0 1490 for plumbing_item in plumbing_response.history: 1491 yield plumbing.convert_account_history_to_porcelain( 1492 plumbing_item) 1493 if plumbing_response.meta.next_cursor == '': 1494 break 1495 req.meta.cursor = plumbing_response.meta.next_cursor 1496 1497 return generator(self, req) 1498 1499 1500class Activities: 1501 ''' 1502 An Activity is a record of an action taken against a strongDM deployment, e.g. 1503 a user creation, resource deletion, sso configuration change, etc. The Activities 1504 service is read-only. 1505 See `strongdm.models.Activity`. 1506 ''' 1507 def __init__(self, channel, client): 1508 self.parent = client 1509 self.stub = ActivitiesStub(channel) 1510 1511 def get(self, id, timeout=None): 1512 ''' 1513 Get reads one Activity by ID. 1514 ''' 1515 deadline = None if timeout is None else time.time() + timeout 1516 req = ActivityGetRequest() 1517 if self.parent.snapshot_datetime is not None: 1518 req.meta.CopyFrom(GetRequestMetadata()) 1519 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1520 1521 req.id = (id) 1522 tries = 0 1523 plumbing_response = None 1524 while True: 1525 t = None if deadline is None else deadline - time.time() 1526 try: 1527 plumbing_response = self.stub.Get( 1528 req, 1529 metadata=self.parent.get_metadata('Activities.Get', req), 1530 timeout=t) 1531 except Exception as e: 1532 if self.parent.shouldRetry(tries, e, deadline): 1533 tries += 1 1534 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1535 continue 1536 raise plumbing.convert_error_to_porcelain(e) from e 1537 break 1538 1539 resp = models.ActivityGetResponse() 1540 resp.activity = plumbing.convert_activity_to_porcelain( 1541 plumbing_response.activity) 1542 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1543 plumbing_response.meta) 1544 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1545 plumbing_response.rate_limit) 1546 return resp 1547 1548 def list(self, filter, *args, timeout=None): 1549 ''' 1550 List gets a list of Activities matching a given set of criteria. 1551 The 'before' and 'after' filters can be used to control the time 1552 range of the output activities. If not provided, one week of back 1553 of activities will be returned. 1554 ''' 1555 deadline = None if timeout is None else time.time() + timeout 1556 req = ActivityListRequest() 1557 req.meta.CopyFrom(ListRequestMetadata()) 1558 if self.parent.page_limit > 0: 1559 req.meta.limit = self.parent.page_limit 1560 if self.parent.snapshot_datetime is not None: 1561 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1562 1563 req.filter = plumbing.quote_filter_args(filter, *args) 1564 1565 def generator(svc, req): 1566 tries = 0 1567 while True: 1568 t = None if deadline is None else deadline - time.time() 1569 try: 1570 plumbing_response = svc.stub.List( 1571 req, 1572 metadata=svc.parent.get_metadata( 1573 'Activities.List', req), 1574 timeout=t) 1575 except Exception as e: 1576 if self.parent.shouldRetry(tries, e, deadline): 1577 tries += 1 1578 time.sleep( 1579 self.parent.exponentialBackoff(tries, deadline)) 1580 continue 1581 raise plumbing.convert_error_to_porcelain(e) from e 1582 tries = 0 1583 for plumbing_item in plumbing_response.activities: 1584 yield plumbing.convert_activity_to_porcelain(plumbing_item) 1585 if plumbing_response.meta.next_cursor == '': 1586 break 1587 req.meta.cursor = plumbing_response.meta.next_cursor 1588 1589 return generator(self, req) 1590 1591 1592class ApprovalWorkflowApprovers: 1593 ''' 1594 ApprovalWorkflowApprovers link approval workflow approvers to an ApprovalWorkflowStep 1595 See `strongdm.models.ApprovalWorkflowApprover`. 1596 ''' 1597 def __init__(self, channel, client): 1598 self.parent = client 1599 self.stub = ApprovalWorkflowApproversStub(channel) 1600 1601 def create(self, approval_workflow_approver, timeout=None): 1602 ''' 1603 Deprecated: Create creates a new approval workflow approver. 1604 ''' 1605 deadline = None if timeout is None else time.time() + timeout 1606 req = ApprovalWorkflowApproverCreateRequest() 1607 1608 if approval_workflow_approver is not None: 1609 req.approval_workflow_approver.CopyFrom( 1610 plumbing.convert_approval_workflow_approver_to_plumbing( 1611 approval_workflow_approver)) 1612 tries = 0 1613 plumbing_response = None 1614 while True: 1615 t = None if deadline is None else deadline - time.time() 1616 try: 1617 plumbing_response = self.stub.Create( 1618 req, 1619 metadata=self.parent.get_metadata( 1620 'ApprovalWorkflowApprovers.Create', req), 1621 timeout=t) 1622 except Exception as e: 1623 if self.parent.shouldRetry(tries, e, deadline): 1624 tries += 1 1625 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1626 continue 1627 raise plumbing.convert_error_to_porcelain(e) from e 1628 break 1629 1630 resp = models.ApprovalWorkflowApproverCreateResponse() 1631 resp.approval_workflow_approver = plumbing.convert_approval_workflow_approver_to_porcelain( 1632 plumbing_response.approval_workflow_approver) 1633 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1634 plumbing_response.rate_limit) 1635 return resp 1636 1637 def get(self, id, timeout=None): 1638 ''' 1639 Deprecated: Get reads one approval workflow approver by ID. 1640 ''' 1641 deadline = None if timeout is None else time.time() + timeout 1642 req = ApprovalWorkflowApproverGetRequest() 1643 if self.parent.snapshot_datetime is not None: 1644 req.meta.CopyFrom(GetRequestMetadata()) 1645 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1646 1647 req.id = (id) 1648 tries = 0 1649 plumbing_response = None 1650 while True: 1651 t = None if deadline is None else deadline - time.time() 1652 try: 1653 plumbing_response = self.stub.Get( 1654 req, 1655 metadata=self.parent.get_metadata( 1656 'ApprovalWorkflowApprovers.Get', req), 1657 timeout=t) 1658 except Exception as e: 1659 if self.parent.shouldRetry(tries, e, deadline): 1660 tries += 1 1661 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1662 continue 1663 raise plumbing.convert_error_to_porcelain(e) from e 1664 break 1665 1666 resp = models.ApprovalWorkflowApproverGetResponse() 1667 resp.approval_workflow_approver = plumbing.convert_approval_workflow_approver_to_porcelain( 1668 plumbing_response.approval_workflow_approver) 1669 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1670 plumbing_response.meta) 1671 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1672 plumbing_response.rate_limit) 1673 return resp 1674 1675 def delete(self, id, timeout=None): 1676 ''' 1677 Deprecated: Delete deletes an existing approval workflow approver. 1678 ''' 1679 deadline = None if timeout is None else time.time() + timeout 1680 req = ApprovalWorkflowApproverDeleteRequest() 1681 1682 req.id = (id) 1683 tries = 0 1684 plumbing_response = None 1685 while True: 1686 t = None if deadline is None else deadline - time.time() 1687 try: 1688 plumbing_response = self.stub.Delete( 1689 req, 1690 metadata=self.parent.get_metadata( 1691 'ApprovalWorkflowApprovers.Delete', req), 1692 timeout=t) 1693 except Exception as e: 1694 if self.parent.shouldRetry(tries, e, deadline): 1695 tries += 1 1696 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1697 continue 1698 raise plumbing.convert_error_to_porcelain(e) from e 1699 break 1700 1701 resp = models.ApprovalWorkflowApproverDeleteResponse() 1702 resp.id = (plumbing_response.id) 1703 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1704 plumbing_response.rate_limit) 1705 return resp 1706 1707 def list(self, filter, *args, timeout=None): 1708 ''' 1709 Deprecated: Lists existing approval workflow approvers. 1710 ''' 1711 deadline = None if timeout is None else time.time() + timeout 1712 req = ApprovalWorkflowApproverListRequest() 1713 req.meta.CopyFrom(ListRequestMetadata()) 1714 if self.parent.page_limit > 0: 1715 req.meta.limit = self.parent.page_limit 1716 if self.parent.snapshot_datetime is not None: 1717 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1718 1719 req.filter = plumbing.quote_filter_args(filter, *args) 1720 1721 def generator(svc, req): 1722 tries = 0 1723 while True: 1724 t = None if deadline is None else deadline - time.time() 1725 try: 1726 plumbing_response = svc.stub.List( 1727 req, 1728 metadata=svc.parent.get_metadata( 1729 'ApprovalWorkflowApprovers.List', req), 1730 timeout=t) 1731 except Exception as e: 1732 if self.parent.shouldRetry(tries, e, deadline): 1733 tries += 1 1734 time.sleep( 1735 self.parent.exponentialBackoff(tries, deadline)) 1736 continue 1737 raise plumbing.convert_error_to_porcelain(e) from e 1738 tries = 0 1739 for plumbing_item in plumbing_response.approval_workflow_approvers: 1740 yield plumbing.convert_approval_workflow_approver_to_porcelain( 1741 plumbing_item) 1742 if plumbing_response.meta.next_cursor == '': 1743 break 1744 req.meta.cursor = plumbing_response.meta.next_cursor 1745 1746 return generator(self, req) 1747 1748 1749class SnapshotApprovalWorkflowApprovers: 1750 ''' 1751 SnapshotApprovalWorkflowApprovers exposes the read only methods of the ApprovalWorkflowApprovers 1752 service for historical queries. 1753 ''' 1754 def __init__(self, approval_workflow_approvers): 1755 self.approval_workflow_approvers = approval_workflow_approvers 1756 1757 def get(self, id, timeout=None): 1758 ''' 1759 Deprecated: Get reads one approval workflow approver by ID. 1760 ''' 1761 return self.approval_workflow_approvers.get(id, timeout=timeout) 1762 1763 def list(self, filter, *args, timeout=None): 1764 ''' 1765 Deprecated: Lists existing approval workflow approvers. 1766 ''' 1767 return self.approval_workflow_approvers.list(filter, 1768 *args, 1769 timeout=timeout) 1770 1771 1772class ApprovalWorkflowApproversHistory: 1773 ''' 1774 ApprovalWorkflowApproversHistory records all changes to the state of an ApprovalWorkflowApprover. 1775 See `strongdm.models.ApprovalWorkflowApproverHistory`. 1776 ''' 1777 def __init__(self, channel, client): 1778 self.parent = client 1779 self.stub = ApprovalWorkflowApproversHistoryStub(channel) 1780 1781 def list(self, filter, *args, timeout=None): 1782 ''' 1783 List gets a list of ApprovalWorkflowApproverHistory records matching a given set of criteria. 1784 ''' 1785 deadline = None if timeout is None else time.time() + timeout 1786 req = ApprovalWorkflowApproverHistoryListRequest() 1787 req.meta.CopyFrom(ListRequestMetadata()) 1788 if self.parent.page_limit > 0: 1789 req.meta.limit = self.parent.page_limit 1790 if self.parent.snapshot_datetime is not None: 1791 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1792 1793 req.filter = plumbing.quote_filter_args(filter, *args) 1794 1795 def generator(svc, req): 1796 tries = 0 1797 while True: 1798 t = None if deadline is None else deadline - time.time() 1799 try: 1800 plumbing_response = svc.stub.List( 1801 req, 1802 metadata=svc.parent.get_metadata( 1803 'ApprovalWorkflowApproversHistory.List', req), 1804 timeout=t) 1805 except Exception as e: 1806 if self.parent.shouldRetry(tries, e, deadline): 1807 tries += 1 1808 time.sleep( 1809 self.parent.exponentialBackoff(tries, deadline)) 1810 continue 1811 raise plumbing.convert_error_to_porcelain(e) from e 1812 tries = 0 1813 for plumbing_item in plumbing_response.history: 1814 yield plumbing.convert_approval_workflow_approver_history_to_porcelain( 1815 plumbing_item) 1816 if plumbing_response.meta.next_cursor == '': 1817 break 1818 req.meta.cursor = plumbing_response.meta.next_cursor 1819 1820 return generator(self, req) 1821 1822 1823class ApprovalWorkflowSteps: 1824 ''' 1825 ApprovalWorkflowSteps link approval workflow steps to an ApprovalWorkflow 1826 See `strongdm.models.ApprovalWorkflowStep`. 1827 ''' 1828 def __init__(self, channel, client): 1829 self.parent = client 1830 self.stub = ApprovalWorkflowStepsStub(channel) 1831 1832 def create(self, approval_workflow_step, timeout=None): 1833 ''' 1834 Deprecated: Create creates a new approval workflow step. 1835 ''' 1836 deadline = None if timeout is None else time.time() + timeout 1837 req = ApprovalWorkflowStepCreateRequest() 1838 1839 if approval_workflow_step is not None: 1840 req.approval_workflow_step.CopyFrom( 1841 plumbing.convert_approval_workflow_step_to_plumbing( 1842 approval_workflow_step)) 1843 tries = 0 1844 plumbing_response = None 1845 while True: 1846 t = None if deadline is None else deadline - time.time() 1847 try: 1848 plumbing_response = self.stub.Create( 1849 req, 1850 metadata=self.parent.get_metadata( 1851 'ApprovalWorkflowSteps.Create', req), 1852 timeout=t) 1853 except Exception as e: 1854 if self.parent.shouldRetry(tries, e, deadline): 1855 tries += 1 1856 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1857 continue 1858 raise plumbing.convert_error_to_porcelain(e) from e 1859 break 1860 1861 resp = models.ApprovalWorkflowStepCreateResponse() 1862 resp.approval_workflow_step = plumbing.convert_approval_workflow_step_to_porcelain( 1863 plumbing_response.approval_workflow_step) 1864 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1865 plumbing_response.rate_limit) 1866 return resp 1867 1868 def get(self, id, timeout=None): 1869 ''' 1870 Deprecated: Get reads one approval workflow step by ID. 1871 ''' 1872 deadline = None if timeout is None else time.time() + timeout 1873 req = ApprovalWorkflowStepGetRequest() 1874 if self.parent.snapshot_datetime is not None: 1875 req.meta.CopyFrom(GetRequestMetadata()) 1876 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1877 1878 req.id = (id) 1879 tries = 0 1880 plumbing_response = None 1881 while True: 1882 t = None if deadline is None else deadline - time.time() 1883 try: 1884 plumbing_response = self.stub.Get( 1885 req, 1886 metadata=self.parent.get_metadata( 1887 'ApprovalWorkflowSteps.Get', req), 1888 timeout=t) 1889 except Exception as e: 1890 if self.parent.shouldRetry(tries, e, deadline): 1891 tries += 1 1892 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1893 continue 1894 raise plumbing.convert_error_to_porcelain(e) from e 1895 break 1896 1897 resp = models.ApprovalWorkflowStepGetResponse() 1898 resp.approval_workflow_step = plumbing.convert_approval_workflow_step_to_porcelain( 1899 plumbing_response.approval_workflow_step) 1900 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1901 plumbing_response.meta) 1902 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1903 plumbing_response.rate_limit) 1904 return resp 1905 1906 def delete(self, id, timeout=None): 1907 ''' 1908 Deprecated: Delete deletes an existing approval workflow step. 1909 ''' 1910 deadline = None if timeout is None else time.time() + timeout 1911 req = ApprovalWorkflowStepDeleteRequest() 1912 1913 req.id = (id) 1914 tries = 0 1915 plumbing_response = None 1916 while True: 1917 t = None if deadline is None else deadline - time.time() 1918 try: 1919 plumbing_response = self.stub.Delete( 1920 req, 1921 metadata=self.parent.get_metadata( 1922 'ApprovalWorkflowSteps.Delete', req), 1923 timeout=t) 1924 except Exception as e: 1925 if self.parent.shouldRetry(tries, e, deadline): 1926 tries += 1 1927 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1928 continue 1929 raise plumbing.convert_error_to_porcelain(e) from e 1930 break 1931 1932 resp = models.ApprovalWorkflowStepDeleteResponse() 1933 resp.id = (plumbing_response.id) 1934 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1935 plumbing_response.rate_limit) 1936 return resp 1937 1938 def list(self, filter, *args, timeout=None): 1939 ''' 1940 Deprecated: Lists existing approval workflow steps. 1941 ''' 1942 deadline = None if timeout is None else time.time() + timeout 1943 req = ApprovalWorkflowStepListRequest() 1944 req.meta.CopyFrom(ListRequestMetadata()) 1945 if self.parent.page_limit > 0: 1946 req.meta.limit = self.parent.page_limit 1947 if self.parent.snapshot_datetime is not None: 1948 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1949 1950 req.filter = plumbing.quote_filter_args(filter, *args) 1951 1952 def generator(svc, req): 1953 tries = 0 1954 while True: 1955 t = None if deadline is None else deadline - time.time() 1956 try: 1957 plumbing_response = svc.stub.List( 1958 req, 1959 metadata=svc.parent.get_metadata( 1960 'ApprovalWorkflowSteps.List', req), 1961 timeout=t) 1962 except Exception as e: 1963 if self.parent.shouldRetry(tries, e, deadline): 1964 tries += 1 1965 time.sleep( 1966 self.parent.exponentialBackoff(tries, deadline)) 1967 continue 1968 raise plumbing.convert_error_to_porcelain(e) from e 1969 tries = 0 1970 for plumbing_item in plumbing_response.approval_workflow_steps: 1971 yield plumbing.convert_approval_workflow_step_to_porcelain( 1972 plumbing_item) 1973 if plumbing_response.meta.next_cursor == '': 1974 break 1975 req.meta.cursor = plumbing_response.meta.next_cursor 1976 1977 return generator(self, req) 1978 1979 1980class SnapshotApprovalWorkflowSteps: 1981 ''' 1982 SnapshotApprovalWorkflowSteps exposes the read only methods of the ApprovalWorkflowSteps 1983 service for historical queries. 1984 ''' 1985 def __init__(self, approval_workflow_steps): 1986 self.approval_workflow_steps = approval_workflow_steps 1987 1988 def get(self, id, timeout=None): 1989 ''' 1990 Deprecated: Get reads one approval workflow step by ID. 1991 ''' 1992 return self.approval_workflow_steps.get(id, timeout=timeout) 1993 1994 def list(self, filter, *args, timeout=None): 1995 ''' 1996 Deprecated: Lists existing approval workflow steps. 1997 ''' 1998 return self.approval_workflow_steps.list(filter, 1999 *args, 2000 timeout=timeout) 2001 2002 2003class ApprovalWorkflowStepsHistory: 2004 ''' 2005 ApprovalWorkflowStepsHistory records all changes to the state of an ApprovalWorkflowStep. 2006 See `strongdm.models.ApprovalWorkflowStepHistory`. 2007 ''' 2008 def __init__(self, channel, client): 2009 self.parent = client 2010 self.stub = ApprovalWorkflowStepsHistoryStub(channel) 2011 2012 def list(self, filter, *args, timeout=None): 2013 ''' 2014 List gets a list of ApprovalWorkflowStepHistory records matching a given set of criteria. 2015 ''' 2016 deadline = None if timeout is None else time.time() + timeout 2017 req = ApprovalWorkflowStepHistoryListRequest() 2018 req.meta.CopyFrom(ListRequestMetadata()) 2019 if self.parent.page_limit > 0: 2020 req.meta.limit = self.parent.page_limit 2021 if self.parent.snapshot_datetime is not None: 2022 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2023 2024 req.filter = plumbing.quote_filter_args(filter, *args) 2025 2026 def generator(svc, req): 2027 tries = 0 2028 while True: 2029 t = None if deadline is None else deadline - time.time() 2030 try: 2031 plumbing_response = svc.stub.List( 2032 req, 2033 metadata=svc.parent.get_metadata( 2034 'ApprovalWorkflowStepsHistory.List', req), 2035 timeout=t) 2036 except Exception as e: 2037 if self.parent.shouldRetry(tries, e, deadline): 2038 tries += 1 2039 time.sleep( 2040 self.parent.exponentialBackoff(tries, deadline)) 2041 continue 2042 raise plumbing.convert_error_to_porcelain(e) from e 2043 tries = 0 2044 for plumbing_item in plumbing_response.history: 2045 yield plumbing.convert_approval_workflow_step_history_to_porcelain( 2046 plumbing_item) 2047 if plumbing_response.meta.next_cursor == '': 2048 break 2049 req.meta.cursor = plumbing_response.meta.next_cursor 2050 2051 return generator(self, req) 2052 2053 2054class ApprovalWorkflows: 2055 ''' 2056 ApprovalWorkflows are the mechanism by which requests for access can be viewed by authorized 2057 approvers and be approved or denied. 2058 See `strongdm.models.ApprovalWorkflow`. 2059 ''' 2060 def __init__(self, channel, client): 2061 self.parent = client 2062 self.stub = ApprovalWorkflowsStub(channel) 2063 2064 def create(self, approval_workflow, timeout=None): 2065 ''' 2066 Create creates a new approval workflow and requires a name and approval mode for the approval workflow. 2067 ''' 2068 deadline = None if timeout is None else time.time() + timeout 2069 req = ApprovalWorkflowCreateRequest() 2070 2071 if approval_workflow is not None: 2072 req.approval_workflow.CopyFrom( 2073 plumbing.convert_approval_workflow_to_plumbing( 2074 approval_workflow)) 2075 tries = 0 2076 plumbing_response = None 2077 while True: 2078 t = None if deadline is None else deadline - time.time() 2079 try: 2080 plumbing_response = self.stub.Create( 2081 req, 2082 metadata=self.parent.get_metadata( 2083 'ApprovalWorkflows.Create', req), 2084 timeout=t) 2085 except Exception as e: 2086 if self.parent.shouldRetry(tries, e, deadline): 2087 tries += 1 2088 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2089 continue 2090 raise plumbing.convert_error_to_porcelain(e) from e 2091 break 2092 2093 resp = models.ApprovalWorkflowCreateResponse() 2094 resp.approval_workflow = plumbing.convert_approval_workflow_to_porcelain( 2095 plumbing_response.approval_workflow) 2096 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2097 plumbing_response.rate_limit) 2098 return resp 2099 2100 def get(self, id, timeout=None): 2101 ''' 2102 Get reads one approval workflow by ID. 2103 ''' 2104 deadline = None if timeout is None else time.time() + timeout 2105 req = ApprovalWorkflowGetRequest() 2106 if self.parent.snapshot_datetime is not None: 2107 req.meta.CopyFrom(GetRequestMetadata()) 2108 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2109 2110 req.id = (id) 2111 tries = 0 2112 plumbing_response = None 2113 while True: 2114 t = None if deadline is None else deadline - time.time() 2115 try: 2116 plumbing_response = self.stub.Get( 2117 req, 2118 metadata=self.parent.get_metadata('ApprovalWorkflows.Get', 2119 req), 2120 timeout=t) 2121 except Exception as e: 2122 if self.parent.shouldRetry(tries, e, deadline): 2123 tries += 1 2124 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2125 continue 2126 raise plumbing.convert_error_to_porcelain(e) from e 2127 break 2128 2129 resp = models.ApprovalWorkflowGetResponse() 2130 resp.approval_workflow = plumbing.convert_approval_workflow_to_porcelain( 2131 plumbing_response.approval_workflow) 2132 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2133 plumbing_response.meta) 2134 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2135 plumbing_response.rate_limit) 2136 return resp 2137 2138 def delete(self, id, timeout=None): 2139 ''' 2140 Delete deletes an existing approval workflow. 2141 ''' 2142 deadline = None if timeout is None else time.time() + timeout 2143 req = ApprovalWorkflowDeleteRequest() 2144 2145 req.id = (id) 2146 tries = 0 2147 plumbing_response = None 2148 while True: 2149 t = None if deadline is None else deadline - time.time() 2150 try: 2151 plumbing_response = self.stub.Delete( 2152 req, 2153 metadata=self.parent.get_metadata( 2154 'ApprovalWorkflows.Delete', req), 2155 timeout=t) 2156 except Exception as e: 2157 if self.parent.shouldRetry(tries, e, deadline): 2158 tries += 1 2159 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2160 continue 2161 raise plumbing.convert_error_to_porcelain(e) from e 2162 break 2163 2164 resp = models.ApprovalWorkflowDeleteResponse() 2165 resp.id = (plumbing_response.id) 2166 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2167 plumbing_response.rate_limit) 2168 return resp 2169 2170 def update(self, approval_workflow, timeout=None): 2171 ''' 2172 Update updates an existing approval workflow. 2173 ''' 2174 deadline = None if timeout is None else time.time() + timeout 2175 req = ApprovalWorkflowUpdateRequest() 2176 2177 if approval_workflow is not None: 2178 req.approval_workflow.CopyFrom( 2179 plumbing.convert_approval_workflow_to_plumbing( 2180 approval_workflow)) 2181 tries = 0 2182 plumbing_response = None 2183 while True: 2184 t = None if deadline is None else deadline - time.time() 2185 try: 2186 plumbing_response = self.stub.Update( 2187 req, 2188 metadata=self.parent.get_metadata( 2189 'ApprovalWorkflows.Update', req), 2190 timeout=t) 2191 except Exception as e: 2192 if self.parent.shouldRetry(tries, e, deadline): 2193 tries += 1 2194 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2195 continue 2196 raise plumbing.convert_error_to_porcelain(e) from e 2197 break 2198 2199 resp = models.ApprovalWorkflowUpdateResponse() 2200 resp.approval_workflow = plumbing.convert_approval_workflow_to_porcelain( 2201 plumbing_response.approval_workflow) 2202 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2203 plumbing_response.rate_limit) 2204 return resp 2205 2206 def list(self, filter, *args, timeout=None): 2207 ''' 2208 Lists existing approval workflows. 2209 ''' 2210 deadline = None if timeout is None else time.time() + timeout 2211 req = ApprovalWorkflowListRequest() 2212 req.meta.CopyFrom(ListRequestMetadata()) 2213 if self.parent.page_limit > 0: 2214 req.meta.limit = self.parent.page_limit 2215 if self.parent.snapshot_datetime is not None: 2216 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2217 2218 req.filter = plumbing.quote_filter_args(filter, *args) 2219 2220 def generator(svc, req): 2221 tries = 0 2222 while True: 2223 t = None if deadline is None else deadline - time.time() 2224 try: 2225 plumbing_response = svc.stub.List( 2226 req, 2227 metadata=svc.parent.get_metadata( 2228 'ApprovalWorkflows.List', req), 2229 timeout=t) 2230 except Exception as e: 2231 if self.parent.shouldRetry(tries, e, deadline): 2232 tries += 1 2233 time.sleep( 2234 self.parent.exponentialBackoff(tries, deadline)) 2235 continue 2236 raise plumbing.convert_error_to_porcelain(e) from e 2237 tries = 0 2238 for plumbing_item in plumbing_response.approval_workflows: 2239 yield plumbing.convert_approval_workflow_to_porcelain( 2240 plumbing_item) 2241 if plumbing_response.meta.next_cursor == '': 2242 break 2243 req.meta.cursor = plumbing_response.meta.next_cursor 2244 2245 return generator(self, req) 2246 2247 2248class SnapshotApprovalWorkflows: 2249 ''' 2250 SnapshotApprovalWorkflows exposes the read only methods of the ApprovalWorkflows 2251 service for historical queries. 2252 ''' 2253 def __init__(self, approval_workflows): 2254 self.approval_workflows = approval_workflows 2255 2256 def get(self, id, timeout=None): 2257 ''' 2258 Get reads one approval workflow by ID. 2259 ''' 2260 return self.approval_workflows.get(id, timeout=timeout) 2261 2262 def list(self, filter, *args, timeout=None): 2263 ''' 2264 Lists existing approval workflows. 2265 ''' 2266 return self.approval_workflows.list(filter, *args, timeout=timeout) 2267 2268 2269class ApprovalWorkflowsHistory: 2270 ''' 2271 ApprovalWorkflowsHistory records all changes to the state of an ApprovalWorkflow. 2272 See `strongdm.models.ApprovalWorkflowHistory`. 2273 ''' 2274 def __init__(self, channel, client): 2275 self.parent = client 2276 self.stub = ApprovalWorkflowsHistoryStub(channel) 2277 2278 def list(self, filter, *args, timeout=None): 2279 ''' 2280 List gets a list of ApprovalWorkflowHistory records matching a given set of criteria. 2281 ''' 2282 deadline = None if timeout is None else time.time() + timeout 2283 req = ApprovalWorkflowHistoryListRequest() 2284 req.meta.CopyFrom(ListRequestMetadata()) 2285 if self.parent.page_limit > 0: 2286 req.meta.limit = self.parent.page_limit 2287 if self.parent.snapshot_datetime is not None: 2288 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2289 2290 req.filter = plumbing.quote_filter_args(filter, *args) 2291 2292 def generator(svc, req): 2293 tries = 0 2294 while True: 2295 t = None if deadline is None else deadline - time.time() 2296 try: 2297 plumbing_response = svc.stub.List( 2298 req, 2299 metadata=svc.parent.get_metadata( 2300 'ApprovalWorkflowsHistory.List', req), 2301 timeout=t) 2302 except Exception as e: 2303 if self.parent.shouldRetry(tries, e, deadline): 2304 tries += 1 2305 time.sleep( 2306 self.parent.exponentialBackoff(tries, deadline)) 2307 continue 2308 raise plumbing.convert_error_to_porcelain(e) from e 2309 tries = 0 2310 for plumbing_item in plumbing_response.history: 2311 yield plumbing.convert_approval_workflow_history_to_porcelain( 2312 plumbing_item) 2313 if plumbing_response.meta.next_cursor == '': 2314 break 2315 req.meta.cursor = plumbing_response.meta.next_cursor 2316 2317 return generator(self, req) 2318 2319 2320class ControlPanel: 2321 ''' 2322 ControlPanel contains all administrative controls. 2323 ''' 2324 def __init__(self, channel, client): 2325 self.parent = client 2326 self.stub = ControlPanelStub(channel) 2327 2328 def get_sshca_public_key(self, timeout=None): 2329 ''' 2330 GetSSHCAPublicKey retrieves the SSH CA public key. 2331 ''' 2332 deadline = None if timeout is None else time.time() + timeout 2333 req = ControlPanelGetSSHCAPublicKeyRequest() 2334 2335 tries = 0 2336 plumbing_response = None 2337 while True: 2338 t = None if deadline is None else deadline - time.time() 2339 try: 2340 plumbing_response = self.stub.GetSSHCAPublicKey( 2341 req, 2342 metadata=self.parent.get_metadata( 2343 'ControlPanel.GetSSHCAPublicKey', req), 2344 timeout=t) 2345 except Exception as e: 2346 if self.parent.shouldRetry(tries, e, deadline): 2347 tries += 1 2348 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2349 continue 2350 raise plumbing.convert_error_to_porcelain(e) from e 2351 break 2352 2353 resp = models.ControlPanelGetSSHCAPublicKeyResponse() 2354 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2355 plumbing_response.meta) 2356 resp.public_key = (plumbing_response.public_key) 2357 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2358 plumbing_response.rate_limit) 2359 return resp 2360 2361 def get_rdpca_public_key(self, timeout=None): 2362 ''' 2363 GetRDPCAPublicKey retrieves the RDP CA public key. 2364 ''' 2365 deadline = None if timeout is None else time.time() + timeout 2366 req = ControlPanelGetRDPCAPublicKeyRequest() 2367 2368 tries = 0 2369 plumbing_response = None 2370 while True: 2371 t = None if deadline is None else deadline - time.time() 2372 try: 2373 plumbing_response = self.stub.GetRDPCAPublicKey( 2374 req, 2375 metadata=self.parent.get_metadata( 2376 'ControlPanel.GetRDPCAPublicKey', req), 2377 timeout=t) 2378 except Exception as e: 2379 if self.parent.shouldRetry(tries, e, deadline): 2380 tries += 1 2381 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2382 continue 2383 raise plumbing.convert_error_to_porcelain(e) from e 2384 break 2385 2386 resp = models.ControlPanelGetRDPCAPublicKeyResponse() 2387 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2388 plumbing_response.meta) 2389 resp.public_key = (plumbing_response.public_key) 2390 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2391 plumbing_response.rate_limit) 2392 return resp 2393 2394 def verify_jwt(self, token, timeout=None): 2395 ''' 2396 VerifyJWT reports whether the given JWT token (x-sdm-token) is valid. 2397 ''' 2398 deadline = None if timeout is None else time.time() + timeout 2399 req = ControlPanelVerifyJWTRequest() 2400 2401 req.token = (token) 2402 tries = 0 2403 plumbing_response = None 2404 while True: 2405 t = None if deadline is None else deadline - time.time() 2406 try: 2407 plumbing_response = self.stub.VerifyJWT( 2408 req, 2409 metadata=self.parent.get_metadata('ControlPanel.VerifyJWT', 2410 req), 2411 timeout=t) 2412 except Exception as e: 2413 if self.parent.shouldRetry(tries, e, deadline): 2414 tries += 1 2415 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2416 continue 2417 raise plumbing.convert_error_to_porcelain(e) from e 2418 break 2419 2420 resp = models.ControlPanelVerifyJWTResponse() 2421 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2422 plumbing_response.meta) 2423 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2424 plumbing_response.rate_limit) 2425 resp.valid = (plumbing_response.valid) 2426 return resp 2427 2428 2429class DiscoveryConnectors: 2430 ''' 2431 A Discovery Connector is a configuration object for performing Resource 2432 Scans in remote systems such as AWS, GCP, Azure, and other systems. 2433 See: 2434 `strongdm.models.AWSConnector` 2435 `strongdm.models.AzureConnector` 2436 `strongdm.models.GCPConnector` 2437 ''' 2438 def __init__(self, channel, client): 2439 self.parent = client 2440 self.stub = DiscoveryConnectorsStub(channel) 2441 2442 def create(self, connector, timeout=None): 2443 ''' 2444 Create adds a new Connector. 2445 ''' 2446 deadline = None if timeout is None else time.time() + timeout 2447 req = ConnectorCreateRequest() 2448 2449 if connector is not None: 2450 req.connector.CopyFrom( 2451 plumbing.convert_connector_to_plumbing(connector)) 2452 tries = 0 2453 plumbing_response = None 2454 while True: 2455 t = None if deadline is None else deadline - time.time() 2456 try: 2457 plumbing_response = self.stub.Create( 2458 req, 2459 metadata=self.parent.get_metadata( 2460 'DiscoveryConnectors.Create', req), 2461 timeout=t) 2462 except Exception as e: 2463 if self.parent.shouldRetry(tries, e, deadline): 2464 tries += 1 2465 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2466 continue 2467 raise plumbing.convert_error_to_porcelain(e) from e 2468 break 2469 2470 resp = models.ConnectorCreateResponse() 2471 resp.connector = plumbing.convert_connector_to_porcelain( 2472 plumbing_response.connector) 2473 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2474 plumbing_response.rate_limit) 2475 return resp 2476 2477 def get(self, id, timeout=None): 2478 ''' 2479 Get reads one Connector by ID 2480 ''' 2481 deadline = None if timeout is None else time.time() + timeout 2482 req = ConnectorGetRequest() 2483 if self.parent.snapshot_datetime is not None: 2484 req.meta.CopyFrom(GetRequestMetadata()) 2485 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2486 2487 req.id = (id) 2488 tries = 0 2489 plumbing_response = None 2490 while True: 2491 t = None if deadline is None else deadline - time.time() 2492 try: 2493 plumbing_response = self.stub.Get( 2494 req, 2495 metadata=self.parent.get_metadata( 2496 'DiscoveryConnectors.Get', req), 2497 timeout=t) 2498 except Exception as e: 2499 if self.parent.shouldRetry(tries, e, deadline): 2500 tries += 1 2501 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2502 continue 2503 raise plumbing.convert_error_to_porcelain(e) from e 2504 break 2505 2506 resp = models.ConnectorGetResponse() 2507 resp.connector = plumbing.convert_connector_to_porcelain( 2508 plumbing_response.connector) 2509 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2510 plumbing_response.meta) 2511 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2512 plumbing_response.rate_limit) 2513 return resp 2514 2515 def update(self, connector, timeout=None): 2516 ''' 2517 Update replaces all the fields of a Connector by ID. 2518 ''' 2519 deadline = None if timeout is None else time.time() + timeout 2520 req = ConnectorUpdateRequest() 2521 2522 if connector is not None: 2523 req.connector.CopyFrom( 2524 plumbing.convert_connector_to_plumbing(connector)) 2525 tries = 0 2526 plumbing_response = None 2527 while True: 2528 t = None if deadline is None else deadline - time.time() 2529 try: 2530 plumbing_response = self.stub.Update( 2531 req, 2532 metadata=self.parent.get_metadata( 2533 'DiscoveryConnectors.Update', req), 2534 timeout=t) 2535 except Exception as e: 2536 if self.parent.shouldRetry(tries, e, deadline): 2537 tries += 1 2538 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2539 continue 2540 raise plumbing.convert_error_to_porcelain(e) from e 2541 break 2542 2543 resp = models.ConnectorUpdateResponse() 2544 resp.connector = plumbing.convert_connector_to_porcelain( 2545 plumbing_response.connector) 2546 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2547 plumbing_response.rate_limit) 2548 return resp 2549 2550 def delete(self, id, timeout=None): 2551 ''' 2552 Delete removes a Connector by ID. 2553 ''' 2554 deadline = None if timeout is None else time.time() + timeout 2555 req = ConnectorDeleteRequest() 2556 2557 req.id = (id) 2558 tries = 0 2559 plumbing_response = None 2560 while True: 2561 t = None if deadline is None else deadline - time.time() 2562 try: 2563 plumbing_response = self.stub.Delete( 2564 req, 2565 metadata=self.parent.get_metadata( 2566 'DiscoveryConnectors.Delete', req), 2567 timeout=t) 2568 except Exception as e: 2569 if self.parent.shouldRetry(tries, e, deadline): 2570 tries += 1 2571 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2572 continue 2573 raise plumbing.convert_error_to_porcelain(e) from e 2574 break 2575 2576 resp = models.ConnectorDeleteResponse() 2577 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 2578 plumbing_response.meta) 2579 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2580 plumbing_response.rate_limit) 2581 return resp 2582 2583 def list(self, filter, *args, timeout=None): 2584 ''' 2585 List gets a list of Connectors matching a given set of criteria. 2586 ''' 2587 deadline = None if timeout is None else time.time() + timeout 2588 req = ConnectorListRequest() 2589 req.meta.CopyFrom(ListRequestMetadata()) 2590 if self.parent.page_limit > 0: 2591 req.meta.limit = self.parent.page_limit 2592 if self.parent.snapshot_datetime is not None: 2593 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2594 2595 req.filter = plumbing.quote_filter_args(filter, *args) 2596 2597 def generator(svc, req): 2598 tries = 0 2599 while True: 2600 t = None if deadline is None else deadline - time.time() 2601 try: 2602 plumbing_response = svc.stub.List( 2603 req, 2604 metadata=svc.parent.get_metadata( 2605 'DiscoveryConnectors.List', req), 2606 timeout=t) 2607 except Exception as e: 2608 if self.parent.shouldRetry(tries, e, deadline): 2609 tries += 1 2610 time.sleep( 2611 self.parent.exponentialBackoff(tries, deadline)) 2612 continue 2613 raise plumbing.convert_error_to_porcelain(e) from e 2614 tries = 0 2615 for plumbing_item in plumbing_response.connectors: 2616 yield plumbing.convert_connector_to_porcelain( 2617 plumbing_item) 2618 if plumbing_response.meta.next_cursor == '': 2619 break 2620 req.meta.cursor = plumbing_response.meta.next_cursor 2621 2622 return generator(self, req) 2623 2624 2625class SnapshotDiscoveryConnectors: 2626 ''' 2627 SnapshotDiscoveryConnectors exposes the read only methods of the DiscoveryConnectors 2628 service for historical queries. 2629 ''' 2630 def __init__(self, discovery_connectors): 2631 self.discovery_connectors = discovery_connectors 2632 2633 def get(self, id, timeout=None): 2634 ''' 2635 Get reads one Connector by ID 2636 ''' 2637 return self.discovery_connectors.get(id, timeout=timeout) 2638 2639 def list(self, filter, *args, timeout=None): 2640 ''' 2641 List gets a list of Connectors matching a given set of criteria. 2642 ''' 2643 return self.discovery_connectors.list(filter, *args, timeout=timeout) 2644 2645 2646class Roles: 2647 ''' 2648 A Role has a list of access rules which determine which Resources the members 2649 of the Role have access to. An Account can be a member of multiple Roles via 2650 AccountAttachments. 2651 See `strongdm.models.Role`. 2652 ''' 2653 def __init__(self, channel, client): 2654 self.parent = client 2655 self.stub = RolesStub(channel) 2656 2657 def create(self, role, timeout=None): 2658 ''' 2659 Create registers a new Role. 2660 ''' 2661 deadline = None if timeout is None else time.time() + timeout 2662 req = RoleCreateRequest() 2663 2664 if role is not None: 2665 req.role.CopyFrom(plumbing.convert_role_to_plumbing(role)) 2666 tries = 0 2667 plumbing_response = None 2668 while True: 2669 t = None if deadline is None else deadline - time.time() 2670 try: 2671 plumbing_response = self.stub.Create( 2672 req, 2673 metadata=self.parent.get_metadata('Roles.Create', req), 2674 timeout=t) 2675 except Exception as e: 2676 if self.parent.shouldRetry(tries, e, deadline): 2677 tries += 1 2678 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2679 continue 2680 raise plumbing.convert_error_to_porcelain(e) from e 2681 break 2682 2683 resp = models.RoleCreateResponse() 2684 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 2685 plumbing_response.meta) 2686 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2687 plumbing_response.rate_limit) 2688 resp.role = plumbing.convert_role_to_porcelain(plumbing_response.role) 2689 return resp 2690 2691 def get(self, id, timeout=None): 2692 ''' 2693 Get reads one Role by ID. 2694 ''' 2695 deadline = None if timeout is None else time.time() + timeout 2696 req = RoleGetRequest() 2697 if self.parent.snapshot_datetime is not None: 2698 req.meta.CopyFrom(GetRequestMetadata()) 2699 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2700 2701 req.id = (id) 2702 tries = 0 2703 plumbing_response = None 2704 while True: 2705 t = None if deadline is None else deadline - time.time() 2706 try: 2707 plumbing_response = self.stub.Get( 2708 req, 2709 metadata=self.parent.get_metadata('Roles.Get', req), 2710 timeout=t) 2711 except Exception as e: 2712 if self.parent.shouldRetry(tries, e, deadline): 2713 tries += 1 2714 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2715 continue 2716 raise plumbing.convert_error_to_porcelain(e) from e 2717 break 2718 2719 resp = models.RoleGetResponse() 2720 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2721 plumbing_response.meta) 2722 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2723 plumbing_response.rate_limit) 2724 resp.role = plumbing.convert_role_to_porcelain(plumbing_response.role) 2725 return resp 2726 2727 def update(self, role, timeout=None): 2728 ''' 2729 Update replaces all the fields of a Role by ID. 2730 ''' 2731 deadline = None if timeout is None else time.time() + timeout 2732 req = RoleUpdateRequest() 2733 2734 if role is not None: 2735 req.role.CopyFrom(plumbing.convert_role_to_plumbing(role)) 2736 tries = 0 2737 plumbing_response = None 2738 while True: 2739 t = None if deadline is None else deadline - time.time() 2740 try: 2741 plumbing_response = self.stub.Update( 2742 req, 2743 metadata=self.parent.get_metadata('Roles.Update', req), 2744 timeout=t) 2745 except Exception as e: 2746 if self.parent.shouldRetry(tries, e, deadline): 2747 tries += 1 2748 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2749 continue 2750 raise plumbing.convert_error_to_porcelain(e) from e 2751 break 2752 2753 resp = models.RoleUpdateResponse() 2754 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 2755 plumbing_response.meta) 2756 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2757 plumbing_response.rate_limit) 2758 resp.role = plumbing.convert_role_to_porcelain(plumbing_response.role) 2759 return resp 2760 2761 def delete(self, id, timeout=None): 2762 ''' 2763 Delete removes a Role by ID. 2764 ''' 2765 deadline = None if timeout is None else time.time() + timeout 2766 req = RoleDeleteRequest() 2767 2768 req.id = (id) 2769 tries = 0 2770 plumbing_response = None 2771 while True: 2772 t = None if deadline is None else deadline - time.time() 2773 try: 2774 plumbing_response = self.stub.Delete( 2775 req, 2776 metadata=self.parent.get_metadata('Roles.Delete', req), 2777 timeout=t) 2778 except Exception as e: 2779 if self.parent.shouldRetry(tries, e, deadline): 2780 tries += 1 2781 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2782 continue 2783 raise plumbing.convert_error_to_porcelain(e) from e 2784 break 2785 2786 resp = models.RoleDeleteResponse() 2787 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 2788 plumbing_response.meta) 2789 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2790 plumbing_response.rate_limit) 2791 return resp 2792 2793 def list(self, filter, *args, timeout=None): 2794 ''' 2795 List gets a list of Roles matching a given set of criteria. 2796 ''' 2797 deadline = None if timeout is None else time.time() + timeout 2798 req = RoleListRequest() 2799 req.meta.CopyFrom(ListRequestMetadata()) 2800 if self.parent.page_limit > 0: 2801 req.meta.limit = self.parent.page_limit 2802 if self.parent.snapshot_datetime is not None: 2803 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2804 2805 req.filter = plumbing.quote_filter_args(filter, *args) 2806 2807 def generator(svc, req): 2808 tries = 0 2809 while True: 2810 t = None if deadline is None else deadline - time.time() 2811 try: 2812 plumbing_response = svc.stub.List( 2813 req, 2814 metadata=svc.parent.get_metadata('Roles.List', req), 2815 timeout=t) 2816 except Exception as e: 2817 if self.parent.shouldRetry(tries, e, deadline): 2818 tries += 1 2819 time.sleep( 2820 self.parent.exponentialBackoff(tries, deadline)) 2821 continue 2822 raise plumbing.convert_error_to_porcelain(e) from e 2823 tries = 0 2824 for plumbing_item in plumbing_response.roles: 2825 yield plumbing.convert_role_to_porcelain(plumbing_item) 2826 if plumbing_response.meta.next_cursor == '': 2827 break 2828 req.meta.cursor = plumbing_response.meta.next_cursor 2829 2830 return generator(self, req) 2831 2832 2833class SnapshotRoles: 2834 ''' 2835 SnapshotRoles exposes the read only methods of the Roles 2836 service for historical queries. 2837 ''' 2838 def __init__(self, roles): 2839 self.roles = roles 2840 2841 def get(self, id, timeout=None): 2842 ''' 2843 Get reads one Role by ID. 2844 ''' 2845 return self.roles.get(id, timeout=timeout) 2846 2847 def list(self, filter, *args, timeout=None): 2848 ''' 2849 List gets a list of Roles matching a given set of criteria. 2850 ''' 2851 return self.roles.list(filter, *args, timeout=timeout) 2852 2853 2854class Groups: 2855 ''' 2856 A Group is a set of principals. 2857 See `strongdm.models.Group`. 2858 ''' 2859 def __init__(self, channel, client): 2860 self.parent = client 2861 self.stub = GroupsStub(channel) 2862 2863 def create(self, group, timeout=None): 2864 ''' 2865 Create registers a new Group. 2866 ''' 2867 deadline = None if timeout is None else time.time() + timeout 2868 req = GroupCreateRequest() 2869 2870 if group is not None: 2871 req.group.CopyFrom(plumbing.convert_group_to_plumbing(group)) 2872 tries = 0 2873 plumbing_response = None 2874 while True: 2875 t = None if deadline is None else deadline - time.time() 2876 try: 2877 plumbing_response = self.stub.Create( 2878 req, 2879 metadata=self.parent.get_metadata('Groups.Create', req), 2880 timeout=t) 2881 except Exception as e: 2882 if self.parent.shouldRetry(tries, e, deadline): 2883 tries += 1 2884 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2885 continue 2886 raise plumbing.convert_error_to_porcelain(e) from e 2887 break 2888 2889 resp = models.GroupCreateResponse() 2890 resp.group = plumbing.convert_group_to_porcelain( 2891 plumbing_response.group) 2892 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2893 plumbing_response.rate_limit) 2894 return resp 2895 2896 def create_from_roles(self, role_ids, commit, timeout=None): 2897 deadline = None if timeout is None else time.time() + timeout 2898 req = GroupCreateFromRolesRequest() 2899 2900 req.role_ids.extend((role_ids)) 2901 req.commit = (commit) 2902 tries = 0 2903 plumbing_response = None 2904 while True: 2905 t = None if deadline is None else deadline - time.time() 2906 try: 2907 plumbing_response = self.stub.CreateFromRoles( 2908 req, 2909 metadata=self.parent.get_metadata('Groups.CreateFromRoles', 2910 req), 2911 timeout=t) 2912 except Exception as e: 2913 if self.parent.shouldRetry(tries, e, deadline): 2914 tries += 1 2915 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2916 continue 2917 raise plumbing.convert_error_to_porcelain(e) from e 2918 break 2919 2920 resp = models.GroupCreateFromRolesResponse() 2921 resp.group_from_role = plumbing.convert_repeated_group_from_role_to_porcelain( 2922 plumbing_response.group_from_role) 2923 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2924 plumbing_response.rate_limit) 2925 return resp 2926 2927 def get(self, id, timeout=None): 2928 ''' 2929 Get reads one Group by ID. 2930 ''' 2931 deadline = None if timeout is None else time.time() + timeout 2932 req = GroupGetRequest() 2933 if self.parent.snapshot_datetime is not None: 2934 req.meta.CopyFrom(GetRequestMetadata()) 2935 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2936 2937 req.id = (id) 2938 tries = 0 2939 plumbing_response = None 2940 while True: 2941 t = None if deadline is None else deadline - time.time() 2942 try: 2943 plumbing_response = self.stub.Get( 2944 req, 2945 metadata=self.parent.get_metadata('Groups.Get', req), 2946 timeout=t) 2947 except Exception as e: 2948 if self.parent.shouldRetry(tries, e, deadline): 2949 tries += 1 2950 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2951 continue 2952 raise plumbing.convert_error_to_porcelain(e) from e 2953 break 2954 2955 resp = models.GroupGetResponse() 2956 resp.group = plumbing.convert_group_to_porcelain( 2957 plumbing_response.group) 2958 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2959 plumbing_response.meta) 2960 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2961 plumbing_response.rate_limit) 2962 return resp 2963 2964 def update(self, group, timeout=None): 2965 ''' 2966 Update replaces all the fields of a Group by ID. 2967 ''' 2968 deadline = None if timeout is None else time.time() + timeout 2969 req = GroupUpdateRequest() 2970 2971 if group is not None: 2972 req.group.CopyFrom(plumbing.convert_group_to_plumbing(group)) 2973 tries = 0 2974 plumbing_response = None 2975 while True: 2976 t = None if deadline is None else deadline - time.time() 2977 try: 2978 plumbing_response = self.stub.Update( 2979 req, 2980 metadata=self.parent.get_metadata('Groups.Update', req), 2981 timeout=t) 2982 except Exception as e: 2983 if self.parent.shouldRetry(tries, e, deadline): 2984 tries += 1 2985 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2986 continue 2987 raise plumbing.convert_error_to_porcelain(e) from e 2988 break 2989 2990 resp = models.GroupUpdateResponse() 2991 resp.group = plumbing.convert_group_to_porcelain( 2992 plumbing_response.group) 2993 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2994 plumbing_response.rate_limit) 2995 return resp 2996 2997 def delete(self, id, timeout=None): 2998 ''' 2999 Delete removes a Group by ID. 3000 ''' 3001 deadline = None if timeout is None else time.time() + timeout 3002 req = GroupDeleteRequest() 3003 3004 req.id = (id) 3005 tries = 0 3006 plumbing_response = None 3007 while True: 3008 t = None if deadline is None else deadline - time.time() 3009 try: 3010 plumbing_response = self.stub.Delete( 3011 req, 3012 metadata=self.parent.get_metadata('Groups.Delete', req), 3013 timeout=t) 3014 except Exception as e: 3015 if self.parent.shouldRetry(tries, e, deadline): 3016 tries += 1 3017 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3018 continue 3019 raise plumbing.convert_error_to_porcelain(e) from e 3020 break 3021 3022 resp = models.GroupDeleteResponse() 3023 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3024 plumbing_response.meta) 3025 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3026 plumbing_response.rate_limit) 3027 return resp 3028 3029 def list(self, filter, *args, timeout=None): 3030 ''' 3031 List gets a list of Groups matching a given set of criteria. 3032 ''' 3033 deadline = None if timeout is None else time.time() + timeout 3034 req = GroupListRequest() 3035 req.meta.CopyFrom(ListRequestMetadata()) 3036 if self.parent.page_limit > 0: 3037 req.meta.limit = self.parent.page_limit 3038 if self.parent.snapshot_datetime is not None: 3039 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3040 3041 req.filter = plumbing.quote_filter_args(filter, *args) 3042 3043 def generator(svc, req): 3044 tries = 0 3045 while True: 3046 t = None if deadline is None else deadline - time.time() 3047 try: 3048 plumbing_response = svc.stub.List( 3049 req, 3050 metadata=svc.parent.get_metadata('Groups.List', req), 3051 timeout=t) 3052 except Exception as e: 3053 if self.parent.shouldRetry(tries, e, deadline): 3054 tries += 1 3055 time.sleep( 3056 self.parent.exponentialBackoff(tries, deadline)) 3057 continue 3058 raise plumbing.convert_error_to_porcelain(e) from e 3059 tries = 0 3060 for plumbing_item in plumbing_response.groups: 3061 yield plumbing.convert_group_to_porcelain(plumbing_item) 3062 if plumbing_response.meta.next_cursor == '': 3063 break 3064 req.meta.cursor = plumbing_response.meta.next_cursor 3065 3066 return generator(self, req) 3067 3068 3069class SnapshotGroups: 3070 ''' 3071 SnapshotGroups exposes the read only methods of the Groups 3072 service for historical queries. 3073 ''' 3074 def __init__(self, groups): 3075 self.groups = groups 3076 3077 def get(self, id, timeout=None): 3078 ''' 3079 Get reads one Group by ID. 3080 ''' 3081 return self.groups.get(id, timeout=timeout) 3082 3083 def list(self, filter, *args, timeout=None): 3084 ''' 3085 List gets a list of Groups matching a given set of criteria. 3086 ''' 3087 return self.groups.list(filter, *args, timeout=timeout) 3088 3089 3090class GroupsHistory: 3091 ''' 3092 GroupsHistory records all changes to the state of a Group. 3093 See `strongdm.models.GroupHistory`. 3094 ''' 3095 def __init__(self, channel, client): 3096 self.parent = client 3097 self.stub = GroupsHistoryStub(channel) 3098 3099 def list(self, filter, *args, timeout=None): 3100 ''' 3101 List gets a list of GroupHistory records matching a given set of criteria. 3102 ''' 3103 deadline = None if timeout is None else time.time() + timeout 3104 req = GroupHistoryListRequest() 3105 req.meta.CopyFrom(ListRequestMetadata()) 3106 if self.parent.page_limit > 0: 3107 req.meta.limit = self.parent.page_limit 3108 if self.parent.snapshot_datetime is not None: 3109 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3110 3111 req.filter = plumbing.quote_filter_args(filter, *args) 3112 3113 def generator(svc, req): 3114 tries = 0 3115 while True: 3116 t = None if deadline is None else deadline - time.time() 3117 try: 3118 plumbing_response = svc.stub.List( 3119 req, 3120 metadata=svc.parent.get_metadata( 3121 'GroupsHistory.List', req), 3122 timeout=t) 3123 except Exception as e: 3124 if self.parent.shouldRetry(tries, e, deadline): 3125 tries += 1 3126 time.sleep( 3127 self.parent.exponentialBackoff(tries, deadline)) 3128 continue 3129 raise plumbing.convert_error_to_porcelain(e) from e 3130 tries = 0 3131 for plumbing_item in plumbing_response.history: 3132 yield plumbing.convert_group_history_to_porcelain( 3133 plumbing_item) 3134 if plumbing_response.meta.next_cursor == '': 3135 break 3136 req.meta.cursor = plumbing_response.meta.next_cursor 3137 3138 return generator(self, req) 3139 3140 3141class GroupsRoles: 3142 ''' 3143 A GroupRole is an assignment of a Group to a Role. 3144 See `strongdm.models.GroupRole`. 3145 ''' 3146 def __init__(self, channel, client): 3147 self.parent = client 3148 self.stub = GroupsRolesStub(channel) 3149 3150 def create(self, group_role, timeout=None): 3151 ''' 3152 Create registers a new GroupRole. 3153 ''' 3154 deadline = None if timeout is None else time.time() + timeout 3155 req = GroupRoleCreateRequest() 3156 3157 if group_role is not None: 3158 req.group_role.CopyFrom( 3159 plumbing.convert_group_role_to_plumbing(group_role)) 3160 tries = 0 3161 plumbing_response = None 3162 while True: 3163 t = None if deadline is None else deadline - time.time() 3164 try: 3165 plumbing_response = self.stub.Create( 3166 req, 3167 metadata=self.parent.get_metadata('GroupsRoles.Create', 3168 req), 3169 timeout=t) 3170 except Exception as e: 3171 if self.parent.shouldRetry(tries, e, deadline): 3172 tries += 1 3173 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3174 continue 3175 raise plumbing.convert_error_to_porcelain(e) from e 3176 break 3177 3178 resp = models.GroupRoleCreateResponse() 3179 resp.group_role = plumbing.convert_group_role_to_porcelain( 3180 plumbing_response.group_role) 3181 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3182 plumbing_response.rate_limit) 3183 return resp 3184 3185 def get(self, id, timeout=None): 3186 ''' 3187 Get reads one GroupRole by ID. 3188 ''' 3189 deadline = None if timeout is None else time.time() + timeout 3190 req = GroupRoleGetRequest() 3191 if self.parent.snapshot_datetime is not None: 3192 req.meta.CopyFrom(GetRequestMetadata()) 3193 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3194 3195 req.id = (id) 3196 tries = 0 3197 plumbing_response = None 3198 while True: 3199 t = None if deadline is None else deadline - time.time() 3200 try: 3201 plumbing_response = self.stub.Get( 3202 req, 3203 metadata=self.parent.get_metadata('GroupsRoles.Get', req), 3204 timeout=t) 3205 except Exception as e: 3206 if self.parent.shouldRetry(tries, e, deadline): 3207 tries += 1 3208 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3209 continue 3210 raise plumbing.convert_error_to_porcelain(e) from e 3211 break 3212 3213 resp = models.GroupRoleGetResponse() 3214 resp.group_role = plumbing.convert_group_role_to_porcelain( 3215 plumbing_response.group_role) 3216 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3217 plumbing_response.meta) 3218 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3219 plumbing_response.rate_limit) 3220 return resp 3221 3222 def delete(self, id, timeout=None): 3223 ''' 3224 Delete removes a GroupRole by ID. 3225 ''' 3226 deadline = None if timeout is None else time.time() + timeout 3227 req = GroupRoleDeleteRequest() 3228 3229 req.id = (id) 3230 tries = 0 3231 plumbing_response = None 3232 while True: 3233 t = None if deadline is None else deadline - time.time() 3234 try: 3235 plumbing_response = self.stub.Delete( 3236 req, 3237 metadata=self.parent.get_metadata('GroupsRoles.Delete', 3238 req), 3239 timeout=t) 3240 except Exception as e: 3241 if self.parent.shouldRetry(tries, e, deadline): 3242 tries += 1 3243 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3244 continue 3245 raise plumbing.convert_error_to_porcelain(e) from e 3246 break 3247 3248 resp = models.GroupRoleDeleteResponse() 3249 resp.group_role = plumbing.convert_group_role_to_porcelain( 3250 plumbing_response.group_role) 3251 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3252 plumbing_response.meta) 3253 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3254 plumbing_response.rate_limit) 3255 return resp 3256 3257 def list(self, filter, *args, timeout=None): 3258 ''' 3259 List gets a list of GroupRoles matching a given set of criteria. 3260 ''' 3261 deadline = None if timeout is None else time.time() + timeout 3262 req = GroupRoleListRequest() 3263 req.meta.CopyFrom(ListRequestMetadata()) 3264 if self.parent.page_limit > 0: 3265 req.meta.limit = self.parent.page_limit 3266 if self.parent.snapshot_datetime is not None: 3267 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3268 3269 req.filter = plumbing.quote_filter_args(filter, *args) 3270 3271 def generator(svc, req): 3272 tries = 0 3273 while True: 3274 t = None if deadline is None else deadline - time.time() 3275 try: 3276 plumbing_response = svc.stub.List( 3277 req, 3278 metadata=svc.parent.get_metadata( 3279 'GroupsRoles.List', req), 3280 timeout=t) 3281 except Exception as e: 3282 if self.parent.shouldRetry(tries, e, deadline): 3283 tries += 1 3284 time.sleep( 3285 self.parent.exponentialBackoff(tries, deadline)) 3286 continue 3287 raise plumbing.convert_error_to_porcelain(e) from e 3288 tries = 0 3289 for plumbing_item in plumbing_response.groups_roles: 3290 yield plumbing.convert_group_role_to_porcelain( 3291 plumbing_item) 3292 if plumbing_response.meta.next_cursor == '': 3293 break 3294 req.meta.cursor = plumbing_response.meta.next_cursor 3295 3296 return generator(self, req) 3297 3298 3299class SnapshotGroupsRoles: 3300 ''' 3301 SnapshotGroupsRoles exposes the read only methods of the GroupsRoles 3302 service for historical queries. 3303 ''' 3304 def __init__(self, groups_roles): 3305 self.groups_roles = groups_roles 3306 3307 def get(self, id, timeout=None): 3308 ''' 3309 Get reads one GroupRole by ID. 3310 ''' 3311 return self.groups_roles.get(id, timeout=timeout) 3312 3313 def list(self, filter, *args, timeout=None): 3314 ''' 3315 List gets a list of GroupRoles matching a given set of criteria. 3316 ''' 3317 return self.groups_roles.list(filter, *args, timeout=timeout) 3318 3319 3320class GroupsRolesHistory: 3321 ''' 3322 GroupsRolesHistory records all changes to the state of a GroupRole. 3323 See `strongdm.models.GroupRoleHistory`. 3324 ''' 3325 def __init__(self, channel, client): 3326 self.parent = client 3327 self.stub = GroupsRolesHistoryStub(channel) 3328 3329 def list(self, filter, *args, timeout=None): 3330 ''' 3331 List gets a list of GroupRoleHistory records matching a given set of criteria. 3332 ''' 3333 deadline = None if timeout is None else time.time() + timeout 3334 req = GroupRoleHistoryListRequest() 3335 req.meta.CopyFrom(ListRequestMetadata()) 3336 if self.parent.page_limit > 0: 3337 req.meta.limit = self.parent.page_limit 3338 if self.parent.snapshot_datetime is not None: 3339 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3340 3341 req.filter = plumbing.quote_filter_args(filter, *args) 3342 3343 def generator(svc, req): 3344 tries = 0 3345 while True: 3346 t = None if deadline is None else deadline - time.time() 3347 try: 3348 plumbing_response = svc.stub.List( 3349 req, 3350 metadata=svc.parent.get_metadata( 3351 'GroupsRolesHistory.List', req), 3352 timeout=t) 3353 except Exception as e: 3354 if self.parent.shouldRetry(tries, e, deadline): 3355 tries += 1 3356 time.sleep( 3357 self.parent.exponentialBackoff(tries, deadline)) 3358 continue 3359 raise plumbing.convert_error_to_porcelain(e) from e 3360 tries = 0 3361 for plumbing_item in plumbing_response.history: 3362 yield plumbing.convert_group_role_history_to_porcelain( 3363 plumbing_item) 3364 if plumbing_response.meta.next_cursor == '': 3365 break 3366 req.meta.cursor = plumbing_response.meta.next_cursor 3367 3368 return generator(self, req) 3369 3370 3371class HealthChecks: 3372 ''' 3373 HealthChecks lists the last healthcheck between each node and resource. 3374 Note the unconventional capitalization here is to prevent having a collision with GRPC 3375 See `strongdm.models.Healthcheck`. 3376 ''' 3377 def __init__(self, channel, client): 3378 self.parent = client 3379 self.stub = HealthChecksStub(channel) 3380 3381 def list(self, filter, *args, timeout=None): 3382 ''' 3383 List gets a list of Healthchecks matching a given set of criteria. 3384 ''' 3385 deadline = None if timeout is None else time.time() + timeout 3386 req = HealthcheckListRequest() 3387 req.meta.CopyFrom(ListRequestMetadata()) 3388 if self.parent.page_limit > 0: 3389 req.meta.limit = self.parent.page_limit 3390 if self.parent.snapshot_datetime is not None: 3391 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3392 3393 req.filter = plumbing.quote_filter_args(filter, *args) 3394 3395 def generator(svc, req): 3396 tries = 0 3397 while True: 3398 t = None if deadline is None else deadline - time.time() 3399 try: 3400 plumbing_response = svc.stub.List( 3401 req, 3402 metadata=svc.parent.get_metadata( 3403 'HealthChecks.List', req), 3404 timeout=t) 3405 except Exception as e: 3406 if self.parent.shouldRetry(tries, e, deadline): 3407 tries += 1 3408 time.sleep( 3409 self.parent.exponentialBackoff(tries, deadline)) 3410 continue 3411 raise plumbing.convert_error_to_porcelain(e) from e 3412 tries = 0 3413 for plumbing_item in plumbing_response.healthchecks: 3414 yield plumbing.convert_healthcheck_to_porcelain( 3415 plumbing_item) 3416 if plumbing_response.meta.next_cursor == '': 3417 break 3418 req.meta.cursor = plumbing_response.meta.next_cursor 3419 3420 return generator(self, req) 3421 3422 3423class IdentityAliases: 3424 ''' 3425 IdentityAliases assign an alias to an account within an IdentitySet. 3426 The alias is used as the username when connecting to a identity supported resource. 3427 See `strongdm.models.IdentityAlias`. 3428 ''' 3429 def __init__(self, channel, client): 3430 self.parent = client 3431 self.stub = IdentityAliasesStub(channel) 3432 3433 def create(self, identity_alias, timeout=None): 3434 ''' 3435 Create registers a new IdentityAlias. 3436 ''' 3437 deadline = None if timeout is None else time.time() + timeout 3438 req = IdentityAliasCreateRequest() 3439 3440 if identity_alias is not None: 3441 req.identity_alias.CopyFrom( 3442 plumbing.convert_identity_alias_to_plumbing(identity_alias)) 3443 tries = 0 3444 plumbing_response = None 3445 while True: 3446 t = None if deadline is None else deadline - time.time() 3447 try: 3448 plumbing_response = self.stub.Create( 3449 req, 3450 metadata=self.parent.get_metadata('IdentityAliases.Create', 3451 req), 3452 timeout=t) 3453 except Exception as e: 3454 if self.parent.shouldRetry(tries, e, deadline): 3455 tries += 1 3456 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3457 continue 3458 raise plumbing.convert_error_to_porcelain(e) from e 3459 break 3460 3461 resp = models.IdentityAliasCreateResponse() 3462 resp.identity_alias = plumbing.convert_identity_alias_to_porcelain( 3463 plumbing_response.identity_alias) 3464 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 3465 plumbing_response.meta) 3466 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3467 plumbing_response.rate_limit) 3468 return resp 3469 3470 def get(self, id, timeout=None): 3471 ''' 3472 Get reads one IdentityAlias by ID. 3473 ''' 3474 deadline = None if timeout is None else time.time() + timeout 3475 req = IdentityAliasGetRequest() 3476 if self.parent.snapshot_datetime is not None: 3477 req.meta.CopyFrom(GetRequestMetadata()) 3478 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3479 3480 req.id = (id) 3481 tries = 0 3482 plumbing_response = None 3483 while True: 3484 t = None if deadline is None else deadline - time.time() 3485 try: 3486 plumbing_response = self.stub.Get( 3487 req, 3488 metadata=self.parent.get_metadata('IdentityAliases.Get', 3489 req), 3490 timeout=t) 3491 except Exception as e: 3492 if self.parent.shouldRetry(tries, e, deadline): 3493 tries += 1 3494 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3495 continue 3496 raise plumbing.convert_error_to_porcelain(e) from e 3497 break 3498 3499 resp = models.IdentityAliasGetResponse() 3500 resp.identity_alias = plumbing.convert_identity_alias_to_porcelain( 3501 plumbing_response.identity_alias) 3502 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3503 plumbing_response.meta) 3504 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3505 plumbing_response.rate_limit) 3506 return resp 3507 3508 def update(self, identity_alias, timeout=None): 3509 ''' 3510 Update replaces all the fields of a IdentityAlias by ID. 3511 ''' 3512 deadline = None if timeout is None else time.time() + timeout 3513 req = IdentityAliasUpdateRequest() 3514 3515 if identity_alias is not None: 3516 req.identity_alias.CopyFrom( 3517 plumbing.convert_identity_alias_to_plumbing(identity_alias)) 3518 tries = 0 3519 plumbing_response = None 3520 while True: 3521 t = None if deadline is None else deadline - time.time() 3522 try: 3523 plumbing_response = self.stub.Update( 3524 req, 3525 metadata=self.parent.get_metadata('IdentityAliases.Update', 3526 req), 3527 timeout=t) 3528 except Exception as e: 3529 if self.parent.shouldRetry(tries, e, deadline): 3530 tries += 1 3531 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3532 continue 3533 raise plumbing.convert_error_to_porcelain(e) from e 3534 break 3535 3536 resp = models.IdentityAliasUpdateResponse() 3537 resp.identity_alias = plumbing.convert_identity_alias_to_porcelain( 3538 plumbing_response.identity_alias) 3539 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 3540 plumbing_response.meta) 3541 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3542 plumbing_response.rate_limit) 3543 return resp 3544 3545 def delete(self, id, timeout=None): 3546 ''' 3547 Delete removes a IdentityAlias by ID. 3548 ''' 3549 deadline = None if timeout is None else time.time() + timeout 3550 req = IdentityAliasDeleteRequest() 3551 3552 req.id = (id) 3553 tries = 0 3554 plumbing_response = None 3555 while True: 3556 t = None if deadline is None else deadline - time.time() 3557 try: 3558 plumbing_response = self.stub.Delete( 3559 req, 3560 metadata=self.parent.get_metadata('IdentityAliases.Delete', 3561 req), 3562 timeout=t) 3563 except Exception as e: 3564 if self.parent.shouldRetry(tries, e, deadline): 3565 tries += 1 3566 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3567 continue 3568 raise plumbing.convert_error_to_porcelain(e) from e 3569 break 3570 3571 resp = models.IdentityAliasDeleteResponse() 3572 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3573 plumbing_response.meta) 3574 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3575 plumbing_response.rate_limit) 3576 return resp 3577 3578 def list(self, filter, *args, timeout=None): 3579 ''' 3580 List gets a list of IdentityAliases matching a given set of criteria. 3581 ''' 3582 deadline = None if timeout is None else time.time() + timeout 3583 req = IdentityAliasListRequest() 3584 req.meta.CopyFrom(ListRequestMetadata()) 3585 if self.parent.page_limit > 0: 3586 req.meta.limit = self.parent.page_limit 3587 if self.parent.snapshot_datetime is not None: 3588 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3589 3590 req.filter = plumbing.quote_filter_args(filter, *args) 3591 3592 def generator(svc, req): 3593 tries = 0 3594 while True: 3595 t = None if deadline is None else deadline - time.time() 3596 try: 3597 plumbing_response = svc.stub.List( 3598 req, 3599 metadata=svc.parent.get_metadata( 3600 'IdentityAliases.List', req), 3601 timeout=t) 3602 except Exception as e: 3603 if self.parent.shouldRetry(tries, e, deadline): 3604 tries += 1 3605 time.sleep( 3606 self.parent.exponentialBackoff(tries, deadline)) 3607 continue 3608 raise plumbing.convert_error_to_porcelain(e) from e 3609 tries = 0 3610 for plumbing_item in plumbing_response.identity_aliases: 3611 yield plumbing.convert_identity_alias_to_porcelain( 3612 plumbing_item) 3613 if plumbing_response.meta.next_cursor == '': 3614 break 3615 req.meta.cursor = plumbing_response.meta.next_cursor 3616 3617 return generator(self, req) 3618 3619 3620class SnapshotIdentityAliases: 3621 ''' 3622 SnapshotIdentityAliases exposes the read only methods of the IdentityAliases 3623 service for historical queries. 3624 ''' 3625 def __init__(self, identity_aliases): 3626 self.identity_aliases = identity_aliases 3627 3628 def get(self, id, timeout=None): 3629 ''' 3630 Get reads one IdentityAlias by ID. 3631 ''' 3632 return self.identity_aliases.get(id, timeout=timeout) 3633 3634 def list(self, filter, *args, timeout=None): 3635 ''' 3636 List gets a list of IdentityAliases matching a given set of criteria. 3637 ''' 3638 return self.identity_aliases.list(filter, *args, timeout=timeout) 3639 3640 3641class IdentityAliasesHistory: 3642 ''' 3643 IdentityAliasesHistory records all changes to the state of a IdentityAlias. 3644 See `strongdm.models.IdentityAliasHistory`. 3645 ''' 3646 def __init__(self, channel, client): 3647 self.parent = client 3648 self.stub = IdentityAliasesHistoryStub(channel) 3649 3650 def list(self, filter, *args, timeout=None): 3651 ''' 3652 List gets a list of IdentityAliasHistory records matching a given set of criteria. 3653 ''' 3654 deadline = None if timeout is None else time.time() + timeout 3655 req = IdentityAliasHistoryListRequest() 3656 req.meta.CopyFrom(ListRequestMetadata()) 3657 if self.parent.page_limit > 0: 3658 req.meta.limit = self.parent.page_limit 3659 if self.parent.snapshot_datetime is not None: 3660 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3661 3662 req.filter = plumbing.quote_filter_args(filter, *args) 3663 3664 def generator(svc, req): 3665 tries = 0 3666 while True: 3667 t = None if deadline is None else deadline - time.time() 3668 try: 3669 plumbing_response = svc.stub.List( 3670 req, 3671 metadata=svc.parent.get_metadata( 3672 'IdentityAliasesHistory.List', req), 3673 timeout=t) 3674 except Exception as e: 3675 if self.parent.shouldRetry(tries, e, deadline): 3676 tries += 1 3677 time.sleep( 3678 self.parent.exponentialBackoff(tries, deadline)) 3679 continue 3680 raise plumbing.convert_error_to_porcelain(e) from e 3681 tries = 0 3682 for plumbing_item in plumbing_response.history: 3683 yield plumbing.convert_identity_alias_history_to_porcelain( 3684 plumbing_item) 3685 if plumbing_response.meta.next_cursor == '': 3686 break 3687 req.meta.cursor = plumbing_response.meta.next_cursor 3688 3689 return generator(self, req) 3690 3691 3692class IdentitySets: 3693 ''' 3694 A IdentitySet is a named grouping of Identity Aliases for Accounts. 3695 An Account's relationship to a IdentitySet is defined via IdentityAlias objects. 3696 See `strongdm.models.IdentitySet`. 3697 ''' 3698 def __init__(self, channel, client): 3699 self.parent = client 3700 self.stub = IdentitySetsStub(channel) 3701 3702 def create(self, identity_set, timeout=None): 3703 ''' 3704 Create registers a new IdentitySet. 3705 ''' 3706 deadline = None if timeout is None else time.time() + timeout 3707 req = IdentitySetCreateRequest() 3708 3709 if identity_set is not None: 3710 req.identity_set.CopyFrom( 3711 plumbing.convert_identity_set_to_plumbing(identity_set)) 3712 tries = 0 3713 plumbing_response = None 3714 while True: 3715 t = None if deadline is None else deadline - time.time() 3716 try: 3717 plumbing_response = self.stub.Create( 3718 req, 3719 metadata=self.parent.get_metadata('IdentitySets.Create', 3720 req), 3721 timeout=t) 3722 except Exception as e: 3723 if self.parent.shouldRetry(tries, e, deadline): 3724 tries += 1 3725 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3726 continue 3727 raise plumbing.convert_error_to_porcelain(e) from e 3728 break 3729 3730 resp = models.IdentitySetCreateResponse() 3731 resp.identity_set = plumbing.convert_identity_set_to_porcelain( 3732 plumbing_response.identity_set) 3733 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 3734 plumbing_response.meta) 3735 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3736 plumbing_response.rate_limit) 3737 return resp 3738 3739 def get(self, id, timeout=None): 3740 ''' 3741 Get reads one IdentitySet by ID. 3742 ''' 3743 deadline = None if timeout is None else time.time() + timeout 3744 req = IdentitySetGetRequest() 3745 if self.parent.snapshot_datetime is not None: 3746 req.meta.CopyFrom(GetRequestMetadata()) 3747 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3748 3749 req.id = (id) 3750 tries = 0 3751 plumbing_response = None 3752 while True: 3753 t = None if deadline is None else deadline - time.time() 3754 try: 3755 plumbing_response = self.stub.Get( 3756 req, 3757 metadata=self.parent.get_metadata('IdentitySets.Get', req), 3758 timeout=t) 3759 except Exception as e: 3760 if self.parent.shouldRetry(tries, e, deadline): 3761 tries += 1 3762 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3763 continue 3764 raise plumbing.convert_error_to_porcelain(e) from e 3765 break 3766 3767 resp = models.IdentitySetGetResponse() 3768 resp.identity_set = plumbing.convert_identity_set_to_porcelain( 3769 plumbing_response.identity_set) 3770 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3771 plumbing_response.meta) 3772 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3773 plumbing_response.rate_limit) 3774 return resp 3775 3776 def update(self, identity_set, timeout=None): 3777 ''' 3778 Update replaces all the fields of a IdentitySet by ID. 3779 ''' 3780 deadline = None if timeout is None else time.time() + timeout 3781 req = IdentitySetUpdateRequest() 3782 3783 if identity_set is not None: 3784 req.identity_set.CopyFrom( 3785 plumbing.convert_identity_set_to_plumbing(identity_set)) 3786 tries = 0 3787 plumbing_response = None 3788 while True: 3789 t = None if deadline is None else deadline - time.time() 3790 try: 3791 plumbing_response = self.stub.Update( 3792 req, 3793 metadata=self.parent.get_metadata('IdentitySets.Update', 3794 req), 3795 timeout=t) 3796 except Exception as e: 3797 if self.parent.shouldRetry(tries, e, deadline): 3798 tries += 1 3799 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3800 continue 3801 raise plumbing.convert_error_to_porcelain(e) from e 3802 break 3803 3804 resp = models.IdentitySetUpdateResponse() 3805 resp.identity_set = plumbing.convert_identity_set_to_porcelain( 3806 plumbing_response.identity_set) 3807 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 3808 plumbing_response.meta) 3809 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3810 plumbing_response.rate_limit) 3811 return resp 3812 3813 def delete(self, id, timeout=None): 3814 ''' 3815 Delete removes a IdentitySet by ID. 3816 ''' 3817 deadline = None if timeout is None else time.time() + timeout 3818 req = IdentitySetDeleteRequest() 3819 3820 req.id = (id) 3821 tries = 0 3822 plumbing_response = None 3823 while True: 3824 t = None if deadline is None else deadline - time.time() 3825 try: 3826 plumbing_response = self.stub.Delete( 3827 req, 3828 metadata=self.parent.get_metadata('IdentitySets.Delete', 3829 req), 3830 timeout=t) 3831 except Exception as e: 3832 if self.parent.shouldRetry(tries, e, deadline): 3833 tries += 1 3834 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3835 continue 3836 raise plumbing.convert_error_to_porcelain(e) from e 3837 break 3838 3839 resp = models.IdentitySetDeleteResponse() 3840 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3841 plumbing_response.meta) 3842 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3843 plumbing_response.rate_limit) 3844 return resp 3845 3846 def list(self, filter, *args, timeout=None): 3847 ''' 3848 List gets a list of IdentitySets matching a given set of criteria. 3849 ''' 3850 deadline = None if timeout is None else time.time() + timeout 3851 req = IdentitySetListRequest() 3852 req.meta.CopyFrom(ListRequestMetadata()) 3853 if self.parent.page_limit > 0: 3854 req.meta.limit = self.parent.page_limit 3855 if self.parent.snapshot_datetime is not None: 3856 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3857 3858 req.filter = plumbing.quote_filter_args(filter, *args) 3859 3860 def generator(svc, req): 3861 tries = 0 3862 while True: 3863 t = None if deadline is None else deadline - time.time() 3864 try: 3865 plumbing_response = svc.stub.List( 3866 req, 3867 metadata=svc.parent.get_metadata( 3868 'IdentitySets.List', req), 3869 timeout=t) 3870 except Exception as e: 3871 if self.parent.shouldRetry(tries, e, deadline): 3872 tries += 1 3873 time.sleep( 3874 self.parent.exponentialBackoff(tries, deadline)) 3875 continue 3876 raise plumbing.convert_error_to_porcelain(e) from e 3877 tries = 0 3878 for plumbing_item in plumbing_response.identity_sets: 3879 yield plumbing.convert_identity_set_to_porcelain( 3880 plumbing_item) 3881 if plumbing_response.meta.next_cursor == '': 3882 break 3883 req.meta.cursor = plumbing_response.meta.next_cursor 3884 3885 return generator(self, req) 3886 3887 3888class SnapshotIdentitySets: 3889 ''' 3890 SnapshotIdentitySets exposes the read only methods of the IdentitySets 3891 service for historical queries. 3892 ''' 3893 def __init__(self, identity_sets): 3894 self.identity_sets = identity_sets 3895 3896 def get(self, id, timeout=None): 3897 ''' 3898 Get reads one IdentitySet by ID. 3899 ''' 3900 return self.identity_sets.get(id, timeout=timeout) 3901 3902 def list(self, filter, *args, timeout=None): 3903 ''' 3904 List gets a list of IdentitySets matching a given set of criteria. 3905 ''' 3906 return self.identity_sets.list(filter, *args, timeout=timeout) 3907 3908 3909class IdentitySetsHistory: 3910 ''' 3911 IdentitySetsHistory records all changes to the state of a IdentitySet. 3912 See `strongdm.models.IdentitySetHistory`. 3913 ''' 3914 def __init__(self, channel, client): 3915 self.parent = client 3916 self.stub = IdentitySetsHistoryStub(channel) 3917 3918 def list(self, filter, *args, timeout=None): 3919 ''' 3920 List gets a list of IdentitySetHistory records matching a given set of criteria. 3921 ''' 3922 deadline = None if timeout is None else time.time() + timeout 3923 req = IdentitySetHistoryListRequest() 3924 req.meta.CopyFrom(ListRequestMetadata()) 3925 if self.parent.page_limit > 0: 3926 req.meta.limit = self.parent.page_limit 3927 if self.parent.snapshot_datetime is not None: 3928 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3929 3930 req.filter = plumbing.quote_filter_args(filter, *args) 3931 3932 def generator(svc, req): 3933 tries = 0 3934 while True: 3935 t = None if deadline is None else deadline - time.time() 3936 try: 3937 plumbing_response = svc.stub.List( 3938 req, 3939 metadata=svc.parent.get_metadata( 3940 'IdentitySetsHistory.List', req), 3941 timeout=t) 3942 except Exception as e: 3943 if self.parent.shouldRetry(tries, e, deadline): 3944 tries += 1 3945 time.sleep( 3946 self.parent.exponentialBackoff(tries, deadline)) 3947 continue 3948 raise plumbing.convert_error_to_porcelain(e) from e 3949 tries = 0 3950 for plumbing_item in plumbing_response.history: 3951 yield plumbing.convert_identity_set_history_to_porcelain( 3952 plumbing_item) 3953 if plumbing_response.meta.next_cursor == '': 3954 break 3955 req.meta.cursor = plumbing_response.meta.next_cursor 3956 3957 return generator(self, req) 3958 3959 3960class ManagedSecrets: 3961 ''' 3962 ManagedSecret is a private vertical for creating, reading, updating, 3963 deleting, listing and rotating the managed secrets in the secrets engines as 3964 an authenticated user. 3965 See `strongdm.models.ManagedSecret`. 3966 ''' 3967 def __init__(self, channel, client): 3968 self.parent = client 3969 self.stub = ManagedSecretsStub(channel) 3970 3971 def list(self, filter, *args, timeout=None): 3972 ''' 3973 List returns Managed Secrets from a Secret Engine. 3974 ''' 3975 deadline = None if timeout is None else time.time() + timeout 3976 req = ManagedSecretListRequest() 3977 req.meta.CopyFrom(ListRequestMetadata()) 3978 if self.parent.page_limit > 0: 3979 req.meta.limit = self.parent.page_limit 3980 if self.parent.snapshot_datetime is not None: 3981 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3982 3983 req.filter = plumbing.quote_filter_args(filter, *args) 3984 3985 def generator(svc, req): 3986 tries = 0 3987 while True: 3988 t = None if deadline is None else deadline - time.time() 3989 try: 3990 plumbing_response = svc.stub.List( 3991 req, 3992 metadata=svc.parent.get_metadata( 3993 'ManagedSecrets.List', req), 3994 timeout=t) 3995 except Exception as e: 3996 if self.parent.shouldRetry(tries, e, deadline): 3997 tries += 1 3998 time.sleep( 3999 self.parent.exponentialBackoff(tries, deadline)) 4000 continue 4001 raise plumbing.convert_error_to_porcelain(e) from e 4002 tries = 0 4003 for plumbing_item in plumbing_response.managed_secrets: 4004 yield plumbing.convert_managed_secret_to_porcelain( 4005 plumbing_item) 4006 if plumbing_response.meta.next_cursor == '': 4007 break 4008 req.meta.cursor = plumbing_response.meta.next_cursor 4009 4010 return generator(self, req) 4011 4012 def list_by_actor(self, filter, *args, timeout=None): 4013 ''' 4014 List returns Managed Secrets for an Actor from a Secret Engine. 4015 ''' 4016 deadline = None if timeout is None else time.time() + timeout 4017 req = ManagedSecretListRequest() 4018 req.meta.CopyFrom(ListRequestMetadata()) 4019 if self.parent.page_limit > 0: 4020 req.meta.limit = self.parent.page_limit 4021 if self.parent.snapshot_datetime is not None: 4022 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4023 4024 req.filter = plumbing.quote_filter_args(filter, *args) 4025 4026 def generator(svc, req): 4027 tries = 0 4028 while True: 4029 t = None if deadline is None else deadline - time.time() 4030 try: 4031 plumbing_response = svc.stub.ListByActor( 4032 req, 4033 metadata=svc.parent.get_metadata( 4034 'ManagedSecrets.ListByActor', req), 4035 timeout=t) 4036 except Exception as e: 4037 if self.parent.shouldRetry(tries, e, deadline): 4038 tries += 1 4039 time.sleep( 4040 self.parent.exponentialBackoff(tries, deadline)) 4041 continue 4042 raise plumbing.convert_error_to_porcelain(e) from e 4043 tries = 0 4044 for plumbing_item in plumbing_response.managed_secrets: 4045 yield plumbing.convert_managed_secret_to_porcelain( 4046 plumbing_item) 4047 if plumbing_response.meta.next_cursor == '': 4048 break 4049 req.meta.cursor = plumbing_response.meta.next_cursor 4050 4051 return generator(self, req) 4052 4053 def create(self, managed_secret, timeout=None): 4054 ''' 4055 Create creates a Managed Secret 4056 ''' 4057 deadline = None if timeout is None else time.time() + timeout 4058 req = ManagedSecretCreateRequest() 4059 4060 if managed_secret is not None: 4061 req.managed_secret.CopyFrom( 4062 plumbing.convert_managed_secret_to_plumbing(managed_secret)) 4063 tries = 0 4064 plumbing_response = None 4065 while True: 4066 t = None if deadline is None else deadline - time.time() 4067 try: 4068 plumbing_response = self.stub.Create( 4069 req, 4070 metadata=self.parent.get_metadata('ManagedSecrets.Create', 4071 req), 4072 timeout=t) 4073 except Exception as e: 4074 if self.parent.shouldRetry(tries, e, deadline): 4075 tries += 1 4076 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4077 continue 4078 raise plumbing.convert_error_to_porcelain(e) from e 4079 break 4080 4081 resp = models.ManagedSecretCreateResponse() 4082 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 4083 plumbing_response.managed_secret) 4084 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4085 plumbing_response.meta) 4086 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4087 plumbing_response.rate_limit) 4088 return resp 4089 4090 def update(self, managed_secret, timeout=None): 4091 ''' 4092 Update updates a Managed Secret 4093 ''' 4094 deadline = None if timeout is None else time.time() + timeout 4095 req = ManagedSecretUpdateRequest() 4096 4097 if managed_secret is not None: 4098 req.managed_secret.CopyFrom( 4099 plumbing.convert_managed_secret_to_plumbing(managed_secret)) 4100 tries = 0 4101 plumbing_response = None 4102 while True: 4103 t = None if deadline is None else deadline - time.time() 4104 try: 4105 plumbing_response = self.stub.Update( 4106 req, 4107 metadata=self.parent.get_metadata('ManagedSecrets.Update', 4108 req), 4109 timeout=t) 4110 except Exception as e: 4111 if self.parent.shouldRetry(tries, e, deadline): 4112 tries += 1 4113 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4114 continue 4115 raise plumbing.convert_error_to_porcelain(e) from e 4116 break 4117 4118 resp = models.ManagedSecretUpdateResponse() 4119 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 4120 plumbing_response.managed_secret) 4121 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 4122 plumbing_response.meta) 4123 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4124 plumbing_response.rate_limit) 4125 return resp 4126 4127 def rotate(self, id, timeout=None): 4128 ''' 4129 Rotate forces rotation of Managed Secret 4130 ''' 4131 deadline = None if timeout is None else time.time() + timeout 4132 req = ManagedSecretRotateRequest() 4133 4134 req.id = (id) 4135 tries = 0 4136 plumbing_response = None 4137 while True: 4138 t = None if deadline is None else deadline - time.time() 4139 try: 4140 plumbing_response = self.stub.Rotate( 4141 req, 4142 metadata=self.parent.get_metadata('ManagedSecrets.Rotate', 4143 req), 4144 timeout=t) 4145 except Exception as e: 4146 if self.parent.shouldRetry(tries, e, deadline): 4147 tries += 1 4148 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4149 continue 4150 raise plumbing.convert_error_to_porcelain(e) from e 4151 break 4152 4153 resp = models.ManagedSecretRotateResponse() 4154 resp.meta = plumbing.convert_generic_response_metadata_to_porcelain( 4155 plumbing_response.meta) 4156 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4157 plumbing_response.rate_limit) 4158 return resp 4159 4160 def delete(self, id, timeout=None): 4161 ''' 4162 Delete deletes a Managed Secret 4163 ''' 4164 deadline = None if timeout is None else time.time() + timeout 4165 req = ManagedSecretDeleteRequest() 4166 4167 req.id = (id) 4168 tries = 0 4169 plumbing_response = None 4170 while True: 4171 t = None if deadline is None else deadline - time.time() 4172 try: 4173 plumbing_response = self.stub.Delete( 4174 req, 4175 metadata=self.parent.get_metadata('ManagedSecrets.Delete', 4176 req), 4177 timeout=t) 4178 except Exception as e: 4179 if self.parent.shouldRetry(tries, e, deadline): 4180 tries += 1 4181 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4182 continue 4183 raise plumbing.convert_error_to_porcelain(e) from e 4184 break 4185 4186 resp = models.ManagedSecretDeleteResponse() 4187 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4188 plumbing_response.rate_limit) 4189 return resp 4190 4191 def force_delete(self, id, timeout=None): 4192 ''' 4193 ForceDelete deletes a Managed Secret regardless of errors on external system 4194 ''' 4195 deadline = None if timeout is None else time.time() + timeout 4196 req = ManagedSecretDeleteRequest() 4197 4198 req.id = (id) 4199 tries = 0 4200 plumbing_response = None 4201 while True: 4202 t = None if deadline is None else deadline - time.time() 4203 try: 4204 plumbing_response = self.stub.ForceDelete( 4205 req, 4206 metadata=self.parent.get_metadata( 4207 'ManagedSecrets.ForceDelete', req), 4208 timeout=t) 4209 except Exception as e: 4210 if self.parent.shouldRetry(tries, e, deadline): 4211 tries += 1 4212 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4213 continue 4214 raise plumbing.convert_error_to_porcelain(e) from e 4215 break 4216 4217 resp = models.ManagedSecretDeleteResponse() 4218 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4219 plumbing_response.rate_limit) 4220 return resp 4221 4222 def get(self, id, timeout=None): 4223 ''' 4224 Get gets details of a Managed Secret without sensitive data 4225 ''' 4226 deadline = None if timeout is None else time.time() + timeout 4227 req = ManagedSecretGetRequest() 4228 if self.parent.snapshot_datetime is not None: 4229 req.meta.CopyFrom(GetRequestMetadata()) 4230 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4231 4232 req.id = (id) 4233 tries = 0 4234 plumbing_response = None 4235 while True: 4236 t = None if deadline is None else deadline - time.time() 4237 try: 4238 plumbing_response = self.stub.Get( 4239 req, 4240 metadata=self.parent.get_metadata('ManagedSecrets.Get', 4241 req), 4242 timeout=t) 4243 except Exception as e: 4244 if self.parent.shouldRetry(tries, e, deadline): 4245 tries += 1 4246 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4247 continue 4248 raise plumbing.convert_error_to_porcelain(e) from e 4249 break 4250 4251 resp = models.ManagedSecretGetResponse() 4252 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 4253 plumbing_response.managed_secret) 4254 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4255 plumbing_response.meta) 4256 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4257 plumbing_response.rate_limit) 4258 return resp 4259 4260 def retrieve(self, id, timeout=None): 4261 ''' 4262 Retrieve returns Managed Secret with sensitive data 4263 ''' 4264 deadline = None if timeout is None else time.time() + timeout 4265 req = ManagedSecretRetrieveRequest() 4266 4267 req.id = (id) 4268 tries = 0 4269 plumbing_response = None 4270 while True: 4271 t = None if deadline is None else deadline - time.time() 4272 try: 4273 plumbing_response = self.stub.Retrieve( 4274 req, 4275 metadata=self.parent.get_metadata( 4276 'ManagedSecrets.Retrieve', req), 4277 timeout=t) 4278 except Exception as e: 4279 if self.parent.shouldRetry(tries, e, deadline): 4280 tries += 1 4281 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4282 continue 4283 raise plumbing.convert_error_to_porcelain(e) from e 4284 break 4285 4286 resp = models.ManagedSecretRetrieveResponse() 4287 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 4288 plumbing_response.managed_secret) 4289 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4290 plumbing_response.meta) 4291 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4292 plumbing_response.rate_limit) 4293 return resp 4294 4295 def validate(self, id, timeout=None): 4296 ''' 4297 Validate returns the result of testing the stored credential against the 4298 secret engine. 4299 ''' 4300 deadline = None if timeout is None else time.time() + timeout 4301 req = ManagedSecretValidateRequest() 4302 4303 req.id = (id) 4304 tries = 0 4305 plumbing_response = None 4306 while True: 4307 t = None if deadline is None else deadline - time.time() 4308 try: 4309 plumbing_response = self.stub.Validate( 4310 req, 4311 metadata=self.parent.get_metadata( 4312 'ManagedSecrets.Validate', req), 4313 timeout=t) 4314 except Exception as e: 4315 if self.parent.shouldRetry(tries, e, deadline): 4316 tries += 1 4317 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4318 continue 4319 raise plumbing.convert_error_to_porcelain(e) from e 4320 break 4321 4322 resp = models.ManagedSecretValidateResponse() 4323 resp.invalid_info = (plumbing_response.invalid_info) 4324 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4325 plumbing_response.meta) 4326 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4327 plumbing_response.rate_limit) 4328 resp.valid = (plumbing_response.valid) 4329 return resp 4330 4331 def logs(self, filter, *args, timeout=None): 4332 ''' 4333 Logs returns the audit records for the managed secret. This may be replaced 4334 in the future. 4335 ''' 4336 deadline = None if timeout is None else time.time() + timeout 4337 req = ManagedSecretLogsRequest() 4338 req.meta.CopyFrom(ListRequestMetadata()) 4339 if self.parent.page_limit > 0: 4340 req.meta.limit = self.parent.page_limit 4341 if self.parent.snapshot_datetime is not None: 4342 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4343 4344 req.filter = plumbing.quote_filter_args(filter, *args) 4345 4346 def generator(svc, req): 4347 tries = 0 4348 while True: 4349 t = None if deadline is None else deadline - time.time() 4350 try: 4351 plumbing_response = svc.stub.Logs( 4352 req, 4353 metadata=svc.parent.get_metadata( 4354 'ManagedSecrets.Logs', req), 4355 timeout=t) 4356 except Exception as e: 4357 if self.parent.shouldRetry(tries, e, deadline): 4358 tries += 1 4359 time.sleep( 4360 self.parent.exponentialBackoff(tries, deadline)) 4361 continue 4362 raise plumbing.convert_error_to_porcelain(e) from e 4363 tries = 0 4364 for plumbing_item in plumbing_response.managed_secret_logs: 4365 yield plumbing.convert_managed_secret_log_to_porcelain( 4366 plumbing_item) 4367 if plumbing_response.meta.next_cursor == '': 4368 break 4369 req.meta.cursor = plumbing_response.meta.next_cursor 4370 4371 return generator(self, req) 4372 4373 4374class Nodes: 4375 ''' 4376 Nodes make up the StrongDM network, and allow your users to connect securely to your resources. 4377 There are three types of nodes: 4378 1. **Relay:** creates connectivity to your datasources, while maintaining the egress-only nature of your firewall 4379 2. **Gateway:** a relay that also listens for connections from StrongDM clients 4380 3. **Proxy Cluster:** a cluster of workers that together mediate access from clients to resources 4381 See: 4382 `strongdm.models.Gateway` 4383 `strongdm.models.ProxyCluster` 4384 `strongdm.models.Relay` 4385 ''' 4386 def __init__(self, channel, client): 4387 self.parent = client 4388 self.stub = NodesStub(channel) 4389 4390 def create(self, node, timeout=None): 4391 ''' 4392 Create registers a new Node. 4393 ''' 4394 deadline = None if timeout is None else time.time() + timeout 4395 req = NodeCreateRequest() 4396 4397 if node is not None: 4398 req.node.CopyFrom(plumbing.convert_node_to_plumbing(node)) 4399 tries = 0 4400 plumbing_response = None 4401 while True: 4402 t = None if deadline is None else deadline - time.time() 4403 try: 4404 plumbing_response = self.stub.Create( 4405 req, 4406 metadata=self.parent.get_metadata('Nodes.Create', req), 4407 timeout=t) 4408 except Exception as e: 4409 if self.parent.shouldRetry(tries, e, deadline): 4410 tries += 1 4411 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4412 continue 4413 raise plumbing.convert_error_to_porcelain(e) from e 4414 break 4415 4416 resp = models.NodeCreateResponse() 4417 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4418 plumbing_response.meta) 4419 resp.node = plumbing.convert_node_to_porcelain(plumbing_response.node) 4420 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4421 plumbing_response.rate_limit) 4422 resp.token = (plumbing_response.token) 4423 return resp 4424 4425 def get(self, id, timeout=None): 4426 ''' 4427 Get reads one Node by ID. 4428 ''' 4429 deadline = None if timeout is None else time.time() + timeout 4430 req = NodeGetRequest() 4431 if self.parent.snapshot_datetime is not None: 4432 req.meta.CopyFrom(GetRequestMetadata()) 4433 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4434 4435 req.id = (id) 4436 tries = 0 4437 plumbing_response = None 4438 while True: 4439 t = None if deadline is None else deadline - time.time() 4440 try: 4441 plumbing_response = self.stub.Get( 4442 req, 4443 metadata=self.parent.get_metadata('Nodes.Get', req), 4444 timeout=t) 4445 except Exception as e: 4446 if self.parent.shouldRetry(tries, e, deadline): 4447 tries += 1 4448 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4449 continue 4450 raise plumbing.convert_error_to_porcelain(e) from e 4451 break 4452 4453 resp = models.NodeGetResponse() 4454 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4455 plumbing_response.meta) 4456 resp.node = plumbing.convert_node_to_porcelain(plumbing_response.node) 4457 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4458 plumbing_response.rate_limit) 4459 return resp 4460 4461 def update(self, node, timeout=None): 4462 ''' 4463 Update replaces all the fields of a Node by ID. 4464 ''' 4465 deadline = None if timeout is None else time.time() + timeout 4466 req = NodeUpdateRequest() 4467 4468 if node is not None: 4469 req.node.CopyFrom(plumbing.convert_node_to_plumbing(node)) 4470 tries = 0 4471 plumbing_response = None 4472 while True: 4473 t = None if deadline is None else deadline - time.time() 4474 try: 4475 plumbing_response = self.stub.Update( 4476 req, 4477 metadata=self.parent.get_metadata('Nodes.Update', req), 4478 timeout=t) 4479 except Exception as e: 4480 if self.parent.shouldRetry(tries, e, deadline): 4481 tries += 1 4482 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4483 continue 4484 raise plumbing.convert_error_to_porcelain(e) from e 4485 break 4486 4487 resp = models.NodeUpdateResponse() 4488 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 4489 plumbing_response.meta) 4490 resp.node = plumbing.convert_node_to_porcelain(plumbing_response.node) 4491 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4492 plumbing_response.rate_limit) 4493 return resp 4494 4495 def delete(self, id, timeout=None): 4496 ''' 4497 Delete removes a Node by ID. 4498 ''' 4499 deadline = None if timeout is None else time.time() + timeout 4500 req = NodeDeleteRequest() 4501 4502 req.id = (id) 4503 tries = 0 4504 plumbing_response = None 4505 while True: 4506 t = None if deadline is None else deadline - time.time() 4507 try: 4508 plumbing_response = self.stub.Delete( 4509 req, 4510 metadata=self.parent.get_metadata('Nodes.Delete', req), 4511 timeout=t) 4512 except Exception as e: 4513 if self.parent.shouldRetry(tries, e, deadline): 4514 tries += 1 4515 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4516 continue 4517 raise plumbing.convert_error_to_porcelain(e) from e 4518 break 4519 4520 resp = models.NodeDeleteResponse() 4521 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 4522 plumbing_response.meta) 4523 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4524 plumbing_response.rate_limit) 4525 return resp 4526 4527 def list(self, filter, *args, timeout=None): 4528 ''' 4529 List gets a list of Nodes matching a given set of criteria. 4530 ''' 4531 deadline = None if timeout is None else time.time() + timeout 4532 req = NodeListRequest() 4533 req.meta.CopyFrom(ListRequestMetadata()) 4534 if self.parent.page_limit > 0: 4535 req.meta.limit = self.parent.page_limit 4536 if self.parent.snapshot_datetime is not None: 4537 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4538 4539 req.filter = plumbing.quote_filter_args(filter, *args) 4540 4541 def generator(svc, req): 4542 tries = 0 4543 while True: 4544 t = None if deadline is None else deadline - time.time() 4545 try: 4546 plumbing_response = svc.stub.List( 4547 req, 4548 metadata=svc.parent.get_metadata('Nodes.List', req), 4549 timeout=t) 4550 except Exception as e: 4551 if self.parent.shouldRetry(tries, e, deadline): 4552 tries += 1 4553 time.sleep( 4554 self.parent.exponentialBackoff(tries, deadline)) 4555 continue 4556 raise plumbing.convert_error_to_porcelain(e) from e 4557 tries = 0 4558 for plumbing_item in plumbing_response.nodes: 4559 yield plumbing.convert_node_to_porcelain(plumbing_item) 4560 if plumbing_response.meta.next_cursor == '': 4561 break 4562 req.meta.cursor = plumbing_response.meta.next_cursor 4563 4564 return generator(self, req) 4565 4566 def tcp_probe(self, node_id, host, port, timeout=None): 4567 ''' 4568 TCPProbe instructs a Node to connect to an address via TCP and report the 4569 result. 4570 ''' 4571 deadline = None if timeout is None else time.time() + timeout 4572 req = NodeTCPProbeRequest() 4573 4574 req.node_id = (node_id) 4575 req.host = (host) 4576 req.port = (port) 4577 tries = 0 4578 plumbing_response = None 4579 while True: 4580 t = None if deadline is None else deadline - time.time() 4581 try: 4582 plumbing_response = self.stub.TCPProbe( 4583 req, 4584 metadata=self.parent.get_metadata('Nodes.TCPProbe', req), 4585 timeout=t) 4586 except Exception as e: 4587 if self.parent.shouldRetry(tries, e, deadline): 4588 tries += 1 4589 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4590 continue 4591 raise plumbing.convert_error_to_porcelain(e) from e 4592 break 4593 4594 resp = models.NodeTCPProbeResponse() 4595 resp.error = (plumbing_response.error) 4596 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4597 plumbing_response.meta) 4598 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4599 plumbing_response.rate_limit) 4600 resp.succeeded = (plumbing_response.succeeded) 4601 return resp 4602 4603 4604class SnapshotNodes: 4605 ''' 4606 SnapshotNodes exposes the read only methods of the Nodes 4607 service for historical queries. 4608 ''' 4609 def __init__(self, nodes): 4610 self.nodes = nodes 4611 4612 def get(self, id, timeout=None): 4613 ''' 4614 Get reads one Node by ID. 4615 ''' 4616 return self.nodes.get(id, timeout=timeout) 4617 4618 def list(self, filter, *args, timeout=None): 4619 ''' 4620 List gets a list of Nodes matching a given set of criteria. 4621 ''' 4622 return self.nodes.list(filter, *args, timeout=timeout) 4623 4624 4625class NodesHistory: 4626 ''' 4627 NodesHistory records all changes to the state of a Node. 4628 See `strongdm.models.NodeHistory`. 4629 ''' 4630 def __init__(self, channel, client): 4631 self.parent = client 4632 self.stub = NodesHistoryStub(channel) 4633 4634 def list(self, filter, *args, timeout=None): 4635 ''' 4636 List gets a list of NodeHistory records matching a given set of criteria. 4637 ''' 4638 deadline = None if timeout is None else time.time() + timeout 4639 req = NodeHistoryListRequest() 4640 req.meta.CopyFrom(ListRequestMetadata()) 4641 if self.parent.page_limit > 0: 4642 req.meta.limit = self.parent.page_limit 4643 if self.parent.snapshot_datetime is not None: 4644 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4645 4646 req.filter = plumbing.quote_filter_args(filter, *args) 4647 4648 def generator(svc, req): 4649 tries = 0 4650 while True: 4651 t = None if deadline is None else deadline - time.time() 4652 try: 4653 plumbing_response = svc.stub.List( 4654 req, 4655 metadata=svc.parent.get_metadata( 4656 'NodesHistory.List', req), 4657 timeout=t) 4658 except Exception as e: 4659 if self.parent.shouldRetry(tries, e, deadline): 4660 tries += 1 4661 time.sleep( 4662 self.parent.exponentialBackoff(tries, deadline)) 4663 continue 4664 raise plumbing.convert_error_to_porcelain(e) from e 4665 tries = 0 4666 for plumbing_item in plumbing_response.history: 4667 yield plumbing.convert_node_history_to_porcelain( 4668 plumbing_item) 4669 if plumbing_response.meta.next_cursor == '': 4670 break 4671 req.meta.cursor = plumbing_response.meta.next_cursor 4672 4673 return generator(self, req) 4674 4675 4676class OrganizationHistory: 4677 ''' 4678 OrganizationHistory records all changes to the state of an Organization. 4679 See `strongdm.models.OrganizationHistoryRecord`. 4680 ''' 4681 def __init__(self, channel, client): 4682 self.parent = client 4683 self.stub = OrganizationHistoryStub(channel) 4684 4685 def list(self, filter, *args, timeout=None): 4686 ''' 4687 List gets a list of OrganizationHistory records matching a given set of criteria. 4688 ''' 4689 deadline = None if timeout is None else time.time() + timeout 4690 req = OrganizationHistoryListRequest() 4691 req.meta.CopyFrom(ListRequestMetadata()) 4692 if self.parent.page_limit > 0: 4693 req.meta.limit = self.parent.page_limit 4694 if self.parent.snapshot_datetime is not None: 4695 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4696 4697 req.filter = plumbing.quote_filter_args(filter, *args) 4698 4699 def generator(svc, req): 4700 tries = 0 4701 while True: 4702 t = None if deadline is None else deadline - time.time() 4703 try: 4704 plumbing_response = svc.stub.List( 4705 req, 4706 metadata=svc.parent.get_metadata( 4707 'OrganizationHistory.List', req), 4708 timeout=t) 4709 except Exception as e: 4710 if self.parent.shouldRetry(tries, e, deadline): 4711 tries += 1 4712 time.sleep( 4713 self.parent.exponentialBackoff(tries, deadline)) 4714 continue 4715 raise plumbing.convert_error_to_porcelain(e) from e 4716 tries = 0 4717 for plumbing_item in plumbing_response.history: 4718 yield plumbing.convert_organization_history_record_to_porcelain( 4719 plumbing_item) 4720 if plumbing_response.meta.next_cursor == '': 4721 break 4722 req.meta.cursor = plumbing_response.meta.next_cursor 4723 4724 return generator(self, req) 4725 4726 4727class PeeringGroupNodes: 4728 ''' 4729 PeeringGroupNodes provides the building blocks necessary to obtain attach a node to a peering group. 4730 See `strongdm.models.PeeringGroupNode`. 4731 ''' 4732 def __init__(self, channel, client): 4733 self.parent = client 4734 self.stub = PeeringGroupNodesStub(channel) 4735 4736 def create(self, peering_group_node, timeout=None): 4737 ''' 4738 Create attaches a Node to a PeeringGroup 4739 ''' 4740 deadline = None if timeout is None else time.time() + timeout 4741 req = PeeringGroupNodeCreateRequest() 4742 4743 if peering_group_node is not None: 4744 req.peering_group_node.CopyFrom( 4745 plumbing.convert_peering_group_node_to_plumbing( 4746 peering_group_node)) 4747 tries = 0 4748 plumbing_response = None 4749 while True: 4750 t = None if deadline is None else deadline - time.time() 4751 try: 4752 plumbing_response = self.stub.Create( 4753 req, 4754 metadata=self.parent.get_metadata( 4755 'PeeringGroupNodes.Create', req), 4756 timeout=t) 4757 except Exception as e: 4758 if self.parent.shouldRetry(tries, e, deadline): 4759 tries += 1 4760 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4761 continue 4762 raise plumbing.convert_error_to_porcelain(e) from e 4763 break 4764 4765 resp = models.PeeringGroupNodeCreateResponse() 4766 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4767 plumbing_response.meta) 4768 resp.peering_group_node = plumbing.convert_peering_group_node_to_porcelain( 4769 plumbing_response.peering_group_node) 4770 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4771 plumbing_response.rate_limit) 4772 return resp 4773 4774 def delete(self, id, timeout=None): 4775 ''' 4776 Delete detaches a Node to a PeeringGroup. 4777 ''' 4778 deadline = None if timeout is None else time.time() + timeout 4779 req = PeeringGroupNodeDeleteRequest() 4780 4781 req.id = (id) 4782 tries = 0 4783 plumbing_response = None 4784 while True: 4785 t = None if deadline is None else deadline - time.time() 4786 try: 4787 plumbing_response = self.stub.Delete( 4788 req, 4789 metadata=self.parent.get_metadata( 4790 'PeeringGroupNodes.Delete', req), 4791 timeout=t) 4792 except Exception as e: 4793 if self.parent.shouldRetry(tries, e, deadline): 4794 tries += 1 4795 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4796 continue 4797 raise plumbing.convert_error_to_porcelain(e) from e 4798 break 4799 4800 resp = models.PeeringGroupNodeDeleteResponse() 4801 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 4802 plumbing_response.meta) 4803 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4804 plumbing_response.rate_limit) 4805 return resp 4806 4807 def get(self, id, timeout=None): 4808 ''' 4809 Get reads the information of one peering group to node attachment. 4810 ''' 4811 deadline = None if timeout is None else time.time() + timeout 4812 req = PeeringGroupNodeGetRequest() 4813 if self.parent.snapshot_datetime is not None: 4814 req.meta.CopyFrom(GetRequestMetadata()) 4815 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4816 4817 req.id = (id) 4818 tries = 0 4819 plumbing_response = None 4820 while True: 4821 t = None if deadline is None else deadline - time.time() 4822 try: 4823 plumbing_response = self.stub.Get( 4824 req, 4825 metadata=self.parent.get_metadata('PeeringGroupNodes.Get', 4826 req), 4827 timeout=t) 4828 except Exception as e: 4829 if self.parent.shouldRetry(tries, e, deadline): 4830 tries += 1 4831 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4832 continue 4833 raise plumbing.convert_error_to_porcelain(e) from e 4834 break 4835 4836 resp = models.PeeringGroupNodeGetResponse() 4837 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4838 plumbing_response.meta) 4839 resp.peering_group_node = plumbing.convert_peering_group_node_to_porcelain( 4840 plumbing_response.peering_group_node) 4841 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4842 plumbing_response.rate_limit) 4843 return resp 4844 4845 def list(self, filter, *args, timeout=None): 4846 ''' 4847 List gets a list of peering group node attachments. 4848 ''' 4849 deadline = None if timeout is None else time.time() + timeout 4850 req = PeeringGroupNodeListRequest() 4851 req.meta.CopyFrom(ListRequestMetadata()) 4852 if self.parent.page_limit > 0: 4853 req.meta.limit = self.parent.page_limit 4854 if self.parent.snapshot_datetime is not None: 4855 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4856 4857 req.filter = plumbing.quote_filter_args(filter, *args) 4858 4859 def generator(svc, req): 4860 tries = 0 4861 while True: 4862 t = None if deadline is None else deadline - time.time() 4863 try: 4864 plumbing_response = svc.stub.List( 4865 req, 4866 metadata=svc.parent.get_metadata( 4867 'PeeringGroupNodes.List', req), 4868 timeout=t) 4869 except Exception as e: 4870 if self.parent.shouldRetry(tries, e, deadline): 4871 tries += 1 4872 time.sleep( 4873 self.parent.exponentialBackoff(tries, deadline)) 4874 continue 4875 raise plumbing.convert_error_to_porcelain(e) from e 4876 tries = 0 4877 for plumbing_item in plumbing_response.peering_group_nodes: 4878 yield plumbing.convert_peering_group_node_to_porcelain( 4879 plumbing_item) 4880 if plumbing_response.meta.next_cursor == '': 4881 break 4882 req.meta.cursor = plumbing_response.meta.next_cursor 4883 4884 return generator(self, req) 4885 4886 4887class PeeringGroupPeers: 4888 ''' 4889 PeeringGroupPeers provides the building blocks necessary to link two peering groups. 4890 See `strongdm.models.PeeringGroupPeer`. 4891 ''' 4892 def __init__(self, channel, client): 4893 self.parent = client 4894 self.stub = PeeringGroupPeersStub(channel) 4895 4896 def create(self, peering_group_peer, timeout=None): 4897 ''' 4898 Create links two peering groups. 4899 ''' 4900 deadline = None if timeout is None else time.time() + timeout 4901 req = PeeringGroupPeerCreateRequest() 4902 4903 if peering_group_peer is not None: 4904 req.peering_group_peer.CopyFrom( 4905 plumbing.convert_peering_group_peer_to_plumbing( 4906 peering_group_peer)) 4907 tries = 0 4908 plumbing_response = None 4909 while True: 4910 t = None if deadline is None else deadline - time.time() 4911 try: 4912 plumbing_response = self.stub.Create( 4913 req, 4914 metadata=self.parent.get_metadata( 4915 'PeeringGroupPeers.Create', req), 4916 timeout=t) 4917 except Exception as e: 4918 if self.parent.shouldRetry(tries, e, deadline): 4919 tries += 1 4920 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4921 continue 4922 raise plumbing.convert_error_to_porcelain(e) from e 4923 break 4924 4925 resp = models.PeeringGroupPeerCreateResponse() 4926 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4927 plumbing_response.meta) 4928 resp.peering_group_peer = plumbing.convert_peering_group_peer_to_porcelain( 4929 plumbing_response.peering_group_peer) 4930 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4931 plumbing_response.rate_limit) 4932 return resp 4933 4934 def delete(self, id, timeout=None): 4935 ''' 4936 Delete unlinks two peering groups. 4937 ''' 4938 deadline = None if timeout is None else time.time() + timeout 4939 req = PeeringGroupPeerDeleteRequest() 4940 4941 req.id = (id) 4942 tries = 0 4943 plumbing_response = None 4944 while True: 4945 t = None if deadline is None else deadline - time.time() 4946 try: 4947 plumbing_response = self.stub.Delete( 4948 req, 4949 metadata=self.parent.get_metadata( 4950 'PeeringGroupPeers.Delete', req), 4951 timeout=t) 4952 except Exception as e: 4953 if self.parent.shouldRetry(tries, e, deadline): 4954 tries += 1 4955 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4956 continue 4957 raise plumbing.convert_error_to_porcelain(e) from e 4958 break 4959 4960 resp = models.PeeringGroupPeerDeleteResponse() 4961 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 4962 plumbing_response.meta) 4963 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4964 plumbing_response.rate_limit) 4965 return resp 4966 4967 def get(self, id, timeout=None): 4968 ''' 4969 Get reads the information of one peering group link. 4970 ''' 4971 deadline = None if timeout is None else time.time() + timeout 4972 req = PeeringGroupPeerGetRequest() 4973 if self.parent.snapshot_datetime is not None: 4974 req.meta.CopyFrom(GetRequestMetadata()) 4975 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4976 4977 req.id = (id) 4978 tries = 0 4979 plumbing_response = None 4980 while True: 4981 t = None if deadline is None else deadline - time.time() 4982 try: 4983 plumbing_response = self.stub.Get( 4984 req, 4985 metadata=self.parent.get_metadata('PeeringGroupPeers.Get', 4986 req), 4987 timeout=t) 4988 except Exception as e: 4989 if self.parent.shouldRetry(tries, e, deadline): 4990 tries += 1 4991 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4992 continue 4993 raise plumbing.convert_error_to_porcelain(e) from e 4994 break 4995 4996 resp = models.PeeringGroupPeerGetResponse() 4997 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4998 plumbing_response.meta) 4999 resp.peering_group_peer = plumbing.convert_peering_group_peer_to_porcelain( 5000 plumbing_response.peering_group_peer) 5001 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5002 plumbing_response.rate_limit) 5003 return resp 5004 5005 def list(self, filter, *args, timeout=None): 5006 ''' 5007 List gets a list of peering group links. 5008 ''' 5009 deadline = None if timeout is None else time.time() + timeout 5010 req = PeeringGroupPeerListRequest() 5011 req.meta.CopyFrom(ListRequestMetadata()) 5012 if self.parent.page_limit > 0: 5013 req.meta.limit = self.parent.page_limit 5014 if self.parent.snapshot_datetime is not None: 5015 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5016 5017 req.filter = plumbing.quote_filter_args(filter, *args) 5018 5019 def generator(svc, req): 5020 tries = 0 5021 while True: 5022 t = None if deadline is None else deadline - time.time() 5023 try: 5024 plumbing_response = svc.stub.List( 5025 req, 5026 metadata=svc.parent.get_metadata( 5027 'PeeringGroupPeers.List', req), 5028 timeout=t) 5029 except Exception as e: 5030 if self.parent.shouldRetry(tries, e, deadline): 5031 tries += 1 5032 time.sleep( 5033 self.parent.exponentialBackoff(tries, deadline)) 5034 continue 5035 raise plumbing.convert_error_to_porcelain(e) from e 5036 tries = 0 5037 for plumbing_item in plumbing_response.peering_group_peers: 5038 yield plumbing.convert_peering_group_peer_to_porcelain( 5039 plumbing_item) 5040 if plumbing_response.meta.next_cursor == '': 5041 break 5042 req.meta.cursor = plumbing_response.meta.next_cursor 5043 5044 return generator(self, req) 5045 5046 5047class PeeringGroupResources: 5048 ''' 5049 PeeringGroupResources provides the building blocks necessary to obtain attach a resource to a peering group. 5050 See `strongdm.models.PeeringGroupResource`. 5051 ''' 5052 def __init__(self, channel, client): 5053 self.parent = client 5054 self.stub = PeeringGroupResourcesStub(channel) 5055 5056 def create(self, peering_group_resource, timeout=None): 5057 ''' 5058 Create attaches a Resource to a PeeringGroup 5059 ''' 5060 deadline = None if timeout is None else time.time() + timeout 5061 req = PeeringGroupResourceCreateRequest() 5062 5063 if peering_group_resource is not None: 5064 req.peering_group_resource.CopyFrom( 5065 plumbing.convert_peering_group_resource_to_plumbing( 5066 peering_group_resource)) 5067 tries = 0 5068 plumbing_response = None 5069 while True: 5070 t = None if deadline is None else deadline - time.time() 5071 try: 5072 plumbing_response = self.stub.Create( 5073 req, 5074 metadata=self.parent.get_metadata( 5075 'PeeringGroupResources.Create', req), 5076 timeout=t) 5077 except Exception as e: 5078 if self.parent.shouldRetry(tries, e, deadline): 5079 tries += 1 5080 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5081 continue 5082 raise plumbing.convert_error_to_porcelain(e) from e 5083 break 5084 5085 resp = models.PeeringGroupResourceCreateResponse() 5086 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5087 plumbing_response.meta) 5088 resp.peering_group_resource = plumbing.convert_peering_group_resource_to_porcelain( 5089 plumbing_response.peering_group_resource) 5090 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5091 plumbing_response.rate_limit) 5092 return resp 5093 5094 def delete(self, id, timeout=None): 5095 ''' 5096 Delete detaches a Resource to a PeeringGroup 5097 ''' 5098 deadline = None if timeout is None else time.time() + timeout 5099 req = PeeringGroupResourceDeleteRequest() 5100 5101 req.id = (id) 5102 tries = 0 5103 plumbing_response = None 5104 while True: 5105 t = None if deadline is None else deadline - time.time() 5106 try: 5107 plumbing_response = self.stub.Delete( 5108 req, 5109 metadata=self.parent.get_metadata( 5110 'PeeringGroupResources.Delete', req), 5111 timeout=t) 5112 except Exception as e: 5113 if self.parent.shouldRetry(tries, e, deadline): 5114 tries += 1 5115 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5116 continue 5117 raise plumbing.convert_error_to_porcelain(e) from e 5118 break 5119 5120 resp = models.PeeringGroupResourceDeleteResponse() 5121 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 5122 plumbing_response.meta) 5123 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5124 plumbing_response.rate_limit) 5125 return resp 5126 5127 def get(self, id, timeout=None): 5128 ''' 5129 Get reads the information of one peering group to resource attachment. 5130 ''' 5131 deadline = None if timeout is None else time.time() + timeout 5132 req = PeeringGroupResourceGetRequest() 5133 if self.parent.snapshot_datetime is not None: 5134 req.meta.CopyFrom(GetRequestMetadata()) 5135 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5136 5137 req.id = (id) 5138 tries = 0 5139 plumbing_response = None 5140 while True: 5141 t = None if deadline is None else deadline - time.time() 5142 try: 5143 plumbing_response = self.stub.Get( 5144 req, 5145 metadata=self.parent.get_metadata( 5146 'PeeringGroupResources.Get', req), 5147 timeout=t) 5148 except Exception as e: 5149 if self.parent.shouldRetry(tries, e, deadline): 5150 tries += 1 5151 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5152 continue 5153 raise plumbing.convert_error_to_porcelain(e) from e 5154 break 5155 5156 resp = models.PeeringGroupResourceGetResponse() 5157 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5158 plumbing_response.meta) 5159 resp.peering_group_resource = plumbing.convert_peering_group_resource_to_porcelain( 5160 plumbing_response.peering_group_resource) 5161 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5162 plumbing_response.rate_limit) 5163 return resp 5164 5165 def list(self, filter, *args, timeout=None): 5166 ''' 5167 List gets a list of peering group resource attachments. 5168 ''' 5169 deadline = None if timeout is None else time.time() + timeout 5170 req = PeeringGroupResourceListRequest() 5171 req.meta.CopyFrom(ListRequestMetadata()) 5172 if self.parent.page_limit > 0: 5173 req.meta.limit = self.parent.page_limit 5174 if self.parent.snapshot_datetime is not None: 5175 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5176 5177 req.filter = plumbing.quote_filter_args(filter, *args) 5178 5179 def generator(svc, req): 5180 tries = 0 5181 while True: 5182 t = None if deadline is None else deadline - time.time() 5183 try: 5184 plumbing_response = svc.stub.List( 5185 req, 5186 metadata=svc.parent.get_metadata( 5187 'PeeringGroupResources.List', req), 5188 timeout=t) 5189 except Exception as e: 5190 if self.parent.shouldRetry(tries, e, deadline): 5191 tries += 1 5192 time.sleep( 5193 self.parent.exponentialBackoff(tries, deadline)) 5194 continue 5195 raise plumbing.convert_error_to_porcelain(e) from e 5196 tries = 0 5197 for plumbing_item in plumbing_response.peering_group_resources: 5198 yield plumbing.convert_peering_group_resource_to_porcelain( 5199 plumbing_item) 5200 if plumbing_response.meta.next_cursor == '': 5201 break 5202 req.meta.cursor = plumbing_response.meta.next_cursor 5203 5204 return generator(self, req) 5205 5206 5207class PeeringGroups: 5208 ''' 5209 PeeringGroups provides the building blocks necessary to obtain explicit network topology and routing. 5210 See `strongdm.models.PeeringGroup`. 5211 ''' 5212 def __init__(self, channel, client): 5213 self.parent = client 5214 self.stub = PeeringGroupsStub(channel) 5215 5216 def create(self, peering_group, timeout=None): 5217 ''' 5218 Create registers a new PeeringGroup. 5219 ''' 5220 deadline = None if timeout is None else time.time() + timeout 5221 req = PeeringGroupCreateRequest() 5222 5223 if peering_group is not None: 5224 req.peering_group.CopyFrom( 5225 plumbing.convert_peering_group_to_plumbing(peering_group)) 5226 tries = 0 5227 plumbing_response = None 5228 while True: 5229 t = None if deadline is None else deadline - time.time() 5230 try: 5231 plumbing_response = self.stub.Create( 5232 req, 5233 metadata=self.parent.get_metadata('PeeringGroups.Create', 5234 req), 5235 timeout=t) 5236 except Exception as e: 5237 if self.parent.shouldRetry(tries, e, deadline): 5238 tries += 1 5239 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5240 continue 5241 raise plumbing.convert_error_to_porcelain(e) from e 5242 break 5243 5244 resp = models.PeeringGroupCreateResponse() 5245 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5246 plumbing_response.meta) 5247 resp.peering_group = plumbing.convert_peering_group_to_porcelain( 5248 plumbing_response.peering_group) 5249 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5250 plumbing_response.rate_limit) 5251 return resp 5252 5253 def delete(self, id, timeout=None): 5254 ''' 5255 Delete removes a PeeringGroup by ID. 5256 ''' 5257 deadline = None if timeout is None else time.time() + timeout 5258 req = PeeringGroupDeleteRequest() 5259 5260 req.id = (id) 5261 tries = 0 5262 plumbing_response = None 5263 while True: 5264 t = None if deadline is None else deadline - time.time() 5265 try: 5266 plumbing_response = self.stub.Delete( 5267 req, 5268 metadata=self.parent.get_metadata('PeeringGroups.Delete', 5269 req), 5270 timeout=t) 5271 except Exception as e: 5272 if self.parent.shouldRetry(tries, e, deadline): 5273 tries += 1 5274 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5275 continue 5276 raise plumbing.convert_error_to_porcelain(e) from e 5277 break 5278 5279 resp = models.PeeringGroupDeleteResponse() 5280 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 5281 plumbing_response.meta) 5282 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5283 plumbing_response.rate_limit) 5284 return resp 5285 5286 def get(self, id, timeout=None): 5287 ''' 5288 Get reads one PeeringGroup by ID. It will load all its dependencies. 5289 ''' 5290 deadline = None if timeout is None else time.time() + timeout 5291 req = PeeringGroupGetRequest() 5292 if self.parent.snapshot_datetime is not None: 5293 req.meta.CopyFrom(GetRequestMetadata()) 5294 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5295 5296 req.id = (id) 5297 tries = 0 5298 plumbing_response = None 5299 while True: 5300 t = None if deadline is None else deadline - time.time() 5301 try: 5302 plumbing_response = self.stub.Get( 5303 req, 5304 metadata=self.parent.get_metadata('PeeringGroups.Get', 5305 req), 5306 timeout=t) 5307 except Exception as e: 5308 if self.parent.shouldRetry(tries, e, deadline): 5309 tries += 1 5310 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5311 continue 5312 raise plumbing.convert_error_to_porcelain(e) from e 5313 break 5314 5315 resp = models.PeeringGroupGetResponse() 5316 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5317 plumbing_response.meta) 5318 resp.peering_group = plumbing.convert_peering_group_to_porcelain( 5319 plumbing_response.peering_group) 5320 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5321 plumbing_response.rate_limit) 5322 return resp 5323 5324 def list(self, filter, *args, timeout=None): 5325 ''' 5326 List gets a list of Peering Groups. 5327 ''' 5328 deadline = None if timeout is None else time.time() + timeout 5329 req = PeeringGroupListRequest() 5330 req.meta.CopyFrom(ListRequestMetadata()) 5331 if self.parent.page_limit > 0: 5332 req.meta.limit = self.parent.page_limit 5333 if self.parent.snapshot_datetime is not None: 5334 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5335 5336 req.filter = plumbing.quote_filter_args(filter, *args) 5337 5338 def generator(svc, req): 5339 tries = 0 5340 while True: 5341 t = None if deadline is None else deadline - time.time() 5342 try: 5343 plumbing_response = svc.stub.List( 5344 req, 5345 metadata=svc.parent.get_metadata( 5346 'PeeringGroups.List', req), 5347 timeout=t) 5348 except Exception as e: 5349 if self.parent.shouldRetry(tries, e, deadline): 5350 tries += 1 5351 time.sleep( 5352 self.parent.exponentialBackoff(tries, deadline)) 5353 continue 5354 raise plumbing.convert_error_to_porcelain(e) from e 5355 tries = 0 5356 for plumbing_item in plumbing_response.peering_groups: 5357 yield plumbing.convert_peering_group_to_porcelain( 5358 plumbing_item) 5359 if plumbing_response.meta.next_cursor == '': 5360 break 5361 req.meta.cursor = plumbing_response.meta.next_cursor 5362 5363 return generator(self, req) 5364 5365 5366class Policies: 5367 ''' 5368 Policies are the collection of one or more statements that enforce fine-grained access 5369 control for the users of an organization. 5370 See `strongdm.models.Policy`. 5371 ''' 5372 def __init__(self, channel, client): 5373 self.parent = client 5374 self.stub = PoliciesStub(channel) 5375 5376 def create(self, policy, timeout=None): 5377 ''' 5378 Create creates a new Policy. 5379 ''' 5380 deadline = None if timeout is None else time.time() + timeout 5381 req = PolicyCreateRequest() 5382 5383 if policy is not None: 5384 req.policy.CopyFrom(plumbing.convert_policy_to_plumbing(policy)) 5385 tries = 0 5386 plumbing_response = None 5387 while True: 5388 t = None if deadline is None else deadline - time.time() 5389 try: 5390 plumbing_response = self.stub.Create( 5391 req, 5392 metadata=self.parent.get_metadata('Policies.Create', req), 5393 timeout=t) 5394 except Exception as e: 5395 if self.parent.shouldRetry(tries, e, deadline): 5396 tries += 1 5397 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5398 continue 5399 raise plumbing.convert_error_to_porcelain(e) from e 5400 break 5401 5402 resp = models.PolicyCreateResponse() 5403 resp.policy = plumbing.convert_policy_to_porcelain( 5404 plumbing_response.policy) 5405 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5406 plumbing_response.rate_limit) 5407 return resp 5408 5409 def delete(self, id, timeout=None): 5410 ''' 5411 Delete removes a Policy by ID. 5412 ''' 5413 deadline = None if timeout is None else time.time() + timeout 5414 req = PolicyDeleteRequest() 5415 5416 req.id = (id) 5417 tries = 0 5418 plumbing_response = None 5419 while True: 5420 t = None if deadline is None else deadline - time.time() 5421 try: 5422 plumbing_response = self.stub.Delete( 5423 req, 5424 metadata=self.parent.get_metadata('Policies.Delete', req), 5425 timeout=t) 5426 except Exception as e: 5427 if self.parent.shouldRetry(tries, e, deadline): 5428 tries += 1 5429 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5430 continue 5431 raise plumbing.convert_error_to_porcelain(e) from e 5432 break 5433 5434 resp = models.PolicyDeleteResponse() 5435 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5436 plumbing_response.rate_limit) 5437 return resp 5438 5439 def update(self, policy, timeout=None): 5440 ''' 5441 Update replaces all the fields of a Policy by ID. 5442 ''' 5443 deadline = None if timeout is None else time.time() + timeout 5444 req = PolicyUpdateRequest() 5445 5446 if policy is not None: 5447 req.policy.CopyFrom(plumbing.convert_policy_to_plumbing(policy)) 5448 tries = 0 5449 plumbing_response = None 5450 while True: 5451 t = None if deadline is None else deadline - time.time() 5452 try: 5453 plumbing_response = self.stub.Update( 5454 req, 5455 metadata=self.parent.get_metadata('Policies.Update', req), 5456 timeout=t) 5457 except Exception as e: 5458 if self.parent.shouldRetry(tries, e, deadline): 5459 tries += 1 5460 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5461 continue 5462 raise plumbing.convert_error_to_porcelain(e) from e 5463 break 5464 5465 resp = models.PolicyUpdateResponse() 5466 resp.policy = plumbing.convert_policy_to_porcelain( 5467 plumbing_response.policy) 5468 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5469 plumbing_response.rate_limit) 5470 return resp 5471 5472 def get(self, id, timeout=None): 5473 ''' 5474 Get reads one Policy by ID. 5475 ''' 5476 deadline = None if timeout is None else time.time() + timeout 5477 req = PolicyGetRequest() 5478 if self.parent.snapshot_datetime is not None: 5479 req.meta.CopyFrom(GetRequestMetadata()) 5480 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5481 5482 req.id = (id) 5483 tries = 0 5484 plumbing_response = None 5485 while True: 5486 t = None if deadline is None else deadline - time.time() 5487 try: 5488 plumbing_response = self.stub.Get( 5489 req, 5490 metadata=self.parent.get_metadata('Policies.Get', req), 5491 timeout=t) 5492 except Exception as e: 5493 if self.parent.shouldRetry(tries, e, deadline): 5494 tries += 1 5495 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5496 continue 5497 raise plumbing.convert_error_to_porcelain(e) from e 5498 break 5499 5500 resp = models.PolicyGetResponse() 5501 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5502 plumbing_response.meta) 5503 resp.policy = plumbing.convert_policy_to_porcelain( 5504 plumbing_response.policy) 5505 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5506 plumbing_response.rate_limit) 5507 return resp 5508 5509 def list(self, filter, *args, timeout=None): 5510 ''' 5511 List gets a list of Policy matching a given set of criteria 5512 ''' 5513 deadline = None if timeout is None else time.time() + timeout 5514 req = PolicyListRequest() 5515 req.meta.CopyFrom(ListRequestMetadata()) 5516 if self.parent.page_limit > 0: 5517 req.meta.limit = self.parent.page_limit 5518 if self.parent.snapshot_datetime is not None: 5519 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5520 5521 req.filter = plumbing.quote_filter_args(filter, *args) 5522 5523 def generator(svc, req): 5524 tries = 0 5525 while True: 5526 t = None if deadline is None else deadline - time.time() 5527 try: 5528 plumbing_response = svc.stub.List( 5529 req, 5530 metadata=svc.parent.get_metadata('Policies.List', req), 5531 timeout=t) 5532 except Exception as e: 5533 if self.parent.shouldRetry(tries, e, deadline): 5534 tries += 1 5535 time.sleep( 5536 self.parent.exponentialBackoff(tries, deadline)) 5537 continue 5538 raise plumbing.convert_error_to_porcelain(e) from e 5539 tries = 0 5540 for plumbing_item in plumbing_response.policies: 5541 yield plumbing.convert_policy_to_porcelain(plumbing_item) 5542 if plumbing_response.meta.next_cursor == '': 5543 break 5544 req.meta.cursor = plumbing_response.meta.next_cursor 5545 5546 return generator(self, req) 5547 5548 5549class SnapshotPolicies: 5550 ''' 5551 SnapshotPolicies exposes the read only methods of the Policies 5552 service for historical queries. 5553 ''' 5554 def __init__(self, policies): 5555 self.policies = policies 5556 5557 def get(self, id, timeout=None): 5558 ''' 5559 Get reads one Policy by ID. 5560 ''' 5561 return self.policies.get(id, timeout=timeout) 5562 5563 def list(self, filter, *args, timeout=None): 5564 ''' 5565 List gets a list of Policy matching a given set of criteria 5566 ''' 5567 return self.policies.list(filter, *args, timeout=timeout) 5568 5569 5570class PoliciesHistory: 5571 ''' 5572 PoliciesHistory records all changes to the state of a Policy. 5573 See `strongdm.models.PolicyHistory`. 5574 ''' 5575 def __init__(self, channel, client): 5576 self.parent = client 5577 self.stub = PoliciesHistoryStub(channel) 5578 5579 def list(self, filter, *args, timeout=None): 5580 ''' 5581 List gets a list of PolicyHistory records matching a given set of criteria. 5582 ''' 5583 deadline = None if timeout is None else time.time() + timeout 5584 req = PoliciesHistoryListRequest() 5585 req.meta.CopyFrom(ListRequestMetadata()) 5586 if self.parent.page_limit > 0: 5587 req.meta.limit = self.parent.page_limit 5588 if self.parent.snapshot_datetime is not None: 5589 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5590 5591 req.filter = plumbing.quote_filter_args(filter, *args) 5592 5593 def generator(svc, req): 5594 tries = 0 5595 while True: 5596 t = None if deadline is None else deadline - time.time() 5597 try: 5598 plumbing_response = svc.stub.List( 5599 req, 5600 metadata=svc.parent.get_metadata( 5601 'PoliciesHistory.List', req), 5602 timeout=t) 5603 except Exception as e: 5604 if self.parent.shouldRetry(tries, e, deadline): 5605 tries += 1 5606 time.sleep( 5607 self.parent.exponentialBackoff(tries, deadline)) 5608 continue 5609 raise plumbing.convert_error_to_porcelain(e) from e 5610 tries = 0 5611 for plumbing_item in plumbing_response.history: 5612 yield plumbing.convert_policy_history_to_porcelain( 5613 plumbing_item) 5614 if plumbing_response.meta.next_cursor == '': 5615 break 5616 req.meta.cursor = plumbing_response.meta.next_cursor 5617 5618 return generator(self, req) 5619 5620 5621class ProxyClusterKeys: 5622 ''' 5623 Proxy Cluster Keys are authentication keys for all proxies within a cluster. 5624 The proxies within a cluster share the same key. One cluster can have 5625 multiple keys in order to facilitate key rotation. 5626 See `strongdm.models.ProxyClusterKey`. 5627 ''' 5628 def __init__(self, channel, client): 5629 self.parent = client 5630 self.stub = ProxyClusterKeysStub(channel) 5631 5632 def create(self, proxy_cluster_key, timeout=None): 5633 ''' 5634 Create registers a new ProxyClusterKey. 5635 ''' 5636 deadline = None if timeout is None else time.time() + timeout 5637 req = ProxyClusterKeyCreateRequest() 5638 5639 if proxy_cluster_key is not None: 5640 req.proxy_cluster_key.CopyFrom( 5641 plumbing.convert_proxy_cluster_key_to_plumbing( 5642 proxy_cluster_key)) 5643 tries = 0 5644 plumbing_response = None 5645 while True: 5646 t = None if deadline is None else deadline - time.time() 5647 try: 5648 plumbing_response = self.stub.Create( 5649 req, 5650 metadata=self.parent.get_metadata( 5651 'ProxyClusterKeys.Create', req), 5652 timeout=t) 5653 except Exception as e: 5654 if self.parent.shouldRetry(tries, e, deadline): 5655 tries += 1 5656 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5657 continue 5658 raise plumbing.convert_error_to_porcelain(e) from e 5659 break 5660 5661 resp = models.ProxyClusterKeyCreateResponse() 5662 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5663 plumbing_response.meta) 5664 resp.proxy_cluster_key = plumbing.convert_proxy_cluster_key_to_porcelain( 5665 plumbing_response.proxy_cluster_key) 5666 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5667 plumbing_response.rate_limit) 5668 resp.secret_key = (plumbing_response.secret_key) 5669 return resp 5670 5671 def get(self, id, timeout=None): 5672 ''' 5673 Get reads one ProxyClusterKey by ID. 5674 ''' 5675 deadline = None if timeout is None else time.time() + timeout 5676 req = ProxyClusterKeyGetRequest() 5677 if self.parent.snapshot_datetime is not None: 5678 req.meta.CopyFrom(GetRequestMetadata()) 5679 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5680 5681 req.id = (id) 5682 tries = 0 5683 plumbing_response = None 5684 while True: 5685 t = None if deadline is None else deadline - time.time() 5686 try: 5687 plumbing_response = self.stub.Get( 5688 req, 5689 metadata=self.parent.get_metadata('ProxyClusterKeys.Get', 5690 req), 5691 timeout=t) 5692 except Exception as e: 5693 if self.parent.shouldRetry(tries, e, deadline): 5694 tries += 1 5695 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5696 continue 5697 raise plumbing.convert_error_to_porcelain(e) from e 5698 break 5699 5700 resp = models.ProxyClusterKeyGetResponse() 5701 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5702 plumbing_response.meta) 5703 resp.proxy_cluster_key = plumbing.convert_proxy_cluster_key_to_porcelain( 5704 plumbing_response.proxy_cluster_key) 5705 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5706 plumbing_response.rate_limit) 5707 return resp 5708 5709 def delete(self, id, timeout=None): 5710 ''' 5711 Delete removes a ProxyClusterKey by ID. 5712 ''' 5713 deadline = None if timeout is None else time.time() + timeout 5714 req = ProxyClusterKeyDeleteRequest() 5715 5716 req.id = (id) 5717 tries = 0 5718 plumbing_response = None 5719 while True: 5720 t = None if deadline is None else deadline - time.time() 5721 try: 5722 plumbing_response = self.stub.Delete( 5723 req, 5724 metadata=self.parent.get_metadata( 5725 'ProxyClusterKeys.Delete', req), 5726 timeout=t) 5727 except Exception as e: 5728 if self.parent.shouldRetry(tries, e, deadline): 5729 tries += 1 5730 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5731 continue 5732 raise plumbing.convert_error_to_porcelain(e) from e 5733 break 5734 5735 resp = models.ProxyClusterKeyDeleteResponse() 5736 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 5737 plumbing_response.meta) 5738 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5739 plumbing_response.rate_limit) 5740 return resp 5741 5742 def list(self, filter, *args, timeout=None): 5743 ''' 5744 List gets a list of ProxyClusterKeys matching a given set of criteria. 5745 ''' 5746 deadline = None if timeout is None else time.time() + timeout 5747 req = ProxyClusterKeyListRequest() 5748 req.meta.CopyFrom(ListRequestMetadata()) 5749 if self.parent.page_limit > 0: 5750 req.meta.limit = self.parent.page_limit 5751 if self.parent.snapshot_datetime is not None: 5752 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5753 5754 req.filter = plumbing.quote_filter_args(filter, *args) 5755 5756 def generator(svc, req): 5757 tries = 0 5758 while True: 5759 t = None if deadline is None else deadline - time.time() 5760 try: 5761 plumbing_response = svc.stub.List( 5762 req, 5763 metadata=svc.parent.get_metadata( 5764 'ProxyClusterKeys.List', req), 5765 timeout=t) 5766 except Exception as e: 5767 if self.parent.shouldRetry(tries, e, deadline): 5768 tries += 1 5769 time.sleep( 5770 self.parent.exponentialBackoff(tries, deadline)) 5771 continue 5772 raise plumbing.convert_error_to_porcelain(e) from e 5773 tries = 0 5774 for plumbing_item in plumbing_response.proxy_cluster_keys: 5775 yield plumbing.convert_proxy_cluster_key_to_porcelain( 5776 plumbing_item) 5777 if plumbing_response.meta.next_cursor == '': 5778 break 5779 req.meta.cursor = plumbing_response.meta.next_cursor 5780 5781 return generator(self, req) 5782 5783 5784class SnapshotProxyClusterKeys: 5785 ''' 5786 SnapshotProxyClusterKeys exposes the read only methods of the ProxyClusterKeys 5787 service for historical queries. 5788 ''' 5789 def __init__(self, proxy_cluster_keys): 5790 self.proxy_cluster_keys = proxy_cluster_keys 5791 5792 def get(self, id, timeout=None): 5793 ''' 5794 Get reads one ProxyClusterKey by ID. 5795 ''' 5796 return self.proxy_cluster_keys.get(id, timeout=timeout) 5797 5798 def list(self, filter, *args, timeout=None): 5799 ''' 5800 List gets a list of ProxyClusterKeys matching a given set of criteria. 5801 ''' 5802 return self.proxy_cluster_keys.list(filter, *args, timeout=timeout) 5803 5804 5805class Queries: 5806 ''' 5807 A Query is a record of a single client request to a resource, such as a SQL query. 5808 Long-running SSH, RDP, or Kubernetes interactive sessions also count as queries. 5809 The Queries service is read-only. 5810 See `strongdm.models.Query`. 5811 ''' 5812 def __init__(self, channel, client): 5813 self.parent = client 5814 self.stub = QueriesStub(channel) 5815 5816 def list(self, filter, *args, timeout=None): 5817 ''' 5818 List gets a list of Queries matching a given set of criteria. 5819 ''' 5820 deadline = None if timeout is None else time.time() + timeout 5821 req = QueryListRequest() 5822 req.meta.CopyFrom(ListRequestMetadata()) 5823 if self.parent.page_limit > 0: 5824 req.meta.limit = self.parent.page_limit 5825 if self.parent.snapshot_datetime is not None: 5826 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5827 5828 req.filter = plumbing.quote_filter_args(filter, *args) 5829 5830 def generator(svc, req): 5831 tries = 0 5832 while True: 5833 t = None if deadline is None else deadline - time.time() 5834 try: 5835 plumbing_response = svc.stub.List( 5836 req, 5837 metadata=svc.parent.get_metadata('Queries.List', req), 5838 timeout=t) 5839 except Exception as e: 5840 if self.parent.shouldRetry(tries, e, deadline): 5841 tries += 1 5842 time.sleep( 5843 self.parent.exponentialBackoff(tries, deadline)) 5844 continue 5845 raise plumbing.convert_error_to_porcelain(e) from e 5846 tries = 0 5847 for plumbing_item in plumbing_response.queries: 5848 yield plumbing.convert_query_to_porcelain(plumbing_item) 5849 if plumbing_response.meta.next_cursor == '': 5850 break 5851 req.meta.cursor = plumbing_response.meta.next_cursor 5852 5853 return generator(self, req) 5854 5855 5856class RemoteIdentities: 5857 ''' 5858 RemoteIdentities assign a resource directly to an account, giving the account the permission to connect to that resource. 5859 See `strongdm.models.RemoteIdentity`. 5860 ''' 5861 def __init__(self, channel, client): 5862 self.parent = client 5863 self.stub = RemoteIdentitiesStub(channel) 5864 5865 def create(self, remote_identity, timeout=None): 5866 ''' 5867 Create registers a new RemoteIdentity. 5868 ''' 5869 deadline = None if timeout is None else time.time() + timeout 5870 req = RemoteIdentityCreateRequest() 5871 5872 if remote_identity is not None: 5873 req.remote_identity.CopyFrom( 5874 plumbing.convert_remote_identity_to_plumbing(remote_identity)) 5875 tries = 0 5876 plumbing_response = None 5877 while True: 5878 t = None if deadline is None else deadline - time.time() 5879 try: 5880 plumbing_response = self.stub.Create( 5881 req, 5882 metadata=self.parent.get_metadata( 5883 'RemoteIdentities.Create', req), 5884 timeout=t) 5885 except Exception as e: 5886 if self.parent.shouldRetry(tries, e, deadline): 5887 tries += 1 5888 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5889 continue 5890 raise plumbing.convert_error_to_porcelain(e) from e 5891 break 5892 5893 resp = models.RemoteIdentityCreateResponse() 5894 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5895 plumbing_response.meta) 5896 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5897 plumbing_response.rate_limit) 5898 resp.remote_identity = plumbing.convert_remote_identity_to_porcelain( 5899 plumbing_response.remote_identity) 5900 return resp 5901 5902 def get(self, id, timeout=None): 5903 ''' 5904 Get reads one RemoteIdentity by ID. 5905 ''' 5906 deadline = None if timeout is None else time.time() + timeout 5907 req = RemoteIdentityGetRequest() 5908 if self.parent.snapshot_datetime is not None: 5909 req.meta.CopyFrom(GetRequestMetadata()) 5910 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5911 5912 req.id = (id) 5913 tries = 0 5914 plumbing_response = None 5915 while True: 5916 t = None if deadline is None else deadline - time.time() 5917 try: 5918 plumbing_response = self.stub.Get( 5919 req, 5920 metadata=self.parent.get_metadata('RemoteIdentities.Get', 5921 req), 5922 timeout=t) 5923 except Exception as e: 5924 if self.parent.shouldRetry(tries, e, deadline): 5925 tries += 1 5926 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5927 continue 5928 raise plumbing.convert_error_to_porcelain(e) from e 5929 break 5930 5931 resp = models.RemoteIdentityGetResponse() 5932 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5933 plumbing_response.meta) 5934 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5935 plumbing_response.rate_limit) 5936 resp.remote_identity = plumbing.convert_remote_identity_to_porcelain( 5937 plumbing_response.remote_identity) 5938 return resp 5939 5940 def update(self, remote_identity, timeout=None): 5941 ''' 5942 Update replaces all the fields of a RemoteIdentity by ID. 5943 ''' 5944 deadline = None if timeout is None else time.time() + timeout 5945 req = RemoteIdentityUpdateRequest() 5946 5947 if remote_identity is not None: 5948 req.remote_identity.CopyFrom( 5949 plumbing.convert_remote_identity_to_plumbing(remote_identity)) 5950 tries = 0 5951 plumbing_response = None 5952 while True: 5953 t = None if deadline is None else deadline - time.time() 5954 try: 5955 plumbing_response = self.stub.Update( 5956 req, 5957 metadata=self.parent.get_metadata( 5958 'RemoteIdentities.Update', req), 5959 timeout=t) 5960 except Exception as e: 5961 if self.parent.shouldRetry(tries, e, deadline): 5962 tries += 1 5963 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5964 continue 5965 raise plumbing.convert_error_to_porcelain(e) from e 5966 break 5967 5968 resp = models.RemoteIdentityUpdateResponse() 5969 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 5970 plumbing_response.meta) 5971 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5972 plumbing_response.rate_limit) 5973 resp.remote_identity = plumbing.convert_remote_identity_to_porcelain( 5974 plumbing_response.remote_identity) 5975 return resp 5976 5977 def delete(self, id, timeout=None): 5978 ''' 5979 Delete removes a RemoteIdentity by ID. 5980 ''' 5981 deadline = None if timeout is None else time.time() + timeout 5982 req = RemoteIdentityDeleteRequest() 5983 5984 req.id = (id) 5985 tries = 0 5986 plumbing_response = None 5987 while True: 5988 t = None if deadline is None else deadline - time.time() 5989 try: 5990 plumbing_response = self.stub.Delete( 5991 req, 5992 metadata=self.parent.get_metadata( 5993 'RemoteIdentities.Delete', req), 5994 timeout=t) 5995 except Exception as e: 5996 if self.parent.shouldRetry(tries, e, deadline): 5997 tries += 1 5998 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5999 continue 6000 raise plumbing.convert_error_to_porcelain(e) from e 6001 break 6002 6003 resp = models.RemoteIdentityDeleteResponse() 6004 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 6005 plumbing_response.meta) 6006 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6007 plumbing_response.rate_limit) 6008 return resp 6009 6010 def list(self, filter, *args, timeout=None): 6011 ''' 6012 List gets a list of RemoteIdentities matching a given set of criteria. 6013 ''' 6014 deadline = None if timeout is None else time.time() + timeout 6015 req = RemoteIdentityListRequest() 6016 req.meta.CopyFrom(ListRequestMetadata()) 6017 if self.parent.page_limit > 0: 6018 req.meta.limit = self.parent.page_limit 6019 if self.parent.snapshot_datetime is not None: 6020 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6021 6022 req.filter = plumbing.quote_filter_args(filter, *args) 6023 6024 def generator(svc, req): 6025 tries = 0 6026 while True: 6027 t = None if deadline is None else deadline - time.time() 6028 try: 6029 plumbing_response = svc.stub.List( 6030 req, 6031 metadata=svc.parent.get_metadata( 6032 'RemoteIdentities.List', req), 6033 timeout=t) 6034 except Exception as e: 6035 if self.parent.shouldRetry(tries, e, deadline): 6036 tries += 1 6037 time.sleep( 6038 self.parent.exponentialBackoff(tries, deadline)) 6039 continue 6040 raise plumbing.convert_error_to_porcelain(e) from e 6041 tries = 0 6042 for plumbing_item in plumbing_response.remote_identities: 6043 yield plumbing.convert_remote_identity_to_porcelain( 6044 plumbing_item) 6045 if plumbing_response.meta.next_cursor == '': 6046 break 6047 req.meta.cursor = plumbing_response.meta.next_cursor 6048 6049 return generator(self, req) 6050 6051 6052class SnapshotRemoteIdentities: 6053 ''' 6054 SnapshotRemoteIdentities exposes the read only methods of the RemoteIdentities 6055 service for historical queries. 6056 ''' 6057 def __init__(self, remote_identities): 6058 self.remote_identities = remote_identities 6059 6060 def get(self, id, timeout=None): 6061 ''' 6062 Get reads one RemoteIdentity by ID. 6063 ''' 6064 return self.remote_identities.get(id, timeout=timeout) 6065 6066 def list(self, filter, *args, timeout=None): 6067 ''' 6068 List gets a list of RemoteIdentities matching a given set of criteria. 6069 ''' 6070 return self.remote_identities.list(filter, *args, timeout=timeout) 6071 6072 6073class RemoteIdentitiesHistory: 6074 ''' 6075 RemoteIdentitiesHistory records all changes to the state of a RemoteIdentity. 6076 See `strongdm.models.RemoteIdentityHistory`. 6077 ''' 6078 def __init__(self, channel, client): 6079 self.parent = client 6080 self.stub = RemoteIdentitiesHistoryStub(channel) 6081 6082 def list(self, filter, *args, timeout=None): 6083 ''' 6084 List gets a list of RemoteIdentityHistory records matching a given set of criteria. 6085 ''' 6086 deadline = None if timeout is None else time.time() + timeout 6087 req = RemoteIdentityHistoryListRequest() 6088 req.meta.CopyFrom(ListRequestMetadata()) 6089 if self.parent.page_limit > 0: 6090 req.meta.limit = self.parent.page_limit 6091 if self.parent.snapshot_datetime is not None: 6092 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6093 6094 req.filter = plumbing.quote_filter_args(filter, *args) 6095 6096 def generator(svc, req): 6097 tries = 0 6098 while True: 6099 t = None if deadline is None else deadline - time.time() 6100 try: 6101 plumbing_response = svc.stub.List( 6102 req, 6103 metadata=svc.parent.get_metadata( 6104 'RemoteIdentitiesHistory.List', req), 6105 timeout=t) 6106 except Exception as e: 6107 if self.parent.shouldRetry(tries, e, deadline): 6108 tries += 1 6109 time.sleep( 6110 self.parent.exponentialBackoff(tries, deadline)) 6111 continue 6112 raise plumbing.convert_error_to_porcelain(e) from e 6113 tries = 0 6114 for plumbing_item in plumbing_response.history: 6115 yield plumbing.convert_remote_identity_history_to_porcelain( 6116 plumbing_item) 6117 if plumbing_response.meta.next_cursor == '': 6118 break 6119 req.meta.cursor = plumbing_response.meta.next_cursor 6120 6121 return generator(self, req) 6122 6123 6124class RemoteIdentityGroups: 6125 ''' 6126 A RemoteIdentityGroup is a named grouping of Remote Identities for Accounts. 6127 An Account's relationship to a RemoteIdentityGroup is defined via RemoteIdentity objects. 6128 See `strongdm.models.RemoteIdentityGroup`. 6129 ''' 6130 def __init__(self, channel, client): 6131 self.parent = client 6132 self.stub = RemoteIdentityGroupsStub(channel) 6133 6134 def get(self, id, timeout=None): 6135 ''' 6136 Get reads one RemoteIdentityGroup by ID. 6137 ''' 6138 deadline = None if timeout is None else time.time() + timeout 6139 req = RemoteIdentityGroupGetRequest() 6140 if self.parent.snapshot_datetime is not None: 6141 req.meta.CopyFrom(GetRequestMetadata()) 6142 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6143 6144 req.id = (id) 6145 tries = 0 6146 plumbing_response = None 6147 while True: 6148 t = None if deadline is None else deadline - time.time() 6149 try: 6150 plumbing_response = self.stub.Get( 6151 req, 6152 metadata=self.parent.get_metadata( 6153 'RemoteIdentityGroups.Get', req), 6154 timeout=t) 6155 except Exception as e: 6156 if self.parent.shouldRetry(tries, e, deadline): 6157 tries += 1 6158 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6159 continue 6160 raise plumbing.convert_error_to_porcelain(e) from e 6161 break 6162 6163 resp = models.RemoteIdentityGroupGetResponse() 6164 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 6165 plumbing_response.meta) 6166 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6167 plumbing_response.rate_limit) 6168 resp.remote_identity_group = plumbing.convert_remote_identity_group_to_porcelain( 6169 plumbing_response.remote_identity_group) 6170 return resp 6171 6172 def list(self, filter, *args, timeout=None): 6173 ''' 6174 List gets a list of RemoteIdentityGroups matching a given set of criteria. 6175 ''' 6176 deadline = None if timeout is None else time.time() + timeout 6177 req = RemoteIdentityGroupListRequest() 6178 req.meta.CopyFrom(ListRequestMetadata()) 6179 if self.parent.page_limit > 0: 6180 req.meta.limit = self.parent.page_limit 6181 if self.parent.snapshot_datetime is not None: 6182 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6183 6184 req.filter = plumbing.quote_filter_args(filter, *args) 6185 6186 def generator(svc, req): 6187 tries = 0 6188 while True: 6189 t = None if deadline is None else deadline - time.time() 6190 try: 6191 plumbing_response = svc.stub.List( 6192 req, 6193 metadata=svc.parent.get_metadata( 6194 'RemoteIdentityGroups.List', req), 6195 timeout=t) 6196 except Exception as e: 6197 if self.parent.shouldRetry(tries, e, deadline): 6198 tries += 1 6199 time.sleep( 6200 self.parent.exponentialBackoff(tries, deadline)) 6201 continue 6202 raise plumbing.convert_error_to_porcelain(e) from e 6203 tries = 0 6204 for plumbing_item in plumbing_response.remote_identity_groups: 6205 yield plumbing.convert_remote_identity_group_to_porcelain( 6206 plumbing_item) 6207 if plumbing_response.meta.next_cursor == '': 6208 break 6209 req.meta.cursor = plumbing_response.meta.next_cursor 6210 6211 return generator(self, req) 6212 6213 6214class SnapshotRemoteIdentityGroups: 6215 ''' 6216 SnapshotRemoteIdentityGroups exposes the read only methods of the RemoteIdentityGroups 6217 service for historical queries. 6218 ''' 6219 def __init__(self, remote_identity_groups): 6220 self.remote_identity_groups = remote_identity_groups 6221 6222 def get(self, id, timeout=None): 6223 ''' 6224 Get reads one RemoteIdentityGroup by ID. 6225 ''' 6226 return self.remote_identity_groups.get(id, timeout=timeout) 6227 6228 def list(self, filter, *args, timeout=None): 6229 ''' 6230 List gets a list of RemoteIdentityGroups matching a given set of criteria. 6231 ''' 6232 return self.remote_identity_groups.list(filter, *args, timeout=timeout) 6233 6234 6235class RemoteIdentityGroupsHistory: 6236 ''' 6237 RemoteIdentityGroupsHistory records all changes to the state of a RemoteIdentityGroup. 6238 See `strongdm.models.RemoteIdentityGroupHistory`. 6239 ''' 6240 def __init__(self, channel, client): 6241 self.parent = client 6242 self.stub = RemoteIdentityGroupsHistoryStub(channel) 6243 6244 def list(self, filter, *args, timeout=None): 6245 ''' 6246 List gets a list of RemoteIdentityGroupHistory records matching a given set of criteria. 6247 ''' 6248 deadline = None if timeout is None else time.time() + timeout 6249 req = RemoteIdentityGroupHistoryListRequest() 6250 req.meta.CopyFrom(ListRequestMetadata()) 6251 if self.parent.page_limit > 0: 6252 req.meta.limit = self.parent.page_limit 6253 if self.parent.snapshot_datetime is not None: 6254 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6255 6256 req.filter = plumbing.quote_filter_args(filter, *args) 6257 6258 def generator(svc, req): 6259 tries = 0 6260 while True: 6261 t = None if deadline is None else deadline - time.time() 6262 try: 6263 plumbing_response = svc.stub.List( 6264 req, 6265 metadata=svc.parent.get_metadata( 6266 'RemoteIdentityGroupsHistory.List', req), 6267 timeout=t) 6268 except Exception as e: 6269 if self.parent.shouldRetry(tries, e, deadline): 6270 tries += 1 6271 time.sleep( 6272 self.parent.exponentialBackoff(tries, deadline)) 6273 continue 6274 raise plumbing.convert_error_to_porcelain(e) from e 6275 tries = 0 6276 for plumbing_item in plumbing_response.history: 6277 yield plumbing.convert_remote_identity_group_history_to_porcelain( 6278 plumbing_item) 6279 if plumbing_response.meta.next_cursor == '': 6280 break 6281 req.meta.cursor = plumbing_response.meta.next_cursor 6282 6283 return generator(self, req) 6284 6285 6286class Replays: 6287 ''' 6288 A Replay captures the data transferred over a long-running SSH, RDP, or Kubernetes interactive session 6289 (otherwise referred to as a query). The Replays service is read-only. 6290 See `strongdm.models.ReplayChunk`. 6291 ''' 6292 def __init__(self, channel, client): 6293 self.parent = client 6294 self.stub = ReplaysStub(channel) 6295 6296 def list(self, filter, *args, timeout=None): 6297 ''' 6298 List gets a list of ReplayChunks for the Query ID specified by the filter criteria. 6299 ''' 6300 deadline = None if timeout is None else time.time() + timeout 6301 req = ReplayListRequest() 6302 req.meta.CopyFrom(ListRequestMetadata()) 6303 if self.parent.page_limit > 0: 6304 req.meta.limit = self.parent.page_limit 6305 if self.parent.snapshot_datetime is not None: 6306 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6307 6308 req.filter = plumbing.quote_filter_args(filter, *args) 6309 6310 def generator(svc, req): 6311 tries = 0 6312 while True: 6313 t = None if deadline is None else deadline - time.time() 6314 try: 6315 plumbing_response = svc.stub.List( 6316 req, 6317 metadata=svc.parent.get_metadata('Replays.List', req), 6318 timeout=t) 6319 except Exception as e: 6320 if self.parent.shouldRetry(tries, e, deadline): 6321 tries += 1 6322 time.sleep( 6323 self.parent.exponentialBackoff(tries, deadline)) 6324 continue 6325 raise plumbing.convert_error_to_porcelain(e) from e 6326 tries = 0 6327 for plumbing_item in plumbing_response.chunks: 6328 yield plumbing.convert_replay_chunk_to_porcelain( 6329 plumbing_item) 6330 if plumbing_response.meta.next_cursor == '': 6331 break 6332 req.meta.cursor = plumbing_response.meta.next_cursor 6333 6334 return generator(self, req) 6335 6336 6337class Resources: 6338 ''' 6339 Resources are databases, servers, clusters, websites, or clouds that strongDM 6340 delegates access to. 6341 See: 6342 `strongdm.models.Aerospike` 6343 `strongdm.models.AKS` 6344 `strongdm.models.AKSBasicAuth` 6345 `strongdm.models.AKSServiceAccount` 6346 `strongdm.models.AKSServiceAccountUserImpersonation` 6347 `strongdm.models.AKSUserImpersonation` 6348 `strongdm.models.AmazonEKS` 6349 `strongdm.models.AmazonEKSInstanceProfile` 6350 `strongdm.models.AmazonEKSInstanceProfileUserImpersonation` 6351 `strongdm.models.AmazonEKSUserImpersonation` 6352 `strongdm.models.AmazonES` 6353 `strongdm.models.AmazonESIAM` 6354 `strongdm.models.AmazonMQAMQP091` 6355 `strongdm.models.AMQP` 6356 `strongdm.models.Athena` 6357 `strongdm.models.AthenaIAM` 6358 `strongdm.models.AuroraMysql` 6359 `strongdm.models.AuroraMysqlIAM` 6360 `strongdm.models.AuroraPostgres` 6361 `strongdm.models.AuroraPostgresIAM` 6362 `strongdm.models.AWS` 6363 `strongdm.models.AWSConsole` 6364 `strongdm.models.AWSConsoleStaticKeyPair` 6365 `strongdm.models.AWSInstanceProfile` 6366 `strongdm.models.Azure` 6367 `strongdm.models.AzureCertificate` 6368 `strongdm.models.AzureMysql` 6369 `strongdm.models.AzureMysqlManagedIdentity` 6370 `strongdm.models.AzurePostgres` 6371 `strongdm.models.AzurePostgresManagedIdentity` 6372 `strongdm.models.BigQuery` 6373 `strongdm.models.Cassandra` 6374 `strongdm.models.Citus` 6375 `strongdm.models.ClickHouseHTTP` 6376 `strongdm.models.ClickHouseMySQL` 6377 `strongdm.models.ClickHouseTCP` 6378 `strongdm.models.Clustrix` 6379 `strongdm.models.Cockroach` 6380 `strongdm.models.CouchbaseDatabase` 6381 `strongdm.models.CouchbaseWebUI` 6382 `strongdm.models.DB2I` 6383 `strongdm.models.DB2LUW` 6384 `strongdm.models.DocumentDBHost` 6385 `strongdm.models.DocumentDBHostIAM` 6386 `strongdm.models.DocumentDBReplicaSet` 6387 `strongdm.models.DocumentDBReplicaSetIAM` 6388 `strongdm.models.Druid` 6389 `strongdm.models.DynamoDB` 6390 `strongdm.models.DynamoDBIAM` 6391 `strongdm.models.Elastic` 6392 `strongdm.models.ElasticacheRedis` 6393 `strongdm.models.ElasticacheRedisIAM` 6394 `strongdm.models.EntraID` 6395 `strongdm.models.GCP` 6396 `strongdm.models.GCPConsole` 6397 `strongdm.models.GCPWIF` 6398 `strongdm.models.GoogleGKE` 6399 `strongdm.models.GoogleGKEUserImpersonation` 6400 `strongdm.models.GoogleSpanner` 6401 `strongdm.models.Greenplum` 6402 `strongdm.models.HTTPAuth` 6403 `strongdm.models.HTTPBasicAuth` 6404 `strongdm.models.HTTPNoAuth` 6405 `strongdm.models.Kubernetes` 6406 `strongdm.models.KubernetesBasicAuth` 6407 `strongdm.models.KubernetesPodIdentity` 6408 `strongdm.models.KubernetesServiceAccount` 6409 `strongdm.models.KubernetesServiceAccountUserImpersonation` 6410 `strongdm.models.KubernetesUserImpersonation` 6411 `strongdm.models.Maria` 6412 `strongdm.models.MCP` 6413 `strongdm.models.Memcached` 6414 `strongdm.models.Memsql` 6415 `strongdm.models.MongoHost` 6416 `strongdm.models.MongoLegacyHost` 6417 `strongdm.models.MongoLegacyReplicaset` 6418 `strongdm.models.MongoReplicaSet` 6419 `strongdm.models.MongoShardedCluster` 6420 `strongdm.models.MTLSMysql` 6421 `strongdm.models.MTLSPostgres` 6422 `strongdm.models.Mysql` 6423 `strongdm.models.Neptune` 6424 `strongdm.models.NeptuneIAM` 6425 `strongdm.models.OktaGroups` 6426 `strongdm.models.Oracle` 6427 `strongdm.models.OracleNNE` 6428 `strongdm.models.Postgres` 6429 `strongdm.models.Presto` 6430 `strongdm.models.RabbitMQAMQP091` 6431 `strongdm.models.RawTCP` 6432 `strongdm.models.RDP` 6433 `strongdm.models.RDPCert` 6434 `strongdm.models.RDSPostgresIAM` 6435 `strongdm.models.Redis` 6436 `strongdm.models.RedisCluster` 6437 `strongdm.models.Redshift` 6438 `strongdm.models.RedshiftIAM` 6439 `strongdm.models.RedshiftServerlessIAM` 6440 `strongdm.models.SingleStore` 6441 `strongdm.models.Snowflake` 6442 `strongdm.models.Snowsight` 6443 `strongdm.models.SQLServer` 6444 `strongdm.models.SQLServerAzureAD` 6445 `strongdm.models.SQLServerKerberosAD` 6446 `strongdm.models.SSH` 6447 `strongdm.models.SSHCert` 6448 `strongdm.models.SSHCustomerKey` 6449 `strongdm.models.SSHPassword` 6450 `strongdm.models.Sybase` 6451 `strongdm.models.SybaseIQ` 6452 `strongdm.models.Teradata` 6453 `strongdm.models.Trino` 6454 `strongdm.models.Vertica` 6455 ''' 6456 def __init__(self, channel, client): 6457 self.parent = client 6458 self.stub = ResourcesStub(channel) 6459 6460 def enumerate_tags(self, filter, *args, timeout=None): 6461 ''' 6462 EnumerateTags gets a list of the filter matching tags. 6463 ''' 6464 deadline = None if timeout is None else time.time() + timeout 6465 req = EnumerateTagsRequest() 6466 req.meta.CopyFrom(ListRequestMetadata()) 6467 if self.parent.page_limit > 0: 6468 req.meta.limit = self.parent.page_limit 6469 if self.parent.snapshot_datetime is not None: 6470 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6471 6472 req.filter = plumbing.quote_filter_args(filter, *args) 6473 6474 def generator(svc, req): 6475 tries = 0 6476 while True: 6477 t = None if deadline is None else deadline - time.time() 6478 try: 6479 plumbing_response = svc.stub.EnumerateTags( 6480 req, 6481 metadata=svc.parent.get_metadata( 6482 'Resources.EnumerateTags', req), 6483 timeout=t) 6484 except Exception as e: 6485 if self.parent.shouldRetry(tries, e, deadline): 6486 tries += 1 6487 time.sleep( 6488 self.parent.exponentialBackoff(tries, deadline)) 6489 continue 6490 raise plumbing.convert_error_to_porcelain(e) from e 6491 tries = 0 6492 for plumbing_item in plumbing_response.matches: 6493 yield plumbing.convert_tag_to_porcelain(plumbing_item) 6494 if plumbing_response.meta.next_cursor == '': 6495 break 6496 req.meta.cursor = plumbing_response.meta.next_cursor 6497 6498 return generator(self, req) 6499 6500 def create(self, resource, timeout=None): 6501 ''' 6502 Create registers a new Resource. 6503 ''' 6504 deadline = None if timeout is None else time.time() + timeout 6505 req = ResourceCreateRequest() 6506 6507 if resource is not None: 6508 req.resource.CopyFrom( 6509 plumbing.convert_resource_to_plumbing(resource)) 6510 tries = 0 6511 plumbing_response = None 6512 while True: 6513 t = None if deadline is None else deadline - time.time() 6514 try: 6515 plumbing_response = self.stub.Create( 6516 req, 6517 metadata=self.parent.get_metadata('Resources.Create', req), 6518 timeout=t) 6519 except Exception as e: 6520 if self.parent.shouldRetry(tries, e, deadline): 6521 tries += 1 6522 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6523 continue 6524 raise plumbing.convert_error_to_porcelain(e) from e 6525 break 6526 6527 resp = models.ResourceCreateResponse() 6528 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 6529 plumbing_response.meta) 6530 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6531 plumbing_response.rate_limit) 6532 resp.resource = plumbing.convert_resource_to_porcelain( 6533 plumbing_response.resource) 6534 return resp 6535 6536 def get(self, id, timeout=None): 6537 ''' 6538 Get reads one Resource by ID. 6539 ''' 6540 deadline = None if timeout is None else time.time() + timeout 6541 req = ResourceGetRequest() 6542 if self.parent.snapshot_datetime is not None: 6543 req.meta.CopyFrom(GetRequestMetadata()) 6544 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6545 6546 req.id = (id) 6547 tries = 0 6548 plumbing_response = None 6549 while True: 6550 t = None if deadline is None else deadline - time.time() 6551 try: 6552 plumbing_response = self.stub.Get( 6553 req, 6554 metadata=self.parent.get_metadata('Resources.Get', req), 6555 timeout=t) 6556 except Exception as e: 6557 if self.parent.shouldRetry(tries, e, deadline): 6558 tries += 1 6559 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6560 continue 6561 raise plumbing.convert_error_to_porcelain(e) from e 6562 break 6563 6564 resp = models.ResourceGetResponse() 6565 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 6566 plumbing_response.meta) 6567 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6568 plumbing_response.rate_limit) 6569 resp.resource = plumbing.convert_resource_to_porcelain( 6570 plumbing_response.resource) 6571 return resp 6572 6573 def update(self, resource, timeout=None): 6574 ''' 6575 Update replaces all the fields of a Resource by ID. 6576 ''' 6577 deadline = None if timeout is None else time.time() + timeout 6578 req = ResourceUpdateRequest() 6579 6580 if resource is not None: 6581 req.resource.CopyFrom( 6582 plumbing.convert_resource_to_plumbing(resource)) 6583 tries = 0 6584 plumbing_response = None 6585 while True: 6586 t = None if deadline is None else deadline - time.time() 6587 try: 6588 plumbing_response = self.stub.Update( 6589 req, 6590 metadata=self.parent.get_metadata('Resources.Update', req), 6591 timeout=t) 6592 except Exception as e: 6593 if self.parent.shouldRetry(tries, e, deadline): 6594 tries += 1 6595 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6596 continue 6597 raise plumbing.convert_error_to_porcelain(e) from e 6598 break 6599 6600 resp = models.ResourceUpdateResponse() 6601 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 6602 plumbing_response.meta) 6603 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6604 plumbing_response.rate_limit) 6605 resp.resource = plumbing.convert_resource_to_porcelain( 6606 plumbing_response.resource) 6607 return resp 6608 6609 def delete(self, id, timeout=None): 6610 ''' 6611 Delete removes a Resource by ID. 6612 ''' 6613 deadline = None if timeout is None else time.time() + timeout 6614 req = ResourceDeleteRequest() 6615 6616 req.id = (id) 6617 tries = 0 6618 plumbing_response = None 6619 while True: 6620 t = None if deadline is None else deadline - time.time() 6621 try: 6622 plumbing_response = self.stub.Delete( 6623 req, 6624 metadata=self.parent.get_metadata('Resources.Delete', req), 6625 timeout=t) 6626 except Exception as e: 6627 if self.parent.shouldRetry(tries, e, deadline): 6628 tries += 1 6629 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6630 continue 6631 raise plumbing.convert_error_to_porcelain(e) from e 6632 break 6633 6634 resp = models.ResourceDeleteResponse() 6635 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 6636 plumbing_response.meta) 6637 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6638 plumbing_response.rate_limit) 6639 return resp 6640 6641 def list(self, filter, *args, timeout=None): 6642 ''' 6643 List gets a list of Resources matching a given set of criteria. 6644 ''' 6645 deadline = None if timeout is None else time.time() + timeout 6646 req = ResourceListRequest() 6647 req.meta.CopyFrom(ListRequestMetadata()) 6648 if self.parent.page_limit > 0: 6649 req.meta.limit = self.parent.page_limit 6650 if self.parent.snapshot_datetime is not None: 6651 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6652 6653 req.filter = plumbing.quote_filter_args(filter, *args) 6654 6655 def generator(svc, req): 6656 tries = 0 6657 while True: 6658 t = None if deadline is None else deadline - time.time() 6659 try: 6660 plumbing_response = svc.stub.List( 6661 req, 6662 metadata=svc.parent.get_metadata( 6663 'Resources.List', req), 6664 timeout=t) 6665 except Exception as e: 6666 if self.parent.shouldRetry(tries, e, deadline): 6667 tries += 1 6668 time.sleep( 6669 self.parent.exponentialBackoff(tries, deadline)) 6670 continue 6671 raise plumbing.convert_error_to_porcelain(e) from e 6672 tries = 0 6673 for plumbing_item in plumbing_response.resources: 6674 yield plumbing.convert_resource_to_porcelain(plumbing_item) 6675 if plumbing_response.meta.next_cursor == '': 6676 break 6677 req.meta.cursor = plumbing_response.meta.next_cursor 6678 6679 return generator(self, req) 6680 6681 def healthcheck(self, id, timeout=None): 6682 ''' 6683 Healthcheck triggers a remote healthcheck. It may take minutes to propagate across a 6684 large network of Nodes. The call will return immediately, and the updated health of the 6685 Resource can be retrieved via Get or List. 6686 ''' 6687 deadline = None if timeout is None else time.time() + timeout 6688 req = ResourceHealthcheckRequest() 6689 6690 req.id = (id) 6691 tries = 0 6692 plumbing_response = None 6693 while True: 6694 t = None if deadline is None else deadline - time.time() 6695 try: 6696 plumbing_response = self.stub.Healthcheck( 6697 req, 6698 metadata=self.parent.get_metadata('Resources.Healthcheck', 6699 req), 6700 timeout=t) 6701 except Exception as e: 6702 if self.parent.shouldRetry(tries, e, deadline): 6703 tries += 1 6704 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6705 continue 6706 raise plumbing.convert_error_to_porcelain(e) from e 6707 break 6708 6709 resp = models.ResourceHealthcheckResponse() 6710 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 6711 plumbing_response.meta) 6712 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6713 plumbing_response.rate_limit) 6714 return resp 6715 6716 6717class SnapshotResources: 6718 ''' 6719 SnapshotResources exposes the read only methods of the Resources 6720 service for historical queries. 6721 ''' 6722 def __init__(self, resources): 6723 self.resources = resources 6724 6725 def get(self, id, timeout=None): 6726 ''' 6727 Get reads one Resource by ID. 6728 ''' 6729 return self.resources.get(id, timeout=timeout) 6730 6731 def list(self, filter, *args, timeout=None): 6732 ''' 6733 List gets a list of Resources matching a given set of criteria. 6734 ''' 6735 return self.resources.list(filter, *args, timeout=timeout) 6736 6737 6738class ResourcesHistory: 6739 ''' 6740 ResourcesHistory records all changes to the state of a Resource. 6741 See `strongdm.models.ResourceHistory`. 6742 ''' 6743 def __init__(self, channel, client): 6744 self.parent = client 6745 self.stub = ResourcesHistoryStub(channel) 6746 6747 def list(self, filter, *args, timeout=None): 6748 ''' 6749 List gets a list of ResourceHistory records matching a given set of criteria. 6750 ''' 6751 deadline = None if timeout is None else time.time() + timeout 6752 req = ResourceHistoryListRequest() 6753 req.meta.CopyFrom(ListRequestMetadata()) 6754 if self.parent.page_limit > 0: 6755 req.meta.limit = self.parent.page_limit 6756 if self.parent.snapshot_datetime is not None: 6757 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6758 6759 req.filter = plumbing.quote_filter_args(filter, *args) 6760 6761 def generator(svc, req): 6762 tries = 0 6763 while True: 6764 t = None if deadline is None else deadline - time.time() 6765 try: 6766 plumbing_response = svc.stub.List( 6767 req, 6768 metadata=svc.parent.get_metadata( 6769 'ResourcesHistory.List', req), 6770 timeout=t) 6771 except Exception as e: 6772 if self.parent.shouldRetry(tries, e, deadline): 6773 tries += 1 6774 time.sleep( 6775 self.parent.exponentialBackoff(tries, deadline)) 6776 continue 6777 raise plumbing.convert_error_to_porcelain(e) from e 6778 tries = 0 6779 for plumbing_item in plumbing_response.history: 6780 yield plumbing.convert_resource_history_to_porcelain( 6781 plumbing_item) 6782 if plumbing_response.meta.next_cursor == '': 6783 break 6784 req.meta.cursor = plumbing_response.meta.next_cursor 6785 6786 return generator(self, req) 6787 6788 6789class RoleResources: 6790 ''' 6791 RoleResources enumerates the resources to which roles have access. 6792 The RoleResources service is read-only. 6793 See `strongdm.models.RoleResource`. 6794 ''' 6795 def __init__(self, channel, client): 6796 self.parent = client 6797 self.stub = RoleResourcesStub(channel) 6798 6799 def list(self, filter, *args, timeout=None): 6800 ''' 6801 List gets a list of RoleResource records matching a given set of criteria. 6802 ''' 6803 deadline = None if timeout is None else time.time() + timeout 6804 req = RoleResourceListRequest() 6805 req.meta.CopyFrom(ListRequestMetadata()) 6806 if self.parent.page_limit > 0: 6807 req.meta.limit = self.parent.page_limit 6808 if self.parent.snapshot_datetime is not None: 6809 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6810 6811 req.filter = plumbing.quote_filter_args(filter, *args) 6812 6813 def generator(svc, req): 6814 tries = 0 6815 while True: 6816 t = None if deadline is None else deadline - time.time() 6817 try: 6818 plumbing_response = svc.stub.List( 6819 req, 6820 metadata=svc.parent.get_metadata( 6821 'RoleResources.List', req), 6822 timeout=t) 6823 except Exception as e: 6824 if self.parent.shouldRetry(tries, e, deadline): 6825 tries += 1 6826 time.sleep( 6827 self.parent.exponentialBackoff(tries, deadline)) 6828 continue 6829 raise plumbing.convert_error_to_porcelain(e) from e 6830 tries = 0 6831 for plumbing_item in plumbing_response.role_resources: 6832 yield plumbing.convert_role_resource_to_porcelain( 6833 plumbing_item) 6834 if plumbing_response.meta.next_cursor == '': 6835 break 6836 req.meta.cursor = plumbing_response.meta.next_cursor 6837 6838 return generator(self, req) 6839 6840 6841class SnapshotRoleResources: 6842 ''' 6843 SnapshotRoleResources exposes the read only methods of the RoleResources 6844 service for historical queries. 6845 ''' 6846 def __init__(self, role_resources): 6847 self.role_resources = role_resources 6848 6849 def list(self, filter, *args, timeout=None): 6850 ''' 6851 List gets a list of RoleResource records matching a given set of criteria. 6852 ''' 6853 return self.role_resources.list(filter, *args, timeout=timeout) 6854 6855 6856class RoleResourcesHistory: 6857 ''' 6858 RoleResourcesHistory records all changes to the state of a RoleResource. 6859 See `strongdm.models.RoleResourceHistory`. 6860 ''' 6861 def __init__(self, channel, client): 6862 self.parent = client 6863 self.stub = RoleResourcesHistoryStub(channel) 6864 6865 def list(self, filter, *args, timeout=None): 6866 ''' 6867 List gets a list of RoleResourceHistory records matching a given set of criteria. 6868 ''' 6869 deadline = None if timeout is None else time.time() + timeout 6870 req = RoleResourceHistoryListRequest() 6871 req.meta.CopyFrom(ListRequestMetadata()) 6872 if self.parent.page_limit > 0: 6873 req.meta.limit = self.parent.page_limit 6874 if self.parent.snapshot_datetime is not None: 6875 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6876 6877 req.filter = plumbing.quote_filter_args(filter, *args) 6878 6879 def generator(svc, req): 6880 tries = 0 6881 while True: 6882 t = None if deadline is None else deadline - time.time() 6883 try: 6884 plumbing_response = svc.stub.List( 6885 req, 6886 metadata=svc.parent.get_metadata( 6887 'RoleResourcesHistory.List', req), 6888 timeout=t) 6889 except Exception as e: 6890 if self.parent.shouldRetry(tries, e, deadline): 6891 tries += 1 6892 time.sleep( 6893 self.parent.exponentialBackoff(tries, deadline)) 6894 continue 6895 raise plumbing.convert_error_to_porcelain(e) from e 6896 tries = 0 6897 for plumbing_item in plumbing_response.history: 6898 yield plumbing.convert_role_resource_history_to_porcelain( 6899 plumbing_item) 6900 if plumbing_response.meta.next_cursor == '': 6901 break 6902 req.meta.cursor = plumbing_response.meta.next_cursor 6903 6904 return generator(self, req) 6905 6906 6907class RolesHistory: 6908 ''' 6909 RolesHistory records all changes to the state of a Role. 6910 See `strongdm.models.RoleHistory`. 6911 ''' 6912 def __init__(self, channel, client): 6913 self.parent = client 6914 self.stub = RolesHistoryStub(channel) 6915 6916 def list(self, filter, *args, timeout=None): 6917 ''' 6918 List gets a list of RoleHistory records matching a given set of criteria. 6919 ''' 6920 deadline = None if timeout is None else time.time() + timeout 6921 req = RoleHistoryListRequest() 6922 req.meta.CopyFrom(ListRequestMetadata()) 6923 if self.parent.page_limit > 0: 6924 req.meta.limit = self.parent.page_limit 6925 if self.parent.snapshot_datetime is not None: 6926 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6927 6928 req.filter = plumbing.quote_filter_args(filter, *args) 6929 6930 def generator(svc, req): 6931 tries = 0 6932 while True: 6933 t = None if deadline is None else deadline - time.time() 6934 try: 6935 plumbing_response = svc.stub.List( 6936 req, 6937 metadata=svc.parent.get_metadata( 6938 'RolesHistory.List', req), 6939 timeout=t) 6940 except Exception as e: 6941 if self.parent.shouldRetry(tries, e, deadline): 6942 tries += 1 6943 time.sleep( 6944 self.parent.exponentialBackoff(tries, deadline)) 6945 continue 6946 raise plumbing.convert_error_to_porcelain(e) from e 6947 tries = 0 6948 for plumbing_item in plumbing_response.history: 6949 yield plumbing.convert_role_history_to_porcelain( 6950 plumbing_item) 6951 if plumbing_response.meta.next_cursor == '': 6952 break 6953 req.meta.cursor = plumbing_response.meta.next_cursor 6954 6955 return generator(self, req) 6956 6957 6958class SecretStores: 6959 ''' 6960 SecretStores are servers where resource secrets (passwords, keys) are stored. 6961 See: 6962 `strongdm.models.ActiveDirectoryStore` 6963 `strongdm.models.AWSStore` 6964 `strongdm.models.AWSCertX509Store` 6965 `strongdm.models.AzureStore` 6966 `strongdm.models.CyberarkConjurStore` 6967 `strongdm.models.CyberarkPAMStore` 6968 `strongdm.models.CyberarkPAMExperimentalStore` 6969 `strongdm.models.DelineaStore` 6970 `strongdm.models.GCPStore` 6971 `strongdm.models.GCPCertX509Store` 6972 `strongdm.models.KeyfactorSSHStore` 6973 `strongdm.models.KeyfactorX509Store` 6974 `strongdm.models.StrongVaultStore` 6975 `strongdm.models.VaultAppRoleStore` 6976 `strongdm.models.VaultAppRoleCertSSHStore` 6977 `strongdm.models.VaultAppRoleCertX509Store` 6978 `strongdm.models.VaultAWSEC2Store` 6979 `strongdm.models.VaultAWSEC2CertSSHStore` 6980 `strongdm.models.VaultAWSEC2CertX509Store` 6981 `strongdm.models.VaultAWSIAMStore` 6982 `strongdm.models.VaultAWSIAMCertSSHStore` 6983 `strongdm.models.VaultAWSIAMCertX509Store` 6984 `strongdm.models.VaultTLSStore` 6985 `strongdm.models.VaultTLSCertSSHStore` 6986 `strongdm.models.VaultTLSCertX509Store` 6987 `strongdm.models.VaultTokenStore` 6988 `strongdm.models.VaultTokenCertSSHStore` 6989 `strongdm.models.VaultTokenCertX509Store` 6990 ''' 6991 def __init__(self, channel, client): 6992 self.parent = client 6993 self.stub = SecretStoresStub(channel) 6994 6995 def create(self, secret_store, timeout=None): 6996 deadline = None if timeout is None else time.time() + timeout 6997 req = SecretStoreCreateRequest() 6998 6999 if secret_store is not None: 7000 req.secret_store.CopyFrom( 7001 plumbing.convert_secret_store_to_plumbing(secret_store)) 7002 tries = 0 7003 plumbing_response = None 7004 while True: 7005 t = None if deadline is None else deadline - time.time() 7006 try: 7007 plumbing_response = self.stub.Create( 7008 req, 7009 metadata=self.parent.get_metadata('SecretStores.Create', 7010 req), 7011 timeout=t) 7012 except Exception as e: 7013 if self.parent.shouldRetry(tries, e, deadline): 7014 tries += 1 7015 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7016 continue 7017 raise plumbing.convert_error_to_porcelain(e) from e 7018 break 7019 7020 resp = models.SecretStoreCreateResponse() 7021 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 7022 plumbing_response.meta) 7023 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7024 plumbing_response.rate_limit) 7025 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 7026 plumbing_response.secret_store) 7027 return resp 7028 7029 def get(self, id, timeout=None): 7030 ''' 7031 Get reads one SecretStore by ID. 7032 ''' 7033 deadline = None if timeout is None else time.time() + timeout 7034 req = SecretStoreGetRequest() 7035 if self.parent.snapshot_datetime is not None: 7036 req.meta.CopyFrom(GetRequestMetadata()) 7037 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7038 7039 req.id = (id) 7040 tries = 0 7041 plumbing_response = None 7042 while True: 7043 t = None if deadline is None else deadline - time.time() 7044 try: 7045 plumbing_response = self.stub.Get( 7046 req, 7047 metadata=self.parent.get_metadata('SecretStores.Get', req), 7048 timeout=t) 7049 except Exception as e: 7050 if self.parent.shouldRetry(tries, e, deadline): 7051 tries += 1 7052 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7053 continue 7054 raise plumbing.convert_error_to_porcelain(e) from e 7055 break 7056 7057 resp = models.SecretStoreGetResponse() 7058 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 7059 plumbing_response.meta) 7060 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7061 plumbing_response.rate_limit) 7062 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 7063 plumbing_response.secret_store) 7064 return resp 7065 7066 def update(self, secret_store, timeout=None): 7067 ''' 7068 Update replaces all the fields of a SecretStore by ID. 7069 ''' 7070 deadline = None if timeout is None else time.time() + timeout 7071 req = SecretStoreUpdateRequest() 7072 7073 if secret_store is not None: 7074 req.secret_store.CopyFrom( 7075 plumbing.convert_secret_store_to_plumbing(secret_store)) 7076 tries = 0 7077 plumbing_response = None 7078 while True: 7079 t = None if deadline is None else deadline - time.time() 7080 try: 7081 plumbing_response = self.stub.Update( 7082 req, 7083 metadata=self.parent.get_metadata('SecretStores.Update', 7084 req), 7085 timeout=t) 7086 except Exception as e: 7087 if self.parent.shouldRetry(tries, e, deadline): 7088 tries += 1 7089 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7090 continue 7091 raise plumbing.convert_error_to_porcelain(e) from e 7092 break 7093 7094 resp = models.SecretStoreUpdateResponse() 7095 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 7096 plumbing_response.meta) 7097 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7098 plumbing_response.rate_limit) 7099 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 7100 plumbing_response.secret_store) 7101 return resp 7102 7103 def delete(self, id, timeout=None): 7104 ''' 7105 Delete removes a SecretStore by ID. 7106 ''' 7107 deadline = None if timeout is None else time.time() + timeout 7108 req = SecretStoreDeleteRequest() 7109 7110 req.id = (id) 7111 tries = 0 7112 plumbing_response = None 7113 while True: 7114 t = None if deadline is None else deadline - time.time() 7115 try: 7116 plumbing_response = self.stub.Delete( 7117 req, 7118 metadata=self.parent.get_metadata('SecretStores.Delete', 7119 req), 7120 timeout=t) 7121 except Exception as e: 7122 if self.parent.shouldRetry(tries, e, deadline): 7123 tries += 1 7124 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7125 continue 7126 raise plumbing.convert_error_to_porcelain(e) from e 7127 break 7128 7129 resp = models.SecretStoreDeleteResponse() 7130 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 7131 plumbing_response.meta) 7132 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7133 plumbing_response.rate_limit) 7134 return resp 7135 7136 def list(self, filter, *args, timeout=None): 7137 ''' 7138 List gets a list of SecretStores matching a given set of criteria. 7139 ''' 7140 deadline = None if timeout is None else time.time() + timeout 7141 req = SecretStoreListRequest() 7142 req.meta.CopyFrom(ListRequestMetadata()) 7143 if self.parent.page_limit > 0: 7144 req.meta.limit = self.parent.page_limit 7145 if self.parent.snapshot_datetime is not None: 7146 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7147 7148 req.filter = plumbing.quote_filter_args(filter, *args) 7149 7150 def generator(svc, req): 7151 tries = 0 7152 while True: 7153 t = None if deadline is None else deadline - time.time() 7154 try: 7155 plumbing_response = svc.stub.List( 7156 req, 7157 metadata=svc.parent.get_metadata( 7158 'SecretStores.List', req), 7159 timeout=t) 7160 except Exception as e: 7161 if self.parent.shouldRetry(tries, e, deadline): 7162 tries += 1 7163 time.sleep( 7164 self.parent.exponentialBackoff(tries, deadline)) 7165 continue 7166 raise plumbing.convert_error_to_porcelain(e) from e 7167 tries = 0 7168 for plumbing_item in plumbing_response.secret_stores: 7169 yield plumbing.convert_secret_store_to_porcelain( 7170 plumbing_item) 7171 if plumbing_response.meta.next_cursor == '': 7172 break 7173 req.meta.cursor = plumbing_response.meta.next_cursor 7174 7175 return generator(self, req) 7176 7177 7178class SnapshotSecretStores: 7179 ''' 7180 SnapshotSecretStores exposes the read only methods of the SecretStores 7181 service for historical queries. 7182 ''' 7183 def __init__(self, secret_stores): 7184 self.secret_stores = secret_stores 7185 7186 def get(self, id, timeout=None): 7187 ''' 7188 Get reads one SecretStore by ID. 7189 ''' 7190 return self.secret_stores.get(id, timeout=timeout) 7191 7192 def list(self, filter, *args, timeout=None): 7193 ''' 7194 List gets a list of SecretStores matching a given set of criteria. 7195 ''' 7196 return self.secret_stores.list(filter, *args, timeout=timeout) 7197 7198 7199class SecretEngines: 7200 ''' 7201 7202 See: 7203 `strongdm.models.ActiveDirectoryEngine` 7204 `strongdm.models.KeyValueEngine` 7205 `strongdm.models.MysqlEngine` 7206 `strongdm.models.PostgresEngine` 7207 `strongdm.models.SqlserverEngine` 7208 ''' 7209 def __init__(self, channel, client): 7210 self.parent = client 7211 self.stub = SecretEnginesStub(channel) 7212 7213 def list(self, filter, *args, timeout=None): 7214 ''' 7215 List returns a list of Secret Engines 7216 ''' 7217 deadline = None if timeout is None else time.time() + timeout 7218 req = SecretEngineListRequest() 7219 req.meta.CopyFrom(ListRequestMetadata()) 7220 if self.parent.page_limit > 0: 7221 req.meta.limit = self.parent.page_limit 7222 if self.parent.snapshot_datetime is not None: 7223 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7224 7225 req.filter = plumbing.quote_filter_args(filter, *args) 7226 7227 def generator(svc, req): 7228 tries = 0 7229 while True: 7230 t = None if deadline is None else deadline - time.time() 7231 try: 7232 plumbing_response = svc.stub.List( 7233 req, 7234 metadata=svc.parent.get_metadata( 7235 'SecretEngines.List', req), 7236 timeout=t) 7237 except Exception as e: 7238 if self.parent.shouldRetry(tries, e, deadline): 7239 tries += 1 7240 time.sleep( 7241 self.parent.exponentialBackoff(tries, deadline)) 7242 continue 7243 raise plumbing.convert_error_to_porcelain(e) from e 7244 tries = 0 7245 for plumbing_item in plumbing_response.secret_engines: 7246 yield plumbing.convert_secret_engine_to_porcelain( 7247 plumbing_item) 7248 if plumbing_response.meta.next_cursor == '': 7249 break 7250 req.meta.cursor = plumbing_response.meta.next_cursor 7251 7252 return generator(self, req) 7253 7254 def get(self, id, timeout=None): 7255 ''' 7256 Get returns a secret engine details 7257 ''' 7258 deadline = None if timeout is None else time.time() + timeout 7259 req = SecretEngineGetRequest() 7260 if self.parent.snapshot_datetime is not None: 7261 req.meta.CopyFrom(GetRequestMetadata()) 7262 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7263 7264 req.id = (id) 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.Get( 7271 req, 7272 metadata=self.parent.get_metadata('SecretEngines.Get', 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.SecretEngineGetResponse() 7284 resp.meta = plumbing.convert_get_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_engine = plumbing.convert_secret_engine_to_porcelain( 7289 plumbing_response.secret_engine) 7290 return resp 7291 7292 def create(self, secret_engine, timeout=None): 7293 ''' 7294 Create creates a secret engine 7295 ''' 7296 deadline = None if timeout is None else time.time() + timeout 7297 req = SecretEngineCreateRequest() 7298 7299 if secret_engine is not None: 7300 req.secret_engine.CopyFrom( 7301 plumbing.convert_secret_engine_to_plumbing(secret_engine)) 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.Create( 7308 req, 7309 metadata=self.parent.get_metadata('SecretEngines.Create', 7310 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.SecretEngineCreateResponse() 7321 resp.meta = plumbing.convert_create_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_engine = plumbing.convert_secret_engine_to_porcelain( 7326 plumbing_response.secret_engine) 7327 return resp 7328 7329 def update(self, secret_engine, timeout=None): 7330 ''' 7331 Update updates a secret engine 7332 ''' 7333 deadline = None if timeout is None else time.time() + timeout 7334 req = SecretEngineUpdateRequest() 7335 7336 if secret_engine is not None: 7337 req.secret_engine.CopyFrom( 7338 plumbing.convert_secret_engine_to_plumbing(secret_engine)) 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('SecretEngines.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.SecretEngineUpdateResponse() 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_engine = plumbing.convert_secret_engine_to_porcelain( 7363 plumbing_response.secret_engine) 7364 return resp 7365 7366 def delete(self, id, timeout=None): 7367 ''' 7368 Delete deletes a secret engine 7369 ''' 7370 deadline = None if timeout is None else time.time() + timeout 7371 req = SecretEngineDeleteRequest() 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('SecretEngines.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.SecretEngineDeleteResponse() 7393 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7394 plumbing_response.rate_limit) 7395 return resp 7396 7397 def list_secret_stores(self, filter, *args, timeout=None): 7398 ''' 7399 ListSecretStores returns a list of Secret Stores that can be used as a backing store 7400 for Secret Engine 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.ListSecretStores( 7418 req, 7419 metadata=svc.parent.get_metadata( 7420 'SecretEngines.ListSecretStores', 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 def generate_keys(self, secret_engine_id, timeout=None): 7440 ''' 7441 GenerateKeys generates a private key, stores it in a secret store and stores a public key in a secret engine 7442 ''' 7443 deadline = None if timeout is None else time.time() + timeout 7444 req = GenerateKeysRequest() 7445 7446 req.secret_engine_id = (secret_engine_id) 7447 tries = 0 7448 plumbing_response = None 7449 while True: 7450 t = None if deadline is None else deadline - time.time() 7451 try: 7452 plumbing_response = self.stub.GenerateKeys( 7453 req, 7454 metadata=self.parent.get_metadata( 7455 'SecretEngines.GenerateKeys', req), 7456 timeout=t) 7457 except Exception as e: 7458 if self.parent.shouldRetry(tries, e, deadline): 7459 tries += 1 7460 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7461 continue 7462 raise plumbing.convert_error_to_porcelain(e) from e 7463 break 7464 7465 resp = models.GenerateKeysResponse() 7466 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7467 plumbing_response.rate_limit) 7468 return resp 7469 7470 def healthcheck(self, secret_engine_id, timeout=None): 7471 ''' 7472 Healthcheck triggers a healthcheck for all nodes serving a secret engine 7473 ''' 7474 deadline = None if timeout is None else time.time() + timeout 7475 req = HealthcheckRequest() 7476 7477 req.secret_engine_id = (secret_engine_id) 7478 tries = 0 7479 plumbing_response = None 7480 while True: 7481 t = None if deadline is None else deadline - time.time() 7482 try: 7483 plumbing_response = self.stub.Healthcheck( 7484 req, 7485 metadata=self.parent.get_metadata( 7486 'SecretEngines.Healthcheck', req), 7487 timeout=t) 7488 except Exception as e: 7489 if self.parent.shouldRetry(tries, e, deadline): 7490 tries += 1 7491 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7492 continue 7493 raise plumbing.convert_error_to_porcelain(e) from e 7494 break 7495 7496 resp = models.HealthcheckResponse() 7497 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7498 plumbing_response.rate_limit) 7499 resp.status = plumbing.convert_repeated_healthcheck_status_to_porcelain( 7500 plumbing_response.status) 7501 return resp 7502 7503 def rotate(self, id, password_policy, timeout=None): 7504 ''' 7505 Rotate rotates secret engine's credentials 7506 ''' 7507 deadline = None if timeout is None else time.time() + timeout 7508 req = SecretEngineRotateRequest() 7509 7510 req.id = (id) 7511 if password_policy is not None: 7512 req.password_policy.CopyFrom( 7513 plumbing.convert_secret_engine_password_policy_to_plumbing( 7514 password_policy)) 7515 tries = 0 7516 plumbing_response = None 7517 while True: 7518 t = None if deadline is None else deadline - time.time() 7519 try: 7520 plumbing_response = self.stub.Rotate( 7521 req, 7522 metadata=self.parent.get_metadata('SecretEngines.Rotate', 7523 req), 7524 timeout=t) 7525 except Exception as e: 7526 if self.parent.shouldRetry(tries, e, deadline): 7527 tries += 1 7528 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7529 continue 7530 raise plumbing.convert_error_to_porcelain(e) from e 7531 break 7532 7533 resp = models.SecretEngineRotateResponse() 7534 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7535 plumbing_response.rate_limit) 7536 return resp 7537 7538 7539class SecretStoreHealths: 7540 ''' 7541 SecretStoreHealths exposes health states for secret stores. 7542 See `strongdm.models.SecretStoreHealth`. 7543 ''' 7544 def __init__(self, channel, client): 7545 self.parent = client 7546 self.stub = SecretStoreHealthsStub(channel) 7547 7548 def list(self, filter, *args, timeout=None): 7549 ''' 7550 List reports the health status of node to secret store pairs. 7551 ''' 7552 deadline = None if timeout is None else time.time() + timeout 7553 req = SecretStoreHealthListRequest() 7554 req.meta.CopyFrom(ListRequestMetadata()) 7555 if self.parent.page_limit > 0: 7556 req.meta.limit = self.parent.page_limit 7557 if self.parent.snapshot_datetime is not None: 7558 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7559 7560 req.filter = plumbing.quote_filter_args(filter, *args) 7561 7562 def generator(svc, req): 7563 tries = 0 7564 while True: 7565 t = None if deadline is None else deadline - time.time() 7566 try: 7567 plumbing_response = svc.stub.List( 7568 req, 7569 metadata=svc.parent.get_metadata( 7570 'SecretStoreHealths.List', req), 7571 timeout=t) 7572 except Exception as e: 7573 if self.parent.shouldRetry(tries, e, deadline): 7574 tries += 1 7575 time.sleep( 7576 self.parent.exponentialBackoff(tries, deadline)) 7577 continue 7578 raise plumbing.convert_error_to_porcelain(e) from e 7579 tries = 0 7580 for plumbing_item in plumbing_response.secret_store_healths: 7581 yield plumbing.convert_secret_store_health_to_porcelain( 7582 plumbing_item) 7583 if plumbing_response.meta.next_cursor == '': 7584 break 7585 req.meta.cursor = plumbing_response.meta.next_cursor 7586 7587 return generator(self, req) 7588 7589 def healthcheck(self, secret_store_id, timeout=None): 7590 ''' 7591 Healthcheck triggers a remote healthcheck request for a secret store. It may take minutes 7592 to propagate across a large network of Nodes. The call will return immediately, and the 7593 updated health of the Secret Store can be retrieved via List. 7594 ''' 7595 deadline = None if timeout is None else time.time() + timeout 7596 req = SecretStoreHealthcheckRequest() 7597 7598 req.secret_store_id = (secret_store_id) 7599 tries = 0 7600 plumbing_response = None 7601 while True: 7602 t = None if deadline is None else deadline - time.time() 7603 try: 7604 plumbing_response = self.stub.Healthcheck( 7605 req, 7606 metadata=self.parent.get_metadata( 7607 'SecretStoreHealths.Healthcheck', req), 7608 timeout=t) 7609 except Exception as e: 7610 if self.parent.shouldRetry(tries, e, deadline): 7611 tries += 1 7612 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7613 continue 7614 raise plumbing.convert_error_to_porcelain(e) from e 7615 break 7616 7617 resp = models.SecretStoreHealthcheckResponse() 7618 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7619 plumbing_response.rate_limit) 7620 return resp 7621 7622 7623class SecretStoresHistory: 7624 ''' 7625 SecretStoresHistory records all changes to the state of a SecretStore. 7626 See `strongdm.models.SecretStoreHistory`. 7627 ''' 7628 def __init__(self, channel, client): 7629 self.parent = client 7630 self.stub = SecretStoresHistoryStub(channel) 7631 7632 def list(self, filter, *args, timeout=None): 7633 ''' 7634 List gets a list of SecretStoreHistory records matching a given set of criteria. 7635 ''' 7636 deadline = None if timeout is None else time.time() + timeout 7637 req = SecretStoreHistoryListRequest() 7638 req.meta.CopyFrom(ListRequestMetadata()) 7639 if self.parent.page_limit > 0: 7640 req.meta.limit = self.parent.page_limit 7641 if self.parent.snapshot_datetime is not None: 7642 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7643 7644 req.filter = plumbing.quote_filter_args(filter, *args) 7645 7646 def generator(svc, req): 7647 tries = 0 7648 while True: 7649 t = None if deadline is None else deadline - time.time() 7650 try: 7651 plumbing_response = svc.stub.List( 7652 req, 7653 metadata=svc.parent.get_metadata( 7654 'SecretStoresHistory.List', req), 7655 timeout=t) 7656 except Exception as e: 7657 if self.parent.shouldRetry(tries, e, deadline): 7658 tries += 1 7659 time.sleep( 7660 self.parent.exponentialBackoff(tries, deadline)) 7661 continue 7662 raise plumbing.convert_error_to_porcelain(e) from e 7663 tries = 0 7664 for plumbing_item in plumbing_response.history: 7665 yield plumbing.convert_secret_store_history_to_porcelain( 7666 plumbing_item) 7667 if plumbing_response.meta.next_cursor == '': 7668 break 7669 req.meta.cursor = plumbing_response.meta.next_cursor 7670 7671 return generator(self, req) 7672 7673 7674class WorkflowApprovers: 7675 ''' 7676 WorkflowApprovers is an account or a role with the ability to approve requests bound to a workflow. 7677 See `strongdm.models.WorkflowApprover`. 7678 ''' 7679 def __init__(self, channel, client): 7680 self.parent = client 7681 self.stub = WorkflowApproversStub(channel) 7682 7683 def create(self, workflow_approver, timeout=None): 7684 ''' 7685 Create creates a new workflow approver 7686 ''' 7687 deadline = None if timeout is None else time.time() + timeout 7688 req = WorkflowApproversCreateRequest() 7689 7690 if workflow_approver is not None: 7691 req.workflow_approver.CopyFrom( 7692 plumbing.convert_workflow_approver_to_plumbing( 7693 workflow_approver)) 7694 tries = 0 7695 plumbing_response = None 7696 while True: 7697 t = None if deadline is None else deadline - time.time() 7698 try: 7699 plumbing_response = self.stub.Create( 7700 req, 7701 metadata=self.parent.get_metadata( 7702 'WorkflowApprovers.Create', req), 7703 timeout=t) 7704 except Exception as e: 7705 if self.parent.shouldRetry(tries, e, deadline): 7706 tries += 1 7707 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7708 continue 7709 raise plumbing.convert_error_to_porcelain(e) from e 7710 break 7711 7712 resp = models.WorkflowApproversCreateResponse() 7713 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7714 plumbing_response.rate_limit) 7715 resp.workflow_approver = plumbing.convert_workflow_approver_to_porcelain( 7716 plumbing_response.workflow_approver) 7717 return resp 7718 7719 def get(self, id, timeout=None): 7720 ''' 7721 Get reads one workflow approver by ID. 7722 ''' 7723 deadline = None if timeout is None else time.time() + timeout 7724 req = WorkflowApproverGetRequest() 7725 if self.parent.snapshot_datetime is not None: 7726 req.meta.CopyFrom(GetRequestMetadata()) 7727 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7728 7729 req.id = (id) 7730 tries = 0 7731 plumbing_response = None 7732 while True: 7733 t = None if deadline is None else deadline - time.time() 7734 try: 7735 plumbing_response = self.stub.Get( 7736 req, 7737 metadata=self.parent.get_metadata('WorkflowApprovers.Get', 7738 req), 7739 timeout=t) 7740 except Exception as e: 7741 if self.parent.shouldRetry(tries, e, deadline): 7742 tries += 1 7743 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7744 continue 7745 raise plumbing.convert_error_to_porcelain(e) from e 7746 break 7747 7748 resp = models.WorkflowApproverGetResponse() 7749 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 7750 plumbing_response.meta) 7751 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7752 plumbing_response.rate_limit) 7753 resp.workflow_approver = plumbing.convert_workflow_approver_to_porcelain( 7754 plumbing_response.workflow_approver) 7755 return resp 7756 7757 def delete(self, id, timeout=None): 7758 ''' 7759 Delete deletes a workflow approver 7760 ''' 7761 deadline = None if timeout is None else time.time() + timeout 7762 req = WorkflowApproversDeleteRequest() 7763 7764 req.id = (id) 7765 tries = 0 7766 plumbing_response = None 7767 while True: 7768 t = None if deadline is None else deadline - time.time() 7769 try: 7770 plumbing_response = self.stub.Delete( 7771 req, 7772 metadata=self.parent.get_metadata( 7773 'WorkflowApprovers.Delete', req), 7774 timeout=t) 7775 except Exception as e: 7776 if self.parent.shouldRetry(tries, e, deadline): 7777 tries += 1 7778 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7779 continue 7780 raise plumbing.convert_error_to_porcelain(e) from e 7781 break 7782 7783 resp = models.WorkflowApproversDeleteResponse() 7784 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7785 plumbing_response.rate_limit) 7786 return resp 7787 7788 def list(self, filter, *args, timeout=None): 7789 ''' 7790 Lists existing workflow approvers. 7791 ''' 7792 deadline = None if timeout is None else time.time() + timeout 7793 req = WorkflowApproversListRequest() 7794 req.meta.CopyFrom(ListRequestMetadata()) 7795 if self.parent.page_limit > 0: 7796 req.meta.limit = self.parent.page_limit 7797 if self.parent.snapshot_datetime is not None: 7798 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7799 7800 req.filter = plumbing.quote_filter_args(filter, *args) 7801 7802 def generator(svc, req): 7803 tries = 0 7804 while True: 7805 t = None if deadline is None else deadline - time.time() 7806 try: 7807 plumbing_response = svc.stub.List( 7808 req, 7809 metadata=svc.parent.get_metadata( 7810 'WorkflowApprovers.List', req), 7811 timeout=t) 7812 except Exception as e: 7813 if self.parent.shouldRetry(tries, e, deadline): 7814 tries += 1 7815 time.sleep( 7816 self.parent.exponentialBackoff(tries, deadline)) 7817 continue 7818 raise plumbing.convert_error_to_porcelain(e) from e 7819 tries = 0 7820 for plumbing_item in plumbing_response.workflow_approvers: 7821 yield plumbing.convert_workflow_approver_to_porcelain( 7822 plumbing_item) 7823 if plumbing_response.meta.next_cursor == '': 7824 break 7825 req.meta.cursor = plumbing_response.meta.next_cursor 7826 7827 return generator(self, req) 7828 7829 7830class SnapshotWorkflowApprovers: 7831 ''' 7832 SnapshotWorkflowApprovers exposes the read only methods of the WorkflowApprovers 7833 service for historical queries. 7834 ''' 7835 def __init__(self, workflow_approvers): 7836 self.workflow_approvers = workflow_approvers 7837 7838 def get(self, id, timeout=None): 7839 ''' 7840 Get reads one workflow approver by ID. 7841 ''' 7842 return self.workflow_approvers.get(id, timeout=timeout) 7843 7844 def list(self, filter, *args, timeout=None): 7845 ''' 7846 Lists existing workflow approvers. 7847 ''' 7848 return self.workflow_approvers.list(filter, *args, timeout=timeout) 7849 7850 7851class WorkflowApproversHistory: 7852 ''' 7853 WorkflowApproversHistory provides records of all changes to the state of a WorkflowApprover. 7854 See `strongdm.models.WorkflowApproverHistory`. 7855 ''' 7856 def __init__(self, channel, client): 7857 self.parent = client 7858 self.stub = WorkflowApproversHistoryStub(channel) 7859 7860 def list(self, filter, *args, timeout=None): 7861 ''' 7862 List gets a list of WorkflowApproversHistory records matching a given set of criteria. 7863 ''' 7864 deadline = None if timeout is None else time.time() + timeout 7865 req = WorkflowApproversHistoryListRequest() 7866 req.meta.CopyFrom(ListRequestMetadata()) 7867 if self.parent.page_limit > 0: 7868 req.meta.limit = self.parent.page_limit 7869 if self.parent.snapshot_datetime is not None: 7870 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7871 7872 req.filter = plumbing.quote_filter_args(filter, *args) 7873 7874 def generator(svc, req): 7875 tries = 0 7876 while True: 7877 t = None if deadline is None else deadline - time.time() 7878 try: 7879 plumbing_response = svc.stub.List( 7880 req, 7881 metadata=svc.parent.get_metadata( 7882 'WorkflowApproversHistory.List', req), 7883 timeout=t) 7884 except Exception as e: 7885 if self.parent.shouldRetry(tries, e, deadline): 7886 tries += 1 7887 time.sleep( 7888 self.parent.exponentialBackoff(tries, deadline)) 7889 continue 7890 raise plumbing.convert_error_to_porcelain(e) from e 7891 tries = 0 7892 for plumbing_item in plumbing_response.history: 7893 yield plumbing.convert_workflow_approver_history_to_porcelain( 7894 plumbing_item) 7895 if plumbing_response.meta.next_cursor == '': 7896 break 7897 req.meta.cursor = plumbing_response.meta.next_cursor 7898 7899 return generator(self, req) 7900 7901 7902class WorkflowRoles: 7903 ''' 7904 WorkflowRole links a role to a workflow. The linked roles indicate which roles a user must be a part of 7905 to request access to a resource via the workflow. 7906 See `strongdm.models.WorkflowRole`. 7907 ''' 7908 def __init__(self, channel, client): 7909 self.parent = client 7910 self.stub = WorkflowRolesStub(channel) 7911 7912 def create(self, workflow_role, timeout=None): 7913 ''' 7914 Create creates a new workflow role 7915 ''' 7916 deadline = None if timeout is None else time.time() + timeout 7917 req = WorkflowRolesCreateRequest() 7918 7919 if workflow_role is not None: 7920 req.workflow_role.CopyFrom( 7921 plumbing.convert_workflow_role_to_plumbing(workflow_role)) 7922 tries = 0 7923 plumbing_response = None 7924 while True: 7925 t = None if deadline is None else deadline - time.time() 7926 try: 7927 plumbing_response = self.stub.Create( 7928 req, 7929 metadata=self.parent.get_metadata('WorkflowRoles.Create', 7930 req), 7931 timeout=t) 7932 except Exception as e: 7933 if self.parent.shouldRetry(tries, e, deadline): 7934 tries += 1 7935 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7936 continue 7937 raise plumbing.convert_error_to_porcelain(e) from e 7938 break 7939 7940 resp = models.WorkflowRolesCreateResponse() 7941 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7942 plumbing_response.rate_limit) 7943 resp.workflow_role = plumbing.convert_workflow_role_to_porcelain( 7944 plumbing_response.workflow_role) 7945 return resp 7946 7947 def get(self, id, timeout=None): 7948 ''' 7949 Get reads one workflow role by ID. 7950 ''' 7951 deadline = None if timeout is None else time.time() + timeout 7952 req = WorkflowRoleGetRequest() 7953 if self.parent.snapshot_datetime is not None: 7954 req.meta.CopyFrom(GetRequestMetadata()) 7955 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7956 7957 req.id = (id) 7958 tries = 0 7959 plumbing_response = None 7960 while True: 7961 t = None if deadline is None else deadline - time.time() 7962 try: 7963 plumbing_response = self.stub.Get( 7964 req, 7965 metadata=self.parent.get_metadata('WorkflowRoles.Get', 7966 req), 7967 timeout=t) 7968 except Exception as e: 7969 if self.parent.shouldRetry(tries, e, deadline): 7970 tries += 1 7971 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7972 continue 7973 raise plumbing.convert_error_to_porcelain(e) from e 7974 break 7975 7976 resp = models.WorkflowRoleGetResponse() 7977 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 7978 plumbing_response.meta) 7979 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7980 plumbing_response.rate_limit) 7981 resp.workflow_role = plumbing.convert_workflow_role_to_porcelain( 7982 plumbing_response.workflow_role) 7983 return resp 7984 7985 def delete(self, id, timeout=None): 7986 ''' 7987 Delete deletes a workflow role 7988 ''' 7989 deadline = None if timeout is None else time.time() + timeout 7990 req = WorkflowRolesDeleteRequest() 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.Delete( 7999 req, 8000 metadata=self.parent.get_metadata('WorkflowRoles.Delete', 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.WorkflowRolesDeleteResponse() 8012 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8013 plumbing_response.rate_limit) 8014 return resp 8015 8016 def list(self, filter, *args, timeout=None): 8017 ''' 8018 Lists existing workflow roles. 8019 ''' 8020 deadline = None if timeout is None else time.time() + timeout 8021 req = WorkflowRolesListRequest() 8022 req.meta.CopyFrom(ListRequestMetadata()) 8023 if self.parent.page_limit > 0: 8024 req.meta.limit = self.parent.page_limit 8025 if self.parent.snapshot_datetime is not None: 8026 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8027 8028 req.filter = plumbing.quote_filter_args(filter, *args) 8029 8030 def generator(svc, req): 8031 tries = 0 8032 while True: 8033 t = None if deadline is None else deadline - time.time() 8034 try: 8035 plumbing_response = svc.stub.List( 8036 req, 8037 metadata=svc.parent.get_metadata( 8038 'WorkflowRoles.List', req), 8039 timeout=t) 8040 except Exception as e: 8041 if self.parent.shouldRetry(tries, e, deadline): 8042 tries += 1 8043 time.sleep( 8044 self.parent.exponentialBackoff(tries, deadline)) 8045 continue 8046 raise plumbing.convert_error_to_porcelain(e) from e 8047 tries = 0 8048 for plumbing_item in plumbing_response.workflow_role: 8049 yield plumbing.convert_workflow_role_to_porcelain( 8050 plumbing_item) 8051 if plumbing_response.meta.next_cursor == '': 8052 break 8053 req.meta.cursor = plumbing_response.meta.next_cursor 8054 8055 return generator(self, req) 8056 8057 8058class SnapshotWorkflowRoles: 8059 ''' 8060 SnapshotWorkflowRoles exposes the read only methods of the WorkflowRoles 8061 service for historical queries. 8062 ''' 8063 def __init__(self, workflow_roles): 8064 self.workflow_roles = workflow_roles 8065 8066 def get(self, id, timeout=None): 8067 ''' 8068 Get reads one workflow role by ID. 8069 ''' 8070 return self.workflow_roles.get(id, timeout=timeout) 8071 8072 def list(self, filter, *args, timeout=None): 8073 ''' 8074 Lists existing workflow roles. 8075 ''' 8076 return self.workflow_roles.list(filter, *args, timeout=timeout) 8077 8078 8079class WorkflowRolesHistory: 8080 ''' 8081 WorkflowRolesHistory provides records of all changes to the state of a WorkflowRole 8082 See `strongdm.models.WorkflowRoleHistory`. 8083 ''' 8084 def __init__(self, channel, client): 8085 self.parent = client 8086 self.stub = WorkflowRolesHistoryStub(channel) 8087 8088 def list(self, filter, *args, timeout=None): 8089 ''' 8090 List gets a list of WorkflowRolesHistory records matching a given set of criteria. 8091 ''' 8092 deadline = None if timeout is None else time.time() + timeout 8093 req = WorkflowRolesHistoryListRequest() 8094 req.meta.CopyFrom(ListRequestMetadata()) 8095 if self.parent.page_limit > 0: 8096 req.meta.limit = self.parent.page_limit 8097 if self.parent.snapshot_datetime is not None: 8098 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8099 8100 req.filter = plumbing.quote_filter_args(filter, *args) 8101 8102 def generator(svc, req): 8103 tries = 0 8104 while True: 8105 t = None if deadline is None else deadline - time.time() 8106 try: 8107 plumbing_response = svc.stub.List( 8108 req, 8109 metadata=svc.parent.get_metadata( 8110 'WorkflowRolesHistory.List', req), 8111 timeout=t) 8112 except Exception as e: 8113 if self.parent.shouldRetry(tries, e, deadline): 8114 tries += 1 8115 time.sleep( 8116 self.parent.exponentialBackoff(tries, deadline)) 8117 continue 8118 raise plumbing.convert_error_to_porcelain(e) from e 8119 tries = 0 8120 for plumbing_item in plumbing_response.history: 8121 yield plumbing.convert_workflow_role_history_to_porcelain( 8122 plumbing_item) 8123 if plumbing_response.meta.next_cursor == '': 8124 break 8125 req.meta.cursor = plumbing_response.meta.next_cursor 8126 8127 return generator(self, req) 8128 8129 8130class Workflows: 8131 ''' 8132 Workflows are the collection of rules that define the resources to which access can be requested, 8133 the users that can request that access, and the mechanism for approving those requests which can either 8134 be automatic approval or a set of users authorized to approve the requests. 8135 See `strongdm.models.Workflow`. 8136 ''' 8137 def __init__(self, channel, client): 8138 self.parent = client 8139 self.stub = WorkflowsStub(channel) 8140 8141 def create(self, workflow, timeout=None): 8142 ''' 8143 Create creates a new workflow and requires a name for the workflow. 8144 ''' 8145 deadline = None if timeout is None else time.time() + timeout 8146 req = WorkflowCreateRequest() 8147 8148 if workflow is not None: 8149 req.workflow.CopyFrom( 8150 plumbing.convert_workflow_to_plumbing(workflow)) 8151 tries = 0 8152 plumbing_response = None 8153 while True: 8154 t = None if deadline is None else deadline - time.time() 8155 try: 8156 plumbing_response = self.stub.Create( 8157 req, 8158 metadata=self.parent.get_metadata('Workflows.Create', req), 8159 timeout=t) 8160 except Exception as e: 8161 if self.parent.shouldRetry(tries, e, deadline): 8162 tries += 1 8163 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8164 continue 8165 raise plumbing.convert_error_to_porcelain(e) from e 8166 break 8167 8168 resp = models.WorkflowCreateResponse() 8169 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8170 plumbing_response.rate_limit) 8171 resp.workflow = plumbing.convert_workflow_to_porcelain( 8172 plumbing_response.workflow) 8173 return resp 8174 8175 def get(self, id, timeout=None): 8176 ''' 8177 Get reads one workflow by ID. 8178 ''' 8179 deadline = None if timeout is None else time.time() + timeout 8180 req = WorkflowGetRequest() 8181 if self.parent.snapshot_datetime is not None: 8182 req.meta.CopyFrom(GetRequestMetadata()) 8183 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8184 8185 req.id = (id) 8186 tries = 0 8187 plumbing_response = None 8188 while True: 8189 t = None if deadline is None else deadline - time.time() 8190 try: 8191 plumbing_response = self.stub.Get( 8192 req, 8193 metadata=self.parent.get_metadata('Workflows.Get', 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.WorkflowGetResponse() 8204 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 8205 plumbing_response.meta) 8206 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8207 plumbing_response.rate_limit) 8208 resp.workflow = plumbing.convert_workflow_to_porcelain( 8209 plumbing_response.workflow) 8210 return resp 8211 8212 def delete(self, id, timeout=None): 8213 ''' 8214 Delete deletes an existing workflow. 8215 ''' 8216 deadline = None if timeout is None else time.time() + timeout 8217 req = WorkflowDeleteRequest() 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.Delete( 8226 req, 8227 metadata=self.parent.get_metadata('Workflows.Delete', req), 8228 timeout=t) 8229 except Exception as e: 8230 if self.parent.shouldRetry(tries, e, deadline): 8231 tries += 1 8232 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8233 continue 8234 raise plumbing.convert_error_to_porcelain(e) from e 8235 break 8236 8237 resp = models.WorkflowDeleteResponse() 8238 resp.id = (plumbing_response.id) 8239 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8240 plumbing_response.rate_limit) 8241 return resp 8242 8243 def update(self, workflow, timeout=None): 8244 ''' 8245 Update updates an existing workflow. 8246 ''' 8247 deadline = None if timeout is None else time.time() + timeout 8248 req = WorkflowUpdateRequest() 8249 8250 if workflow is not None: 8251 req.workflow.CopyFrom( 8252 plumbing.convert_workflow_to_plumbing(workflow)) 8253 tries = 0 8254 plumbing_response = None 8255 while True: 8256 t = None if deadline is None else deadline - time.time() 8257 try: 8258 plumbing_response = self.stub.Update( 8259 req, 8260 metadata=self.parent.get_metadata('Workflows.Update', req), 8261 timeout=t) 8262 except Exception as e: 8263 if self.parent.shouldRetry(tries, e, deadline): 8264 tries += 1 8265 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8266 continue 8267 raise plumbing.convert_error_to_porcelain(e) from e 8268 break 8269 8270 resp = models.WorkflowUpdateResponse() 8271 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8272 plumbing_response.rate_limit) 8273 resp.workflow = plumbing.convert_workflow_to_porcelain( 8274 plumbing_response.workflow) 8275 return resp 8276 8277 def list(self, filter, *args, timeout=None): 8278 ''' 8279 Lists existing workflows. 8280 ''' 8281 deadline = None if timeout is None else time.time() + timeout 8282 req = WorkflowListRequest() 8283 req.meta.CopyFrom(ListRequestMetadata()) 8284 if self.parent.page_limit > 0: 8285 req.meta.limit = self.parent.page_limit 8286 if self.parent.snapshot_datetime is not None: 8287 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8288 8289 req.filter = plumbing.quote_filter_args(filter, *args) 8290 8291 def generator(svc, req): 8292 tries = 0 8293 while True: 8294 t = None if deadline is None else deadline - time.time() 8295 try: 8296 plumbing_response = svc.stub.List( 8297 req, 8298 metadata=svc.parent.get_metadata( 8299 'Workflows.List', req), 8300 timeout=t) 8301 except Exception as e: 8302 if self.parent.shouldRetry(tries, e, deadline): 8303 tries += 1 8304 time.sleep( 8305 self.parent.exponentialBackoff(tries, deadline)) 8306 continue 8307 raise plumbing.convert_error_to_porcelain(e) from e 8308 tries = 0 8309 for plumbing_item in plumbing_response.workflows: 8310 yield plumbing.convert_workflow_to_porcelain(plumbing_item) 8311 if plumbing_response.meta.next_cursor == '': 8312 break 8313 req.meta.cursor = plumbing_response.meta.next_cursor 8314 8315 return generator(self, req) 8316 8317 8318class SnapshotWorkflows: 8319 ''' 8320 SnapshotWorkflows exposes the read only methods of the Workflows 8321 service for historical queries. 8322 ''' 8323 def __init__(self, workflows): 8324 self.workflows = workflows 8325 8326 def get(self, id, timeout=None): 8327 ''' 8328 Get reads one workflow by ID. 8329 ''' 8330 return self.workflows.get(id, timeout=timeout) 8331 8332 def list(self, filter, *args, timeout=None): 8333 ''' 8334 Lists existing workflows. 8335 ''' 8336 return self.workflows.list(filter, *args, timeout=timeout) 8337 8338 8339class WorkflowsHistory: 8340 ''' 8341 WorkflowsHistory provides records of all changes to the state of a Workflow. 8342 See `strongdm.models.WorkflowHistory`. 8343 ''' 8344 def __init__(self, channel, client): 8345 self.parent = client 8346 self.stub = WorkflowsHistoryStub(channel) 8347 8348 def list(self, filter, *args, timeout=None): 8349 ''' 8350 List gets a list of WorkflowHistory records matching a given set of criteria. 8351 ''' 8352 deadline = None if timeout is None else time.time() + timeout 8353 req = WorkflowHistoryListRequest() 8354 req.meta.CopyFrom(ListRequestMetadata()) 8355 if self.parent.page_limit > 0: 8356 req.meta.limit = self.parent.page_limit 8357 if self.parent.snapshot_datetime is not None: 8358 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8359 8360 req.filter = plumbing.quote_filter_args(filter, *args) 8361 8362 def generator(svc, req): 8363 tries = 0 8364 while True: 8365 t = None if deadline is None else deadline - time.time() 8366 try: 8367 plumbing_response = svc.stub.List( 8368 req, 8369 metadata=svc.parent.get_metadata( 8370 'WorkflowsHistory.List', req), 8371 timeout=t) 8372 except Exception as e: 8373 if self.parent.shouldRetry(tries, e, deadline): 8374 tries += 1 8375 time.sleep( 8376 self.parent.exponentialBackoff(tries, deadline)) 8377 continue 8378 raise plumbing.convert_error_to_porcelain(e) from e 8379 tries = 0 8380 for plumbing_item in plumbing_response.history: 8381 yield plumbing.convert_workflow_history_to_porcelain( 8382 plumbing_item) 8383 if plumbing_response.meta.next_cursor == '': 8384 break 8385 req.meta.cursor = plumbing_response.meta.next_cursor 8386 8387 return generator(self, req)
def
deprecated(func)
173def deprecated(func): 174 """This is a decorator which can be used to mark functions 175 as deprecated. It will result in a warning being emitted 176 when the function is used.""" 177 @functools.wraps(func) 178 def new_func(*args, **kwargs): 179 warnings.warn("Call to deprecated function {}.".format(func.__name__), 180 category=DeprecationWarning, 181 stacklevel=2) 182 return func(*args, **kwargs) 183 184 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:
187class AccessRequests: 188 ''' 189 AccessRequests are requests for access to a resource that may match a Workflow. 190 See `strongdm.models.AccessRequest`. 191 ''' 192 def __init__(self, channel, client): 193 self.parent = client 194 self.stub = AccessRequestsStub(channel) 195 196 def list(self, filter, *args, timeout=None): 197 ''' 198 Lists existing access requests. 199 ''' 200 deadline = None if timeout is None else time.time() + timeout 201 req = AccessRequestListRequest() 202 req.meta.CopyFrom(ListRequestMetadata()) 203 if self.parent.page_limit > 0: 204 req.meta.limit = self.parent.page_limit 205 if self.parent.snapshot_datetime is not None: 206 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 207 208 req.filter = plumbing.quote_filter_args(filter, *args) 209 210 def generator(svc, req): 211 tries = 0 212 while True: 213 t = None if deadline is None else deadline - time.time() 214 try: 215 plumbing_response = svc.stub.List( 216 req, 217 metadata=svc.parent.get_metadata( 218 'AccessRequests.List', req), 219 timeout=t) 220 except Exception as e: 221 if self.parent.shouldRetry(tries, e, deadline): 222 tries += 1 223 time.sleep( 224 self.parent.exponentialBackoff(tries, deadline)) 225 continue 226 raise plumbing.convert_error_to_porcelain(e) from e 227 tries = 0 228 for plumbing_item in plumbing_response.access_requests: 229 yield plumbing.convert_access_request_to_porcelain( 230 plumbing_item) 231 if plumbing_response.meta.next_cursor == '': 232 break 233 req.meta.cursor = plumbing_response.meta.next_cursor 234 235 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)
196 def list(self, filter, *args, timeout=None): 197 ''' 198 Lists existing access requests. 199 ''' 200 deadline = None if timeout is None else time.time() + timeout 201 req = AccessRequestListRequest() 202 req.meta.CopyFrom(ListRequestMetadata()) 203 if self.parent.page_limit > 0: 204 req.meta.limit = self.parent.page_limit 205 if self.parent.snapshot_datetime is not None: 206 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 207 208 req.filter = plumbing.quote_filter_args(filter, *args) 209 210 def generator(svc, req): 211 tries = 0 212 while True: 213 t = None if deadline is None else deadline - time.time() 214 try: 215 plumbing_response = svc.stub.List( 216 req, 217 metadata=svc.parent.get_metadata( 218 'AccessRequests.List', req), 219 timeout=t) 220 except Exception as e: 221 if self.parent.shouldRetry(tries, e, deadline): 222 tries += 1 223 time.sleep( 224 self.parent.exponentialBackoff(tries, deadline)) 225 continue 226 raise plumbing.convert_error_to_porcelain(e) from e 227 tries = 0 228 for plumbing_item in plumbing_response.access_requests: 229 yield plumbing.convert_access_request_to_porcelain( 230 plumbing_item) 231 if plumbing_response.meta.next_cursor == '': 232 break 233 req.meta.cursor = plumbing_response.meta.next_cursor 234 235 return generator(self, req)
Lists existing access requests.
class
SnapshotAccessRequests:
238class SnapshotAccessRequests: 239 ''' 240 SnapshotAccessRequests exposes the read only methods of the AccessRequests 241 service for historical queries. 242 ''' 243 def __init__(self, access_requests): 244 self.access_requests = access_requests 245 246 def list(self, filter, *args, timeout=None): 247 ''' 248 Lists existing access requests. 249 ''' 250 return self.access_requests.list(filter, *args, timeout=timeout)
SnapshotAccessRequests exposes the read only methods of the AccessRequests service for historical queries.
class
AccessRequestEventsHistory:
253class AccessRequestEventsHistory: 254 ''' 255 AccessRequestEventsHistory provides records of all changes to the state of an AccessRequest. 256 See `strongdm.models.AccessRequestEventHistory`. 257 ''' 258 def __init__(self, channel, client): 259 self.parent = client 260 self.stub = AccessRequestEventsHistoryStub(channel) 261 262 def list(self, filter, *args, timeout=None): 263 ''' 264 List gets a list of AccessRequestEventHistory records matching a given set of criteria. 265 ''' 266 deadline = None if timeout is None else time.time() + timeout 267 req = AccessRequestEventHistoryListRequest() 268 req.meta.CopyFrom(ListRequestMetadata()) 269 if self.parent.page_limit > 0: 270 req.meta.limit = self.parent.page_limit 271 if self.parent.snapshot_datetime is not None: 272 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 273 274 req.filter = plumbing.quote_filter_args(filter, *args) 275 276 def generator(svc, req): 277 tries = 0 278 while True: 279 t = None if deadline is None else deadline - time.time() 280 try: 281 plumbing_response = svc.stub.List( 282 req, 283 metadata=svc.parent.get_metadata( 284 'AccessRequestEventsHistory.List', req), 285 timeout=t) 286 except Exception as e: 287 if self.parent.shouldRetry(tries, e, deadline): 288 tries += 1 289 time.sleep( 290 self.parent.exponentialBackoff(tries, deadline)) 291 continue 292 raise plumbing.convert_error_to_porcelain(e) from e 293 tries = 0 294 for plumbing_item in plumbing_response.history: 295 yield plumbing.convert_access_request_event_history_to_porcelain( 296 plumbing_item) 297 if plumbing_response.meta.next_cursor == '': 298 break 299 req.meta.cursor = plumbing_response.meta.next_cursor 300 301 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)
262 def list(self, filter, *args, timeout=None): 263 ''' 264 List gets a list of AccessRequestEventHistory records matching a given set of criteria. 265 ''' 266 deadline = None if timeout is None else time.time() + timeout 267 req = AccessRequestEventHistoryListRequest() 268 req.meta.CopyFrom(ListRequestMetadata()) 269 if self.parent.page_limit > 0: 270 req.meta.limit = self.parent.page_limit 271 if self.parent.snapshot_datetime is not None: 272 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 273 274 req.filter = plumbing.quote_filter_args(filter, *args) 275 276 def generator(svc, req): 277 tries = 0 278 while True: 279 t = None if deadline is None else deadline - time.time() 280 try: 281 plumbing_response = svc.stub.List( 282 req, 283 metadata=svc.parent.get_metadata( 284 'AccessRequestEventsHistory.List', req), 285 timeout=t) 286 except Exception as e: 287 if self.parent.shouldRetry(tries, e, deadline): 288 tries += 1 289 time.sleep( 290 self.parent.exponentialBackoff(tries, deadline)) 291 continue 292 raise plumbing.convert_error_to_porcelain(e) from e 293 tries = 0 294 for plumbing_item in plumbing_response.history: 295 yield plumbing.convert_access_request_event_history_to_porcelain( 296 plumbing_item) 297 if plumbing_response.meta.next_cursor == '': 298 break 299 req.meta.cursor = plumbing_response.meta.next_cursor 300 301 return generator(self, req)
List gets a list of AccessRequestEventHistory records matching a given set of criteria.
class
AccessRequestsHistory:
304class AccessRequestsHistory: 305 ''' 306 AccessRequestsHistory provides records of all changes to the state of an AccessRequest. 307 See `strongdm.models.AccessRequestHistory`. 308 ''' 309 def __init__(self, channel, client): 310 self.parent = client 311 self.stub = AccessRequestsHistoryStub(channel) 312 313 def list(self, filter, *args, timeout=None): 314 ''' 315 List gets a list of AccessRequestHistory records matching a given set of criteria. 316 ''' 317 deadline = None if timeout is None else time.time() + timeout 318 req = AccessRequestHistoryListRequest() 319 req.meta.CopyFrom(ListRequestMetadata()) 320 if self.parent.page_limit > 0: 321 req.meta.limit = self.parent.page_limit 322 if self.parent.snapshot_datetime is not None: 323 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 324 325 req.filter = plumbing.quote_filter_args(filter, *args) 326 327 def generator(svc, req): 328 tries = 0 329 while True: 330 t = None if deadline is None else deadline - time.time() 331 try: 332 plumbing_response = svc.stub.List( 333 req, 334 metadata=svc.parent.get_metadata( 335 'AccessRequestsHistory.List', req), 336 timeout=t) 337 except Exception as e: 338 if self.parent.shouldRetry(tries, e, deadline): 339 tries += 1 340 time.sleep( 341 self.parent.exponentialBackoff(tries, deadline)) 342 continue 343 raise plumbing.convert_error_to_porcelain(e) from e 344 tries = 0 345 for plumbing_item in plumbing_response.history: 346 yield plumbing.convert_access_request_history_to_porcelain( 347 plumbing_item) 348 if plumbing_response.meta.next_cursor == '': 349 break 350 req.meta.cursor = plumbing_response.meta.next_cursor 351 352 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)
313 def list(self, filter, *args, timeout=None): 314 ''' 315 List gets a list of AccessRequestHistory records matching a given set of criteria. 316 ''' 317 deadline = None if timeout is None else time.time() + timeout 318 req = AccessRequestHistoryListRequest() 319 req.meta.CopyFrom(ListRequestMetadata()) 320 if self.parent.page_limit > 0: 321 req.meta.limit = self.parent.page_limit 322 if self.parent.snapshot_datetime is not None: 323 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 324 325 req.filter = plumbing.quote_filter_args(filter, *args) 326 327 def generator(svc, req): 328 tries = 0 329 while True: 330 t = None if deadline is None else deadline - time.time() 331 try: 332 plumbing_response = svc.stub.List( 333 req, 334 metadata=svc.parent.get_metadata( 335 'AccessRequestsHistory.List', req), 336 timeout=t) 337 except Exception as e: 338 if self.parent.shouldRetry(tries, e, deadline): 339 tries += 1 340 time.sleep( 341 self.parent.exponentialBackoff(tries, deadline)) 342 continue 343 raise plumbing.convert_error_to_porcelain(e) from e 344 tries = 0 345 for plumbing_item in plumbing_response.history: 346 yield plumbing.convert_access_request_history_to_porcelain( 347 plumbing_item) 348 if plumbing_response.meta.next_cursor == '': 349 break 350 req.meta.cursor = plumbing_response.meta.next_cursor 351 352 return generator(self, req)
List gets a list of AccessRequestHistory records matching a given set of criteria.
class
AccountAttachments:
355class AccountAttachments: 356 ''' 357 AccountAttachments assign an account to a role. 358 See `strongdm.models.AccountAttachment`. 359 ''' 360 def __init__(self, channel, client): 361 self.parent = client 362 self.stub = AccountAttachmentsStub(channel) 363 364 def create(self, account_attachment, timeout=None): 365 ''' 366 Create registers a new AccountAttachment. 367 ''' 368 deadline = None if timeout is None else time.time() + timeout 369 req = AccountAttachmentCreateRequest() 370 371 if account_attachment is not None: 372 req.account_attachment.CopyFrom( 373 plumbing.convert_account_attachment_to_plumbing( 374 account_attachment)) 375 tries = 0 376 plumbing_response = None 377 while True: 378 t = None if deadline is None else deadline - time.time() 379 try: 380 plumbing_response = self.stub.Create( 381 req, 382 metadata=self.parent.get_metadata( 383 'AccountAttachments.Create', req), 384 timeout=t) 385 except Exception as e: 386 if self.parent.shouldRetry(tries, e, deadline): 387 tries += 1 388 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 389 continue 390 raise plumbing.convert_error_to_porcelain(e) from e 391 break 392 393 resp = models.AccountAttachmentCreateResponse() 394 resp.account_attachment = plumbing.convert_account_attachment_to_porcelain( 395 plumbing_response.account_attachment) 396 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 397 plumbing_response.meta) 398 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 399 plumbing_response.rate_limit) 400 return resp 401 402 def get(self, id, timeout=None): 403 ''' 404 Get reads one AccountAttachment by ID. 405 ''' 406 deadline = None if timeout is None else time.time() + timeout 407 req = AccountAttachmentGetRequest() 408 if self.parent.snapshot_datetime is not None: 409 req.meta.CopyFrom(GetRequestMetadata()) 410 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 411 412 req.id = (id) 413 tries = 0 414 plumbing_response = None 415 while True: 416 t = None if deadline is None else deadline - time.time() 417 try: 418 plumbing_response = self.stub.Get( 419 req, 420 metadata=self.parent.get_metadata('AccountAttachments.Get', 421 req), 422 timeout=t) 423 except Exception as e: 424 if self.parent.shouldRetry(tries, e, deadline): 425 tries += 1 426 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 427 continue 428 raise plumbing.convert_error_to_porcelain(e) from e 429 break 430 431 resp = models.AccountAttachmentGetResponse() 432 resp.account_attachment = plumbing.convert_account_attachment_to_porcelain( 433 plumbing_response.account_attachment) 434 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 435 plumbing_response.meta) 436 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 437 plumbing_response.rate_limit) 438 return resp 439 440 def delete(self, id, timeout=None): 441 ''' 442 Delete removes a AccountAttachment by ID. 443 ''' 444 deadline = None if timeout is None else time.time() + timeout 445 req = AccountAttachmentDeleteRequest() 446 447 req.id = (id) 448 tries = 0 449 plumbing_response = None 450 while True: 451 t = None if deadline is None else deadline - time.time() 452 try: 453 plumbing_response = self.stub.Delete( 454 req, 455 metadata=self.parent.get_metadata( 456 'AccountAttachments.Delete', req), 457 timeout=t) 458 except Exception as e: 459 if self.parent.shouldRetry(tries, e, deadline): 460 tries += 1 461 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 462 continue 463 raise plumbing.convert_error_to_porcelain(e) from e 464 break 465 466 resp = models.AccountAttachmentDeleteResponse() 467 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 468 plumbing_response.meta) 469 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 470 plumbing_response.rate_limit) 471 return resp 472 473 def list(self, filter, *args, timeout=None): 474 ''' 475 List gets a list of AccountAttachments matching a given set of criteria. 476 ''' 477 deadline = None if timeout is None else time.time() + timeout 478 req = AccountAttachmentListRequest() 479 req.meta.CopyFrom(ListRequestMetadata()) 480 if self.parent.page_limit > 0: 481 req.meta.limit = self.parent.page_limit 482 if self.parent.snapshot_datetime is not None: 483 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 484 485 req.filter = plumbing.quote_filter_args(filter, *args) 486 487 def generator(svc, req): 488 tries = 0 489 while True: 490 t = None if deadline is None else deadline - time.time() 491 try: 492 plumbing_response = svc.stub.List( 493 req, 494 metadata=svc.parent.get_metadata( 495 'AccountAttachments.List', req), 496 timeout=t) 497 except Exception as e: 498 if self.parent.shouldRetry(tries, e, deadline): 499 tries += 1 500 time.sleep( 501 self.parent.exponentialBackoff(tries, deadline)) 502 continue 503 raise plumbing.convert_error_to_porcelain(e) from e 504 tries = 0 505 for plumbing_item in plumbing_response.account_attachments: 506 yield plumbing.convert_account_attachment_to_porcelain( 507 plumbing_item) 508 if plumbing_response.meta.next_cursor == '': 509 break 510 req.meta.cursor = plumbing_response.meta.next_cursor 511 512 return generator(self, req)
AccountAttachments assign an account to a role.
See strongdm.models.AccountAttachment.
def
create(self, account_attachment, timeout=None)
364 def create(self, account_attachment, timeout=None): 365 ''' 366 Create registers a new AccountAttachment. 367 ''' 368 deadline = None if timeout is None else time.time() + timeout 369 req = AccountAttachmentCreateRequest() 370 371 if account_attachment is not None: 372 req.account_attachment.CopyFrom( 373 plumbing.convert_account_attachment_to_plumbing( 374 account_attachment)) 375 tries = 0 376 plumbing_response = None 377 while True: 378 t = None if deadline is None else deadline - time.time() 379 try: 380 plumbing_response = self.stub.Create( 381 req, 382 metadata=self.parent.get_metadata( 383 'AccountAttachments.Create', req), 384 timeout=t) 385 except Exception as e: 386 if self.parent.shouldRetry(tries, e, deadline): 387 tries += 1 388 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 389 continue 390 raise plumbing.convert_error_to_porcelain(e) from e 391 break 392 393 resp = models.AccountAttachmentCreateResponse() 394 resp.account_attachment = plumbing.convert_account_attachment_to_porcelain( 395 plumbing_response.account_attachment) 396 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 397 plumbing_response.meta) 398 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 399 plumbing_response.rate_limit) 400 return resp
Create registers a new AccountAttachment.
def
get(self, id, timeout=None)
402 def get(self, id, timeout=None): 403 ''' 404 Get reads one AccountAttachment by ID. 405 ''' 406 deadline = None if timeout is None else time.time() + timeout 407 req = AccountAttachmentGetRequest() 408 if self.parent.snapshot_datetime is not None: 409 req.meta.CopyFrom(GetRequestMetadata()) 410 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 411 412 req.id = (id) 413 tries = 0 414 plumbing_response = None 415 while True: 416 t = None if deadline is None else deadline - time.time() 417 try: 418 plumbing_response = self.stub.Get( 419 req, 420 metadata=self.parent.get_metadata('AccountAttachments.Get', 421 req), 422 timeout=t) 423 except Exception as e: 424 if self.parent.shouldRetry(tries, e, deadline): 425 tries += 1 426 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 427 continue 428 raise plumbing.convert_error_to_porcelain(e) from e 429 break 430 431 resp = models.AccountAttachmentGetResponse() 432 resp.account_attachment = plumbing.convert_account_attachment_to_porcelain( 433 plumbing_response.account_attachment) 434 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 435 plumbing_response.meta) 436 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 437 plumbing_response.rate_limit) 438 return resp
Get reads one AccountAttachment by ID.
def
delete(self, id, timeout=None)
440 def delete(self, id, timeout=None): 441 ''' 442 Delete removes a AccountAttachment by ID. 443 ''' 444 deadline = None if timeout is None else time.time() + timeout 445 req = AccountAttachmentDeleteRequest() 446 447 req.id = (id) 448 tries = 0 449 plumbing_response = None 450 while True: 451 t = None if deadline is None else deadline - time.time() 452 try: 453 plumbing_response = self.stub.Delete( 454 req, 455 metadata=self.parent.get_metadata( 456 'AccountAttachments.Delete', req), 457 timeout=t) 458 except Exception as e: 459 if self.parent.shouldRetry(tries, e, deadline): 460 tries += 1 461 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 462 continue 463 raise plumbing.convert_error_to_porcelain(e) from e 464 break 465 466 resp = models.AccountAttachmentDeleteResponse() 467 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 468 plumbing_response.meta) 469 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 470 plumbing_response.rate_limit) 471 return resp
Delete removes a AccountAttachment by ID.
def
list(self, filter, *args, timeout=None)
473 def list(self, filter, *args, timeout=None): 474 ''' 475 List gets a list of AccountAttachments matching a given set of criteria. 476 ''' 477 deadline = None if timeout is None else time.time() + timeout 478 req = AccountAttachmentListRequest() 479 req.meta.CopyFrom(ListRequestMetadata()) 480 if self.parent.page_limit > 0: 481 req.meta.limit = self.parent.page_limit 482 if self.parent.snapshot_datetime is not None: 483 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 484 485 req.filter = plumbing.quote_filter_args(filter, *args) 486 487 def generator(svc, req): 488 tries = 0 489 while True: 490 t = None if deadline is None else deadline - time.time() 491 try: 492 plumbing_response = svc.stub.List( 493 req, 494 metadata=svc.parent.get_metadata( 495 'AccountAttachments.List', req), 496 timeout=t) 497 except Exception as e: 498 if self.parent.shouldRetry(tries, e, deadline): 499 tries += 1 500 time.sleep( 501 self.parent.exponentialBackoff(tries, deadline)) 502 continue 503 raise plumbing.convert_error_to_porcelain(e) from e 504 tries = 0 505 for plumbing_item in plumbing_response.account_attachments: 506 yield plumbing.convert_account_attachment_to_porcelain( 507 plumbing_item) 508 if plumbing_response.meta.next_cursor == '': 509 break 510 req.meta.cursor = plumbing_response.meta.next_cursor 511 512 return generator(self, req)
List gets a list of AccountAttachments matching a given set of criteria.
class
SnapshotAccountAttachments:
515class SnapshotAccountAttachments: 516 ''' 517 SnapshotAccountAttachments exposes the read only methods of the AccountAttachments 518 service for historical queries. 519 ''' 520 def __init__(self, account_attachments): 521 self.account_attachments = account_attachments 522 523 def get(self, id, timeout=None): 524 ''' 525 Get reads one AccountAttachment by ID. 526 ''' 527 return self.account_attachments.get(id, timeout=timeout) 528 529 def list(self, filter, *args, timeout=None): 530 ''' 531 List gets a list of AccountAttachments matching a given set of criteria. 532 ''' 533 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)
523 def get(self, id, timeout=None): 524 ''' 525 Get reads one AccountAttachment by ID. 526 ''' 527 return self.account_attachments.get(id, timeout=timeout)
Get reads one AccountAttachment by ID.
def
list(self, filter, *args, timeout=None)
529 def list(self, filter, *args, timeout=None): 530 ''' 531 List gets a list of AccountAttachments matching a given set of criteria. 532 ''' 533 return self.account_attachments.list(filter, *args, timeout=timeout)
List gets a list of AccountAttachments matching a given set of criteria.
class
AccountAttachmentsHistory:
536class AccountAttachmentsHistory: 537 ''' 538 AccountAttachmentsHistory records all changes to the state of an AccountAttachment. 539 See `strongdm.models.AccountAttachmentHistory`. 540 ''' 541 def __init__(self, channel, client): 542 self.parent = client 543 self.stub = AccountAttachmentsHistoryStub(channel) 544 545 def list(self, filter, *args, timeout=None): 546 ''' 547 List gets a list of AccountAttachmentHistory records matching a given set of criteria. 548 ''' 549 deadline = None if timeout is None else time.time() + timeout 550 req = AccountAttachmentHistoryListRequest() 551 req.meta.CopyFrom(ListRequestMetadata()) 552 if self.parent.page_limit > 0: 553 req.meta.limit = self.parent.page_limit 554 if self.parent.snapshot_datetime is not None: 555 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 556 557 req.filter = plumbing.quote_filter_args(filter, *args) 558 559 def generator(svc, req): 560 tries = 0 561 while True: 562 t = None if deadline is None else deadline - time.time() 563 try: 564 plumbing_response = svc.stub.List( 565 req, 566 metadata=svc.parent.get_metadata( 567 'AccountAttachmentsHistory.List', req), 568 timeout=t) 569 except Exception as e: 570 if self.parent.shouldRetry(tries, e, deadline): 571 tries += 1 572 time.sleep( 573 self.parent.exponentialBackoff(tries, deadline)) 574 continue 575 raise plumbing.convert_error_to_porcelain(e) from e 576 tries = 0 577 for plumbing_item in plumbing_response.history: 578 yield plumbing.convert_account_attachment_history_to_porcelain( 579 plumbing_item) 580 if plumbing_response.meta.next_cursor == '': 581 break 582 req.meta.cursor = plumbing_response.meta.next_cursor 583 584 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)
545 def list(self, filter, *args, timeout=None): 546 ''' 547 List gets a list of AccountAttachmentHistory records matching a given set of criteria. 548 ''' 549 deadline = None if timeout is None else time.time() + timeout 550 req = AccountAttachmentHistoryListRequest() 551 req.meta.CopyFrom(ListRequestMetadata()) 552 if self.parent.page_limit > 0: 553 req.meta.limit = self.parent.page_limit 554 if self.parent.snapshot_datetime is not None: 555 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 556 557 req.filter = plumbing.quote_filter_args(filter, *args) 558 559 def generator(svc, req): 560 tries = 0 561 while True: 562 t = None if deadline is None else deadline - time.time() 563 try: 564 plumbing_response = svc.stub.List( 565 req, 566 metadata=svc.parent.get_metadata( 567 'AccountAttachmentsHistory.List', req), 568 timeout=t) 569 except Exception as e: 570 if self.parent.shouldRetry(tries, e, deadline): 571 tries += 1 572 time.sleep( 573 self.parent.exponentialBackoff(tries, deadline)) 574 continue 575 raise plumbing.convert_error_to_porcelain(e) from e 576 tries = 0 577 for plumbing_item in plumbing_response.history: 578 yield plumbing.convert_account_attachment_history_to_porcelain( 579 plumbing_item) 580 if plumbing_response.meta.next_cursor == '': 581 break 582 req.meta.cursor = plumbing_response.meta.next_cursor 583 584 return generator(self, req)
List gets a list of AccountAttachmentHistory records matching a given set of criteria.
class
AccountGrants:
587class AccountGrants: 588 ''' 589 AccountGrants assign a resource directly to an account, giving the account the permission to connect to that resource. 590 See `strongdm.models.AccountGrant`. 591 ''' 592 def __init__(self, channel, client): 593 self.parent = client 594 self.stub = AccountGrantsStub(channel) 595 596 def create(self, account_grant, timeout=None): 597 ''' 598 Create registers a new AccountGrant. 599 ''' 600 deadline = None if timeout is None else time.time() + timeout 601 req = AccountGrantCreateRequest() 602 603 if account_grant is not None: 604 req.account_grant.CopyFrom( 605 plumbing.convert_account_grant_to_plumbing(account_grant)) 606 tries = 0 607 plumbing_response = None 608 while True: 609 t = None if deadline is None else deadline - time.time() 610 try: 611 plumbing_response = self.stub.Create( 612 req, 613 metadata=self.parent.get_metadata('AccountGrants.Create', 614 req), 615 timeout=t) 616 except Exception as e: 617 if self.parent.shouldRetry(tries, e, deadline): 618 tries += 1 619 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 620 continue 621 raise plumbing.convert_error_to_porcelain(e) from e 622 break 623 624 resp = models.AccountGrantCreateResponse() 625 resp.account_grant = plumbing.convert_account_grant_to_porcelain( 626 plumbing_response.account_grant) 627 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 628 plumbing_response.meta) 629 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 630 plumbing_response.rate_limit) 631 return resp 632 633 def get(self, id, timeout=None): 634 ''' 635 Get reads one AccountGrant by ID. 636 ''' 637 deadline = None if timeout is None else time.time() + timeout 638 req = AccountGrantGetRequest() 639 if self.parent.snapshot_datetime is not None: 640 req.meta.CopyFrom(GetRequestMetadata()) 641 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 642 643 req.id = (id) 644 tries = 0 645 plumbing_response = None 646 while True: 647 t = None if deadline is None else deadline - time.time() 648 try: 649 plumbing_response = self.stub.Get( 650 req, 651 metadata=self.parent.get_metadata('AccountGrants.Get', 652 req), 653 timeout=t) 654 except Exception as e: 655 if self.parent.shouldRetry(tries, e, deadline): 656 tries += 1 657 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 658 continue 659 raise plumbing.convert_error_to_porcelain(e) from e 660 break 661 662 resp = models.AccountGrantGetResponse() 663 resp.account_grant = plumbing.convert_account_grant_to_porcelain( 664 plumbing_response.account_grant) 665 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 666 plumbing_response.meta) 667 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 668 plumbing_response.rate_limit) 669 return resp 670 671 def delete(self, id, timeout=None): 672 ''' 673 Delete removes a AccountGrant by ID. 674 ''' 675 deadline = None if timeout is None else time.time() + timeout 676 req = AccountGrantDeleteRequest() 677 678 req.id = (id) 679 tries = 0 680 plumbing_response = None 681 while True: 682 t = None if deadline is None else deadline - time.time() 683 try: 684 plumbing_response = self.stub.Delete( 685 req, 686 metadata=self.parent.get_metadata('AccountGrants.Delete', 687 req), 688 timeout=t) 689 except Exception as e: 690 if self.parent.shouldRetry(tries, e, deadline): 691 tries += 1 692 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 693 continue 694 raise plumbing.convert_error_to_porcelain(e) from e 695 break 696 697 resp = models.AccountGrantDeleteResponse() 698 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 699 plumbing_response.meta) 700 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 701 plumbing_response.rate_limit) 702 return resp 703 704 def list(self, filter, *args, timeout=None): 705 ''' 706 List gets a list of AccountGrants matching a given set of criteria. 707 ''' 708 deadline = None if timeout is None else time.time() + timeout 709 req = AccountGrantListRequest() 710 req.meta.CopyFrom(ListRequestMetadata()) 711 if self.parent.page_limit > 0: 712 req.meta.limit = self.parent.page_limit 713 if self.parent.snapshot_datetime is not None: 714 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 715 716 req.filter = plumbing.quote_filter_args(filter, *args) 717 718 def generator(svc, req): 719 tries = 0 720 while True: 721 t = None if deadline is None else deadline - time.time() 722 try: 723 plumbing_response = svc.stub.List( 724 req, 725 metadata=svc.parent.get_metadata( 726 'AccountGrants.List', req), 727 timeout=t) 728 except Exception as e: 729 if self.parent.shouldRetry(tries, e, deadline): 730 tries += 1 731 time.sleep( 732 self.parent.exponentialBackoff(tries, deadline)) 733 continue 734 raise plumbing.convert_error_to_porcelain(e) from e 735 tries = 0 736 for plumbing_item in plumbing_response.account_grants: 737 yield plumbing.convert_account_grant_to_porcelain( 738 plumbing_item) 739 if plumbing_response.meta.next_cursor == '': 740 break 741 req.meta.cursor = plumbing_response.meta.next_cursor 742 743 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)
596 def create(self, account_grant, timeout=None): 597 ''' 598 Create registers a new AccountGrant. 599 ''' 600 deadline = None if timeout is None else time.time() + timeout 601 req = AccountGrantCreateRequest() 602 603 if account_grant is not None: 604 req.account_grant.CopyFrom( 605 plumbing.convert_account_grant_to_plumbing(account_grant)) 606 tries = 0 607 plumbing_response = None 608 while True: 609 t = None if deadline is None else deadline - time.time() 610 try: 611 plumbing_response = self.stub.Create( 612 req, 613 metadata=self.parent.get_metadata('AccountGrants.Create', 614 req), 615 timeout=t) 616 except Exception as e: 617 if self.parent.shouldRetry(tries, e, deadline): 618 tries += 1 619 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 620 continue 621 raise plumbing.convert_error_to_porcelain(e) from e 622 break 623 624 resp = models.AccountGrantCreateResponse() 625 resp.account_grant = plumbing.convert_account_grant_to_porcelain( 626 plumbing_response.account_grant) 627 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 628 plumbing_response.meta) 629 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 630 plumbing_response.rate_limit) 631 return resp
Create registers a new AccountGrant.
def
get(self, id, timeout=None)
633 def get(self, id, timeout=None): 634 ''' 635 Get reads one AccountGrant by ID. 636 ''' 637 deadline = None if timeout is None else time.time() + timeout 638 req = AccountGrantGetRequest() 639 if self.parent.snapshot_datetime is not None: 640 req.meta.CopyFrom(GetRequestMetadata()) 641 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 642 643 req.id = (id) 644 tries = 0 645 plumbing_response = None 646 while True: 647 t = None if deadline is None else deadline - time.time() 648 try: 649 plumbing_response = self.stub.Get( 650 req, 651 metadata=self.parent.get_metadata('AccountGrants.Get', 652 req), 653 timeout=t) 654 except Exception as e: 655 if self.parent.shouldRetry(tries, e, deadline): 656 tries += 1 657 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 658 continue 659 raise plumbing.convert_error_to_porcelain(e) from e 660 break 661 662 resp = models.AccountGrantGetResponse() 663 resp.account_grant = plumbing.convert_account_grant_to_porcelain( 664 plumbing_response.account_grant) 665 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 666 plumbing_response.meta) 667 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 668 plumbing_response.rate_limit) 669 return resp
Get reads one AccountGrant by ID.
def
delete(self, id, timeout=None)
671 def delete(self, id, timeout=None): 672 ''' 673 Delete removes a AccountGrant by ID. 674 ''' 675 deadline = None if timeout is None else time.time() + timeout 676 req = AccountGrantDeleteRequest() 677 678 req.id = (id) 679 tries = 0 680 plumbing_response = None 681 while True: 682 t = None if deadline is None else deadline - time.time() 683 try: 684 plumbing_response = self.stub.Delete( 685 req, 686 metadata=self.parent.get_metadata('AccountGrants.Delete', 687 req), 688 timeout=t) 689 except Exception as e: 690 if self.parent.shouldRetry(tries, e, deadline): 691 tries += 1 692 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 693 continue 694 raise plumbing.convert_error_to_porcelain(e) from e 695 break 696 697 resp = models.AccountGrantDeleteResponse() 698 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 699 plumbing_response.meta) 700 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 701 plumbing_response.rate_limit) 702 return resp
Delete removes a AccountGrant by ID.
def
list(self, filter, *args, timeout=None)
704 def list(self, filter, *args, timeout=None): 705 ''' 706 List gets a list of AccountGrants matching a given set of criteria. 707 ''' 708 deadline = None if timeout is None else time.time() + timeout 709 req = AccountGrantListRequest() 710 req.meta.CopyFrom(ListRequestMetadata()) 711 if self.parent.page_limit > 0: 712 req.meta.limit = self.parent.page_limit 713 if self.parent.snapshot_datetime is not None: 714 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 715 716 req.filter = plumbing.quote_filter_args(filter, *args) 717 718 def generator(svc, req): 719 tries = 0 720 while True: 721 t = None if deadline is None else deadline - time.time() 722 try: 723 plumbing_response = svc.stub.List( 724 req, 725 metadata=svc.parent.get_metadata( 726 'AccountGrants.List', req), 727 timeout=t) 728 except Exception as e: 729 if self.parent.shouldRetry(tries, e, deadline): 730 tries += 1 731 time.sleep( 732 self.parent.exponentialBackoff(tries, deadline)) 733 continue 734 raise plumbing.convert_error_to_porcelain(e) from e 735 tries = 0 736 for plumbing_item in plumbing_response.account_grants: 737 yield plumbing.convert_account_grant_to_porcelain( 738 plumbing_item) 739 if plumbing_response.meta.next_cursor == '': 740 break 741 req.meta.cursor = plumbing_response.meta.next_cursor 742 743 return generator(self, req)
List gets a list of AccountGrants matching a given set of criteria.
class
SnapshotAccountGrants:
746class SnapshotAccountGrants: 747 ''' 748 SnapshotAccountGrants exposes the read only methods of the AccountGrants 749 service for historical queries. 750 ''' 751 def __init__(self, account_grants): 752 self.account_grants = account_grants 753 754 def get(self, id, timeout=None): 755 ''' 756 Get reads one AccountGrant by ID. 757 ''' 758 return self.account_grants.get(id, timeout=timeout) 759 760 def list(self, filter, *args, timeout=None): 761 ''' 762 List gets a list of AccountGrants matching a given set of criteria. 763 ''' 764 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)
754 def get(self, id, timeout=None): 755 ''' 756 Get reads one AccountGrant by ID. 757 ''' 758 return self.account_grants.get(id, timeout=timeout)
Get reads one AccountGrant by ID.
def
list(self, filter, *args, timeout=None)
760 def list(self, filter, *args, timeout=None): 761 ''' 762 List gets a list of AccountGrants matching a given set of criteria. 763 ''' 764 return self.account_grants.list(filter, *args, timeout=timeout)
List gets a list of AccountGrants matching a given set of criteria.
class
AccountGrantsHistory:
767class AccountGrantsHistory: 768 ''' 769 AccountGrantsHistory records all changes to the state of an AccountGrant. 770 See `strongdm.models.AccountGrantHistory`. 771 ''' 772 def __init__(self, channel, client): 773 self.parent = client 774 self.stub = AccountGrantsHistoryStub(channel) 775 776 def list(self, filter, *args, timeout=None): 777 ''' 778 List gets a list of AccountGrantHistory records matching a given set of criteria. 779 ''' 780 deadline = None if timeout is None else time.time() + timeout 781 req = AccountGrantHistoryListRequest() 782 req.meta.CopyFrom(ListRequestMetadata()) 783 if self.parent.page_limit > 0: 784 req.meta.limit = self.parent.page_limit 785 if self.parent.snapshot_datetime is not None: 786 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 787 788 req.filter = plumbing.quote_filter_args(filter, *args) 789 790 def generator(svc, req): 791 tries = 0 792 while True: 793 t = None if deadline is None else deadline - time.time() 794 try: 795 plumbing_response = svc.stub.List( 796 req, 797 metadata=svc.parent.get_metadata( 798 'AccountGrantsHistory.List', req), 799 timeout=t) 800 except Exception as e: 801 if self.parent.shouldRetry(tries, e, deadline): 802 tries += 1 803 time.sleep( 804 self.parent.exponentialBackoff(tries, deadline)) 805 continue 806 raise plumbing.convert_error_to_porcelain(e) from e 807 tries = 0 808 for plumbing_item in plumbing_response.history: 809 yield plumbing.convert_account_grant_history_to_porcelain( 810 plumbing_item) 811 if plumbing_response.meta.next_cursor == '': 812 break 813 req.meta.cursor = plumbing_response.meta.next_cursor 814 815 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)
776 def list(self, filter, *args, timeout=None): 777 ''' 778 List gets a list of AccountGrantHistory records matching a given set of criteria. 779 ''' 780 deadline = None if timeout is None else time.time() + timeout 781 req = AccountGrantHistoryListRequest() 782 req.meta.CopyFrom(ListRequestMetadata()) 783 if self.parent.page_limit > 0: 784 req.meta.limit = self.parent.page_limit 785 if self.parent.snapshot_datetime is not None: 786 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 787 788 req.filter = plumbing.quote_filter_args(filter, *args) 789 790 def generator(svc, req): 791 tries = 0 792 while True: 793 t = None if deadline is None else deadline - time.time() 794 try: 795 plumbing_response = svc.stub.List( 796 req, 797 metadata=svc.parent.get_metadata( 798 'AccountGrantsHistory.List', req), 799 timeout=t) 800 except Exception as e: 801 if self.parent.shouldRetry(tries, e, deadline): 802 tries += 1 803 time.sleep( 804 self.parent.exponentialBackoff(tries, deadline)) 805 continue 806 raise plumbing.convert_error_to_porcelain(e) from e 807 tries = 0 808 for plumbing_item in plumbing_response.history: 809 yield plumbing.convert_account_grant_history_to_porcelain( 810 plumbing_item) 811 if plumbing_response.meta.next_cursor == '': 812 break 813 req.meta.cursor = plumbing_response.meta.next_cursor 814 815 return generator(self, req)
List gets a list of AccountGrantHistory records matching a given set of criteria.
class
AccountPermissions:
818class AccountPermissions: 819 ''' 820 AccountPermissions records the granular permissions accounts have, allowing them to execute 821 relevant commands via StrongDM's APIs. 822 See `strongdm.models.AccountPermission`. 823 ''' 824 def __init__(self, channel, client): 825 self.parent = client 826 self.stub = AccountPermissionsStub(channel) 827 828 def list(self, filter, *args, timeout=None): 829 ''' 830 List gets a list of Permission records matching a given set of criteria. 831 ''' 832 deadline = None if timeout is None else time.time() + timeout 833 req = AccountPermissionListRequest() 834 req.meta.CopyFrom(ListRequestMetadata()) 835 if self.parent.page_limit > 0: 836 req.meta.limit = self.parent.page_limit 837 if self.parent.snapshot_datetime is not None: 838 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 839 840 req.filter = plumbing.quote_filter_args(filter, *args) 841 842 def generator(svc, req): 843 tries = 0 844 while True: 845 t = None if deadline is None else deadline - time.time() 846 try: 847 plumbing_response = svc.stub.List( 848 req, 849 metadata=svc.parent.get_metadata( 850 'AccountPermissions.List', req), 851 timeout=t) 852 except Exception as e: 853 if self.parent.shouldRetry(tries, e, deadline): 854 tries += 1 855 time.sleep( 856 self.parent.exponentialBackoff(tries, deadline)) 857 continue 858 raise plumbing.convert_error_to_porcelain(e) from e 859 tries = 0 860 for plumbing_item in plumbing_response.permissions: 861 yield plumbing.convert_account_permission_to_porcelain( 862 plumbing_item) 863 if plumbing_response.meta.next_cursor == '': 864 break 865 req.meta.cursor = plumbing_response.meta.next_cursor 866 867 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)
828 def list(self, filter, *args, timeout=None): 829 ''' 830 List gets a list of Permission records matching a given set of criteria. 831 ''' 832 deadline = None if timeout is None else time.time() + timeout 833 req = AccountPermissionListRequest() 834 req.meta.CopyFrom(ListRequestMetadata()) 835 if self.parent.page_limit > 0: 836 req.meta.limit = self.parent.page_limit 837 if self.parent.snapshot_datetime is not None: 838 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 839 840 req.filter = plumbing.quote_filter_args(filter, *args) 841 842 def generator(svc, req): 843 tries = 0 844 while True: 845 t = None if deadline is None else deadline - time.time() 846 try: 847 plumbing_response = svc.stub.List( 848 req, 849 metadata=svc.parent.get_metadata( 850 'AccountPermissions.List', req), 851 timeout=t) 852 except Exception as e: 853 if self.parent.shouldRetry(tries, e, deadline): 854 tries += 1 855 time.sleep( 856 self.parent.exponentialBackoff(tries, deadline)) 857 continue 858 raise plumbing.convert_error_to_porcelain(e) from e 859 tries = 0 860 for plumbing_item in plumbing_response.permissions: 861 yield plumbing.convert_account_permission_to_porcelain( 862 plumbing_item) 863 if plumbing_response.meta.next_cursor == '': 864 break 865 req.meta.cursor = plumbing_response.meta.next_cursor 866 867 return generator(self, req)
List gets a list of Permission records matching a given set of criteria.
class
SnapshotAccountPermissions:
870class SnapshotAccountPermissions: 871 ''' 872 SnapshotAccountPermissions exposes the read only methods of the AccountPermissions 873 service for historical queries. 874 ''' 875 def __init__(self, account_permissions): 876 self.account_permissions = account_permissions 877 878 def list(self, filter, *args, timeout=None): 879 ''' 880 List gets a list of Permission records matching a given set of criteria. 881 ''' 882 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)
878 def list(self, filter, *args, timeout=None): 879 ''' 880 List gets a list of Permission records matching a given set of criteria. 881 ''' 882 return self.account_permissions.list(filter, *args, timeout=timeout)
List gets a list of Permission records matching a given set of criteria.
class
AccountResources:
885class AccountResources: 886 ''' 887 AccountResources enumerates the resources to which accounts have access. 888 The AccountResources service is read-only. 889 See `strongdm.models.AccountResource`. 890 ''' 891 def __init__(self, channel, client): 892 self.parent = client 893 self.stub = AccountResourcesStub(channel) 894 895 def list(self, filter, *args, timeout=None): 896 ''' 897 List gets a list of AccountResource records matching a given set of criteria. 898 ''' 899 deadline = None if timeout is None else time.time() + timeout 900 req = AccountResourceListRequest() 901 req.meta.CopyFrom(ListRequestMetadata()) 902 if self.parent.page_limit > 0: 903 req.meta.limit = self.parent.page_limit 904 if self.parent.snapshot_datetime is not None: 905 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 906 907 req.filter = plumbing.quote_filter_args(filter, *args) 908 909 def generator(svc, req): 910 tries = 0 911 while True: 912 t = None if deadline is None else deadline - time.time() 913 try: 914 plumbing_response = svc.stub.List( 915 req, 916 metadata=svc.parent.get_metadata( 917 'AccountResources.List', req), 918 timeout=t) 919 except Exception as e: 920 if self.parent.shouldRetry(tries, e, deadline): 921 tries += 1 922 time.sleep( 923 self.parent.exponentialBackoff(tries, deadline)) 924 continue 925 raise plumbing.convert_error_to_porcelain(e) from e 926 tries = 0 927 for plumbing_item in plumbing_response.account_resources: 928 yield plumbing.convert_account_resource_to_porcelain( 929 plumbing_item) 930 if plumbing_response.meta.next_cursor == '': 931 break 932 req.meta.cursor = plumbing_response.meta.next_cursor 933 934 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)
895 def list(self, filter, *args, timeout=None): 896 ''' 897 List gets a list of AccountResource records matching a given set of criteria. 898 ''' 899 deadline = None if timeout is None else time.time() + timeout 900 req = AccountResourceListRequest() 901 req.meta.CopyFrom(ListRequestMetadata()) 902 if self.parent.page_limit > 0: 903 req.meta.limit = self.parent.page_limit 904 if self.parent.snapshot_datetime is not None: 905 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 906 907 req.filter = plumbing.quote_filter_args(filter, *args) 908 909 def generator(svc, req): 910 tries = 0 911 while True: 912 t = None if deadline is None else deadline - time.time() 913 try: 914 plumbing_response = svc.stub.List( 915 req, 916 metadata=svc.parent.get_metadata( 917 'AccountResources.List', req), 918 timeout=t) 919 except Exception as e: 920 if self.parent.shouldRetry(tries, e, deadline): 921 tries += 1 922 time.sleep( 923 self.parent.exponentialBackoff(tries, deadline)) 924 continue 925 raise plumbing.convert_error_to_porcelain(e) from e 926 tries = 0 927 for plumbing_item in plumbing_response.account_resources: 928 yield plumbing.convert_account_resource_to_porcelain( 929 plumbing_item) 930 if plumbing_response.meta.next_cursor == '': 931 break 932 req.meta.cursor = plumbing_response.meta.next_cursor 933 934 return generator(self, req)
List gets a list of AccountResource records matching a given set of criteria.
class
SnapshotAccountResources:
937class SnapshotAccountResources: 938 ''' 939 SnapshotAccountResources exposes the read only methods of the AccountResources 940 service for historical queries. 941 ''' 942 def __init__(self, account_resources): 943 self.account_resources = account_resources 944 945 def list(self, filter, *args, timeout=None): 946 ''' 947 List gets a list of AccountResource records matching a given set of criteria. 948 ''' 949 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)
945 def list(self, filter, *args, timeout=None): 946 ''' 947 List gets a list of AccountResource records matching a given set of criteria. 948 ''' 949 return self.account_resources.list(filter, *args, timeout=timeout)
List gets a list of AccountResource records matching a given set of criteria.
class
AccountResourcesHistory:
952class AccountResourcesHistory: 953 ''' 954 AccountResourcesHistory records all changes to the state of a AccountResource. 955 See `strongdm.models.AccountResourceHistory`. 956 ''' 957 def __init__(self, channel, client): 958 self.parent = client 959 self.stub = AccountResourcesHistoryStub(channel) 960 961 def list(self, filter, *args, timeout=None): 962 ''' 963 List gets a list of AccountResourceHistory records matching a given set of criteria. 964 ''' 965 deadline = None if timeout is None else time.time() + timeout 966 req = AccountResourceHistoryListRequest() 967 req.meta.CopyFrom(ListRequestMetadata()) 968 if self.parent.page_limit > 0: 969 req.meta.limit = self.parent.page_limit 970 if self.parent.snapshot_datetime is not None: 971 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 972 973 req.filter = plumbing.quote_filter_args(filter, *args) 974 975 def generator(svc, req): 976 tries = 0 977 while True: 978 t = None if deadline is None else deadline - time.time() 979 try: 980 plumbing_response = svc.stub.List( 981 req, 982 metadata=svc.parent.get_metadata( 983 'AccountResourcesHistory.List', req), 984 timeout=t) 985 except Exception as e: 986 if self.parent.shouldRetry(tries, e, deadline): 987 tries += 1 988 time.sleep( 989 self.parent.exponentialBackoff(tries, deadline)) 990 continue 991 raise plumbing.convert_error_to_porcelain(e) from e 992 tries = 0 993 for plumbing_item in plumbing_response.history: 994 yield plumbing.convert_account_resource_history_to_porcelain( 995 plumbing_item) 996 if plumbing_response.meta.next_cursor == '': 997 break 998 req.meta.cursor = plumbing_response.meta.next_cursor 999 1000 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)
961 def list(self, filter, *args, timeout=None): 962 ''' 963 List gets a list of AccountResourceHistory records matching a given set of criteria. 964 ''' 965 deadline = None if timeout is None else time.time() + timeout 966 req = AccountResourceHistoryListRequest() 967 req.meta.CopyFrom(ListRequestMetadata()) 968 if self.parent.page_limit > 0: 969 req.meta.limit = self.parent.page_limit 970 if self.parent.snapshot_datetime is not None: 971 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 972 973 req.filter = plumbing.quote_filter_args(filter, *args) 974 975 def generator(svc, req): 976 tries = 0 977 while True: 978 t = None if deadline is None else deadline - time.time() 979 try: 980 plumbing_response = svc.stub.List( 981 req, 982 metadata=svc.parent.get_metadata( 983 'AccountResourcesHistory.List', req), 984 timeout=t) 985 except Exception as e: 986 if self.parent.shouldRetry(tries, e, deadline): 987 tries += 1 988 time.sleep( 989 self.parent.exponentialBackoff(tries, deadline)) 990 continue 991 raise plumbing.convert_error_to_porcelain(e) from e 992 tries = 0 993 for plumbing_item in plumbing_response.history: 994 yield plumbing.convert_account_resource_history_to_porcelain( 995 plumbing_item) 996 if plumbing_response.meta.next_cursor == '': 997 break 998 req.meta.cursor = plumbing_response.meta.next_cursor 999 1000 return generator(self, req)
List gets a list of AccountResourceHistory records matching a given set of criteria.
class
Accounts:
1003class Accounts: 1004 ''' 1005 Accounts are users that have access to strongDM. There are two types of accounts: 1006 1. **Users:** humans who are authenticated through username and password or SSO. 1007 2. **Service Accounts:** machines that are authenticated using a service token. 1008 3. **Tokens** are access keys with permissions that can be used for authentication. 1009 See: 1010 `strongdm.models.Service` 1011 `strongdm.models.Token` 1012 `strongdm.models.User` 1013 ''' 1014 def __init__(self, channel, client): 1015 self.parent = client 1016 self.stub = AccountsStub(channel) 1017 1018 def create(self, account, timeout=None): 1019 ''' 1020 Create registers a new Account. 1021 ''' 1022 deadline = None if timeout is None else time.time() + timeout 1023 req = AccountCreateRequest() 1024 1025 if account is not None: 1026 req.account.CopyFrom(plumbing.convert_account_to_plumbing(account)) 1027 tries = 0 1028 plumbing_response = None 1029 while True: 1030 t = None if deadline is None else deadline - time.time() 1031 try: 1032 plumbing_response = self.stub.Create( 1033 req, 1034 metadata=self.parent.get_metadata('Accounts.Create', req), 1035 timeout=t) 1036 except Exception as e: 1037 if self.parent.shouldRetry(tries, e, deadline): 1038 tries += 1 1039 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1040 continue 1041 raise plumbing.convert_error_to_porcelain(e) from e 1042 break 1043 1044 resp = models.AccountCreateResponse() 1045 resp.access_key = (plumbing_response.access_key) 1046 resp.account = plumbing.convert_account_to_porcelain( 1047 plumbing_response.account) 1048 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 1049 plumbing_response.meta) 1050 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1051 plumbing_response.rate_limit) 1052 resp.secret_key = (plumbing_response.secret_key) 1053 resp.token = (plumbing_response.token) 1054 return resp 1055 1056 def get(self, id, timeout=None): 1057 ''' 1058 Get reads one Account by ID. 1059 ''' 1060 deadline = None if timeout is None else time.time() + timeout 1061 req = AccountGetRequest() 1062 if self.parent.snapshot_datetime is not None: 1063 req.meta.CopyFrom(GetRequestMetadata()) 1064 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1065 1066 req.id = (id) 1067 tries = 0 1068 plumbing_response = None 1069 while True: 1070 t = None if deadline is None else deadline - time.time() 1071 try: 1072 plumbing_response = self.stub.Get( 1073 req, 1074 metadata=self.parent.get_metadata('Accounts.Get', req), 1075 timeout=t) 1076 except Exception as e: 1077 if self.parent.shouldRetry(tries, e, deadline): 1078 tries += 1 1079 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1080 continue 1081 raise plumbing.convert_error_to_porcelain(e) from e 1082 break 1083 1084 resp = models.AccountGetResponse() 1085 resp.account = plumbing.convert_account_to_porcelain( 1086 plumbing_response.account) 1087 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1088 plumbing_response.meta) 1089 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1090 plumbing_response.rate_limit) 1091 return resp 1092 1093 def update(self, account, timeout=None): 1094 ''' 1095 Update replaces all the fields of an Account by ID. 1096 ''' 1097 deadline = None if timeout is None else time.time() + timeout 1098 req = AccountUpdateRequest() 1099 1100 if account is not None: 1101 req.account.CopyFrom(plumbing.convert_account_to_plumbing(account)) 1102 tries = 0 1103 plumbing_response = None 1104 while True: 1105 t = None if deadline is None else deadline - time.time() 1106 try: 1107 plumbing_response = self.stub.Update( 1108 req, 1109 metadata=self.parent.get_metadata('Accounts.Update', req), 1110 timeout=t) 1111 except Exception as e: 1112 if self.parent.shouldRetry(tries, e, deadline): 1113 tries += 1 1114 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1115 continue 1116 raise plumbing.convert_error_to_porcelain(e) from e 1117 break 1118 1119 resp = models.AccountUpdateResponse() 1120 resp.account = plumbing.convert_account_to_porcelain( 1121 plumbing_response.account) 1122 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 1123 plumbing_response.meta) 1124 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1125 plumbing_response.rate_limit) 1126 return resp 1127 1128 def delete(self, id, timeout=None): 1129 ''' 1130 Delete removes an Account by ID. 1131 ''' 1132 deadline = None if timeout is None else time.time() + timeout 1133 req = AccountDeleteRequest() 1134 1135 req.id = (id) 1136 tries = 0 1137 plumbing_response = None 1138 while True: 1139 t = None if deadline is None else deadline - time.time() 1140 try: 1141 plumbing_response = self.stub.Delete( 1142 req, 1143 metadata=self.parent.get_metadata('Accounts.Delete', req), 1144 timeout=t) 1145 except Exception as e: 1146 if self.parent.shouldRetry(tries, e, deadline): 1147 tries += 1 1148 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1149 continue 1150 raise plumbing.convert_error_to_porcelain(e) from e 1151 break 1152 1153 resp = models.AccountDeleteResponse() 1154 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 1155 plumbing_response.meta) 1156 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1157 plumbing_response.rate_limit) 1158 return resp 1159 1160 def list(self, filter, *args, timeout=None): 1161 ''' 1162 List gets a list of Accounts matching a given set of criteria. 1163 ''' 1164 deadline = None if timeout is None else time.time() + timeout 1165 req = AccountListRequest() 1166 req.meta.CopyFrom(ListRequestMetadata()) 1167 if self.parent.page_limit > 0: 1168 req.meta.limit = self.parent.page_limit 1169 if self.parent.snapshot_datetime is not None: 1170 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1171 1172 req.filter = plumbing.quote_filter_args(filter, *args) 1173 1174 def generator(svc, req): 1175 tries = 0 1176 while True: 1177 t = None if deadline is None else deadline - time.time() 1178 try: 1179 plumbing_response = svc.stub.List( 1180 req, 1181 metadata=svc.parent.get_metadata('Accounts.List', req), 1182 timeout=t) 1183 except Exception as e: 1184 if self.parent.shouldRetry(tries, e, deadline): 1185 tries += 1 1186 time.sleep( 1187 self.parent.exponentialBackoff(tries, deadline)) 1188 continue 1189 raise plumbing.convert_error_to_porcelain(e) from e 1190 tries = 0 1191 for plumbing_item in plumbing_response.accounts: 1192 yield plumbing.convert_account_to_porcelain(plumbing_item) 1193 if plumbing_response.meta.next_cursor == '': 1194 break 1195 req.meta.cursor = plumbing_response.meta.next_cursor 1196 1197 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)
1018 def create(self, account, timeout=None): 1019 ''' 1020 Create registers a new Account. 1021 ''' 1022 deadline = None if timeout is None else time.time() + timeout 1023 req = AccountCreateRequest() 1024 1025 if account is not None: 1026 req.account.CopyFrom(plumbing.convert_account_to_plumbing(account)) 1027 tries = 0 1028 plumbing_response = None 1029 while True: 1030 t = None if deadline is None else deadline - time.time() 1031 try: 1032 plumbing_response = self.stub.Create( 1033 req, 1034 metadata=self.parent.get_metadata('Accounts.Create', req), 1035 timeout=t) 1036 except Exception as e: 1037 if self.parent.shouldRetry(tries, e, deadline): 1038 tries += 1 1039 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1040 continue 1041 raise plumbing.convert_error_to_porcelain(e) from e 1042 break 1043 1044 resp = models.AccountCreateResponse() 1045 resp.access_key = (plumbing_response.access_key) 1046 resp.account = plumbing.convert_account_to_porcelain( 1047 plumbing_response.account) 1048 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 1049 plumbing_response.meta) 1050 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1051 plumbing_response.rate_limit) 1052 resp.secret_key = (plumbing_response.secret_key) 1053 resp.token = (plumbing_response.token) 1054 return resp
Create registers a new Account.
def
get(self, id, timeout=None)
1056 def get(self, id, timeout=None): 1057 ''' 1058 Get reads one Account by ID. 1059 ''' 1060 deadline = None if timeout is None else time.time() + timeout 1061 req = AccountGetRequest() 1062 if self.parent.snapshot_datetime is not None: 1063 req.meta.CopyFrom(GetRequestMetadata()) 1064 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1065 1066 req.id = (id) 1067 tries = 0 1068 plumbing_response = None 1069 while True: 1070 t = None if deadline is None else deadline - time.time() 1071 try: 1072 plumbing_response = self.stub.Get( 1073 req, 1074 metadata=self.parent.get_metadata('Accounts.Get', req), 1075 timeout=t) 1076 except Exception as e: 1077 if self.parent.shouldRetry(tries, e, deadline): 1078 tries += 1 1079 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1080 continue 1081 raise plumbing.convert_error_to_porcelain(e) from e 1082 break 1083 1084 resp = models.AccountGetResponse() 1085 resp.account = plumbing.convert_account_to_porcelain( 1086 plumbing_response.account) 1087 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1088 plumbing_response.meta) 1089 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1090 plumbing_response.rate_limit) 1091 return resp
Get reads one Account by ID.
def
update(self, account, timeout=None)
1093 def update(self, account, timeout=None): 1094 ''' 1095 Update replaces all the fields of an Account by ID. 1096 ''' 1097 deadline = None if timeout is None else time.time() + timeout 1098 req = AccountUpdateRequest() 1099 1100 if account is not None: 1101 req.account.CopyFrom(plumbing.convert_account_to_plumbing(account)) 1102 tries = 0 1103 plumbing_response = None 1104 while True: 1105 t = None if deadline is None else deadline - time.time() 1106 try: 1107 plumbing_response = self.stub.Update( 1108 req, 1109 metadata=self.parent.get_metadata('Accounts.Update', req), 1110 timeout=t) 1111 except Exception as e: 1112 if self.parent.shouldRetry(tries, e, deadline): 1113 tries += 1 1114 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1115 continue 1116 raise plumbing.convert_error_to_porcelain(e) from e 1117 break 1118 1119 resp = models.AccountUpdateResponse() 1120 resp.account = plumbing.convert_account_to_porcelain( 1121 plumbing_response.account) 1122 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 1123 plumbing_response.meta) 1124 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1125 plumbing_response.rate_limit) 1126 return resp
Update replaces all the fields of an Account by ID.
def
delete(self, id, timeout=None)
1128 def delete(self, id, timeout=None): 1129 ''' 1130 Delete removes an Account by ID. 1131 ''' 1132 deadline = None if timeout is None else time.time() + timeout 1133 req = AccountDeleteRequest() 1134 1135 req.id = (id) 1136 tries = 0 1137 plumbing_response = None 1138 while True: 1139 t = None if deadline is None else deadline - time.time() 1140 try: 1141 plumbing_response = self.stub.Delete( 1142 req, 1143 metadata=self.parent.get_metadata('Accounts.Delete', req), 1144 timeout=t) 1145 except Exception as e: 1146 if self.parent.shouldRetry(tries, e, deadline): 1147 tries += 1 1148 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1149 continue 1150 raise plumbing.convert_error_to_porcelain(e) from e 1151 break 1152 1153 resp = models.AccountDeleteResponse() 1154 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 1155 plumbing_response.meta) 1156 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1157 plumbing_response.rate_limit) 1158 return resp
Delete removes an Account by ID.
def
list(self, filter, *args, timeout=None)
1160 def list(self, filter, *args, timeout=None): 1161 ''' 1162 List gets a list of Accounts matching a given set of criteria. 1163 ''' 1164 deadline = None if timeout is None else time.time() + timeout 1165 req = AccountListRequest() 1166 req.meta.CopyFrom(ListRequestMetadata()) 1167 if self.parent.page_limit > 0: 1168 req.meta.limit = self.parent.page_limit 1169 if self.parent.snapshot_datetime is not None: 1170 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1171 1172 req.filter = plumbing.quote_filter_args(filter, *args) 1173 1174 def generator(svc, req): 1175 tries = 0 1176 while True: 1177 t = None if deadline is None else deadline - time.time() 1178 try: 1179 plumbing_response = svc.stub.List( 1180 req, 1181 metadata=svc.parent.get_metadata('Accounts.List', req), 1182 timeout=t) 1183 except Exception as e: 1184 if self.parent.shouldRetry(tries, e, deadline): 1185 tries += 1 1186 time.sleep( 1187 self.parent.exponentialBackoff(tries, deadline)) 1188 continue 1189 raise plumbing.convert_error_to_porcelain(e) from e 1190 tries = 0 1191 for plumbing_item in plumbing_response.accounts: 1192 yield plumbing.convert_account_to_porcelain(plumbing_item) 1193 if plumbing_response.meta.next_cursor == '': 1194 break 1195 req.meta.cursor = plumbing_response.meta.next_cursor 1196 1197 return generator(self, req)
List gets a list of Accounts matching a given set of criteria.
class
SnapshotAccounts:
1200class SnapshotAccounts: 1201 ''' 1202 SnapshotAccounts exposes the read only methods of the Accounts 1203 service for historical queries. 1204 ''' 1205 def __init__(self, accounts): 1206 self.accounts = accounts 1207 1208 def get(self, id, timeout=None): 1209 ''' 1210 Get reads one Account by ID. 1211 ''' 1212 return self.accounts.get(id, timeout=timeout) 1213 1214 def list(self, filter, *args, timeout=None): 1215 ''' 1216 List gets a list of Accounts matching a given set of criteria. 1217 ''' 1218 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)
1208 def get(self, id, timeout=None): 1209 ''' 1210 Get reads one Account by ID. 1211 ''' 1212 return self.accounts.get(id, timeout=timeout)
Get reads one Account by ID.
def
list(self, filter, *args, timeout=None)
1214 def list(self, filter, *args, timeout=None): 1215 ''' 1216 List gets a list of Accounts matching a given set of criteria. 1217 ''' 1218 return self.accounts.list(filter, *args, timeout=timeout)
List gets a list of Accounts matching a given set of criteria.
class
AccountsGroups:
1221class AccountsGroups: 1222 ''' 1223 An AccountGroup links an account and a group. 1224 See `strongdm.models.AccountGroup`. 1225 ''' 1226 def __init__(self, channel, client): 1227 self.parent = client 1228 self.stub = AccountsGroupsStub(channel) 1229 1230 def create(self, account_group, timeout=None): 1231 ''' 1232 Create create a new AccountGroup. 1233 ''' 1234 deadline = None if timeout is None else time.time() + timeout 1235 req = AccountGroupCreateRequest() 1236 1237 if account_group is not None: 1238 req.account_group.CopyFrom( 1239 plumbing.convert_account_group_to_plumbing(account_group)) 1240 tries = 0 1241 plumbing_response = None 1242 while True: 1243 t = None if deadline is None else deadline - time.time() 1244 try: 1245 plumbing_response = self.stub.Create( 1246 req, 1247 metadata=self.parent.get_metadata('AccountsGroups.Create', 1248 req), 1249 timeout=t) 1250 except Exception as e: 1251 if self.parent.shouldRetry(tries, e, deadline): 1252 tries += 1 1253 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1254 continue 1255 raise plumbing.convert_error_to_porcelain(e) from e 1256 break 1257 1258 resp = models.AccountGroupCreateResponse() 1259 resp.account_group = plumbing.convert_account_group_to_porcelain( 1260 plumbing_response.account_group) 1261 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1262 plumbing_response.rate_limit) 1263 return resp 1264 1265 def get(self, id, timeout=None): 1266 ''' 1267 Get reads one AccountGroup by ID. 1268 ''' 1269 deadline = None if timeout is None else time.time() + timeout 1270 req = AccountGroupGetRequest() 1271 if self.parent.snapshot_datetime is not None: 1272 req.meta.CopyFrom(GetRequestMetadata()) 1273 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1274 1275 req.id = (id) 1276 tries = 0 1277 plumbing_response = None 1278 while True: 1279 t = None if deadline is None else deadline - time.time() 1280 try: 1281 plumbing_response = self.stub.Get( 1282 req, 1283 metadata=self.parent.get_metadata('AccountsGroups.Get', 1284 req), 1285 timeout=t) 1286 except Exception as e: 1287 if self.parent.shouldRetry(tries, e, deadline): 1288 tries += 1 1289 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1290 continue 1291 raise plumbing.convert_error_to_porcelain(e) from e 1292 break 1293 1294 resp = models.AccountGroupGetResponse() 1295 resp.account_group = plumbing.convert_account_group_to_porcelain( 1296 plumbing_response.account_group) 1297 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1298 plumbing_response.meta) 1299 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1300 plumbing_response.rate_limit) 1301 return resp 1302 1303 def delete(self, id, timeout=None): 1304 ''' 1305 Delete removes an AccountGroup by ID. 1306 ''' 1307 deadline = None if timeout is None else time.time() + timeout 1308 req = AccountGroupDeleteRequest() 1309 1310 req.id = (id) 1311 tries = 0 1312 plumbing_response = None 1313 while True: 1314 t = None if deadline is None else deadline - time.time() 1315 try: 1316 plumbing_response = self.stub.Delete( 1317 req, 1318 metadata=self.parent.get_metadata('AccountsGroups.Delete', 1319 req), 1320 timeout=t) 1321 except Exception as e: 1322 if self.parent.shouldRetry(tries, e, deadline): 1323 tries += 1 1324 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1325 continue 1326 raise plumbing.convert_error_to_porcelain(e) from e 1327 break 1328 1329 resp = models.AccountGroupDeleteResponse() 1330 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 1331 plumbing_response.meta) 1332 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1333 plumbing_response.rate_limit) 1334 return resp 1335 1336 def list(self, filter, *args, timeout=None): 1337 ''' 1338 List gets a list of AccountGroups matching a given set of criteria. 1339 ''' 1340 deadline = None if timeout is None else time.time() + timeout 1341 req = AccountGroupListRequest() 1342 req.meta.CopyFrom(ListRequestMetadata()) 1343 if self.parent.page_limit > 0: 1344 req.meta.limit = self.parent.page_limit 1345 if self.parent.snapshot_datetime is not None: 1346 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1347 1348 req.filter = plumbing.quote_filter_args(filter, *args) 1349 1350 def generator(svc, req): 1351 tries = 0 1352 while True: 1353 t = None if deadline is None else deadline - time.time() 1354 try: 1355 plumbing_response = svc.stub.List( 1356 req, 1357 metadata=svc.parent.get_metadata( 1358 'AccountsGroups.List', req), 1359 timeout=t) 1360 except Exception as e: 1361 if self.parent.shouldRetry(tries, e, deadline): 1362 tries += 1 1363 time.sleep( 1364 self.parent.exponentialBackoff(tries, deadline)) 1365 continue 1366 raise plumbing.convert_error_to_porcelain(e) from e 1367 tries = 0 1368 for plumbing_item in plumbing_response.account_groups: 1369 yield plumbing.convert_account_group_to_porcelain( 1370 plumbing_item) 1371 if plumbing_response.meta.next_cursor == '': 1372 break 1373 req.meta.cursor = plumbing_response.meta.next_cursor 1374 1375 return generator(self, req)
An AccountGroup links an account and a group.
See strongdm.models.AccountGroup.
def
create(self, account_group, timeout=None)
1230 def create(self, account_group, timeout=None): 1231 ''' 1232 Create create a new AccountGroup. 1233 ''' 1234 deadline = None if timeout is None else time.time() + timeout 1235 req = AccountGroupCreateRequest() 1236 1237 if account_group is not None: 1238 req.account_group.CopyFrom( 1239 plumbing.convert_account_group_to_plumbing(account_group)) 1240 tries = 0 1241 plumbing_response = None 1242 while True: 1243 t = None if deadline is None else deadline - time.time() 1244 try: 1245 plumbing_response = self.stub.Create( 1246 req, 1247 metadata=self.parent.get_metadata('AccountsGroups.Create', 1248 req), 1249 timeout=t) 1250 except Exception as e: 1251 if self.parent.shouldRetry(tries, e, deadline): 1252 tries += 1 1253 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1254 continue 1255 raise plumbing.convert_error_to_porcelain(e) from e 1256 break 1257 1258 resp = models.AccountGroupCreateResponse() 1259 resp.account_group = plumbing.convert_account_group_to_porcelain( 1260 plumbing_response.account_group) 1261 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1262 plumbing_response.rate_limit) 1263 return resp
Create create a new AccountGroup.
def
get(self, id, timeout=None)
1265 def get(self, id, timeout=None): 1266 ''' 1267 Get reads one AccountGroup by ID. 1268 ''' 1269 deadline = None if timeout is None else time.time() + timeout 1270 req = AccountGroupGetRequest() 1271 if self.parent.snapshot_datetime is not None: 1272 req.meta.CopyFrom(GetRequestMetadata()) 1273 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1274 1275 req.id = (id) 1276 tries = 0 1277 plumbing_response = None 1278 while True: 1279 t = None if deadline is None else deadline - time.time() 1280 try: 1281 plumbing_response = self.stub.Get( 1282 req, 1283 metadata=self.parent.get_metadata('AccountsGroups.Get', 1284 req), 1285 timeout=t) 1286 except Exception as e: 1287 if self.parent.shouldRetry(tries, e, deadline): 1288 tries += 1 1289 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1290 continue 1291 raise plumbing.convert_error_to_porcelain(e) from e 1292 break 1293 1294 resp = models.AccountGroupGetResponse() 1295 resp.account_group = plumbing.convert_account_group_to_porcelain( 1296 plumbing_response.account_group) 1297 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1298 plumbing_response.meta) 1299 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1300 plumbing_response.rate_limit) 1301 return resp
Get reads one AccountGroup by ID.
def
delete(self, id, timeout=None)
1303 def delete(self, id, timeout=None): 1304 ''' 1305 Delete removes an AccountGroup by ID. 1306 ''' 1307 deadline = None if timeout is None else time.time() + timeout 1308 req = AccountGroupDeleteRequest() 1309 1310 req.id = (id) 1311 tries = 0 1312 plumbing_response = None 1313 while True: 1314 t = None if deadline is None else deadline - time.time() 1315 try: 1316 plumbing_response = self.stub.Delete( 1317 req, 1318 metadata=self.parent.get_metadata('AccountsGroups.Delete', 1319 req), 1320 timeout=t) 1321 except Exception as e: 1322 if self.parent.shouldRetry(tries, e, deadline): 1323 tries += 1 1324 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1325 continue 1326 raise plumbing.convert_error_to_porcelain(e) from e 1327 break 1328 1329 resp = models.AccountGroupDeleteResponse() 1330 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 1331 plumbing_response.meta) 1332 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1333 plumbing_response.rate_limit) 1334 return resp
Delete removes an AccountGroup by ID.
def
list(self, filter, *args, timeout=None)
1336 def list(self, filter, *args, timeout=None): 1337 ''' 1338 List gets a list of AccountGroups matching a given set of criteria. 1339 ''' 1340 deadline = None if timeout is None else time.time() + timeout 1341 req = AccountGroupListRequest() 1342 req.meta.CopyFrom(ListRequestMetadata()) 1343 if self.parent.page_limit > 0: 1344 req.meta.limit = self.parent.page_limit 1345 if self.parent.snapshot_datetime is not None: 1346 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1347 1348 req.filter = plumbing.quote_filter_args(filter, *args) 1349 1350 def generator(svc, req): 1351 tries = 0 1352 while True: 1353 t = None if deadline is None else deadline - time.time() 1354 try: 1355 plumbing_response = svc.stub.List( 1356 req, 1357 metadata=svc.parent.get_metadata( 1358 'AccountsGroups.List', req), 1359 timeout=t) 1360 except Exception as e: 1361 if self.parent.shouldRetry(tries, e, deadline): 1362 tries += 1 1363 time.sleep( 1364 self.parent.exponentialBackoff(tries, deadline)) 1365 continue 1366 raise plumbing.convert_error_to_porcelain(e) from e 1367 tries = 0 1368 for plumbing_item in plumbing_response.account_groups: 1369 yield plumbing.convert_account_group_to_porcelain( 1370 plumbing_item) 1371 if plumbing_response.meta.next_cursor == '': 1372 break 1373 req.meta.cursor = plumbing_response.meta.next_cursor 1374 1375 return generator(self, req)
List gets a list of AccountGroups matching a given set of criteria.
class
SnapshotAccountsGroups:
1378class SnapshotAccountsGroups: 1379 ''' 1380 SnapshotAccountsGroups exposes the read only methods of the AccountsGroups 1381 service for historical queries. 1382 ''' 1383 def __init__(self, accounts_groups): 1384 self.accounts_groups = accounts_groups 1385 1386 def get(self, id, timeout=None): 1387 ''' 1388 Get reads one AccountGroup by ID. 1389 ''' 1390 return self.accounts_groups.get(id, timeout=timeout) 1391 1392 def list(self, filter, *args, timeout=None): 1393 ''' 1394 List gets a list of AccountGroups matching a given set of criteria. 1395 ''' 1396 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)
1386 def get(self, id, timeout=None): 1387 ''' 1388 Get reads one AccountGroup by ID. 1389 ''' 1390 return self.accounts_groups.get(id, timeout=timeout)
Get reads one AccountGroup by ID.
def
list(self, filter, *args, timeout=None)
1392 def list(self, filter, *args, timeout=None): 1393 ''' 1394 List gets a list of AccountGroups matching a given set of criteria. 1395 ''' 1396 return self.accounts_groups.list(filter, *args, timeout=timeout)
List gets a list of AccountGroups matching a given set of criteria.
class
AccountsGroupsHistory:
1399class AccountsGroupsHistory: 1400 ''' 1401 AccountsGroupsHistory records all changes to the state of an AccountGroup. 1402 See `strongdm.models.AccountGroupHistory`. 1403 ''' 1404 def __init__(self, channel, client): 1405 self.parent = client 1406 self.stub = AccountsGroupsHistoryStub(channel) 1407 1408 def list(self, filter, *args, timeout=None): 1409 ''' 1410 List gets a list of AccountGroupHistory records matching a given set of criteria. 1411 ''' 1412 deadline = None if timeout is None else time.time() + timeout 1413 req = AccountGroupHistoryListRequest() 1414 req.meta.CopyFrom(ListRequestMetadata()) 1415 if self.parent.page_limit > 0: 1416 req.meta.limit = self.parent.page_limit 1417 if self.parent.snapshot_datetime is not None: 1418 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1419 1420 req.filter = plumbing.quote_filter_args(filter, *args) 1421 1422 def generator(svc, req): 1423 tries = 0 1424 while True: 1425 t = None if deadline is None else deadline - time.time() 1426 try: 1427 plumbing_response = svc.stub.List( 1428 req, 1429 metadata=svc.parent.get_metadata( 1430 'AccountsGroupsHistory.List', req), 1431 timeout=t) 1432 except Exception as e: 1433 if self.parent.shouldRetry(tries, e, deadline): 1434 tries += 1 1435 time.sleep( 1436 self.parent.exponentialBackoff(tries, deadline)) 1437 continue 1438 raise plumbing.convert_error_to_porcelain(e) from e 1439 tries = 0 1440 for plumbing_item in plumbing_response.history: 1441 yield plumbing.convert_account_group_history_to_porcelain( 1442 plumbing_item) 1443 if plumbing_response.meta.next_cursor == '': 1444 break 1445 req.meta.cursor = plumbing_response.meta.next_cursor 1446 1447 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)
1408 def list(self, filter, *args, timeout=None): 1409 ''' 1410 List gets a list of AccountGroupHistory records matching a given set of criteria. 1411 ''' 1412 deadline = None if timeout is None else time.time() + timeout 1413 req = AccountGroupHistoryListRequest() 1414 req.meta.CopyFrom(ListRequestMetadata()) 1415 if self.parent.page_limit > 0: 1416 req.meta.limit = self.parent.page_limit 1417 if self.parent.snapshot_datetime is not None: 1418 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1419 1420 req.filter = plumbing.quote_filter_args(filter, *args) 1421 1422 def generator(svc, req): 1423 tries = 0 1424 while True: 1425 t = None if deadline is None else deadline - time.time() 1426 try: 1427 plumbing_response = svc.stub.List( 1428 req, 1429 metadata=svc.parent.get_metadata( 1430 'AccountsGroupsHistory.List', req), 1431 timeout=t) 1432 except Exception as e: 1433 if self.parent.shouldRetry(tries, e, deadline): 1434 tries += 1 1435 time.sleep( 1436 self.parent.exponentialBackoff(tries, deadline)) 1437 continue 1438 raise plumbing.convert_error_to_porcelain(e) from e 1439 tries = 0 1440 for plumbing_item in plumbing_response.history: 1441 yield plumbing.convert_account_group_history_to_porcelain( 1442 plumbing_item) 1443 if plumbing_response.meta.next_cursor == '': 1444 break 1445 req.meta.cursor = plumbing_response.meta.next_cursor 1446 1447 return generator(self, req)
List gets a list of AccountGroupHistory records matching a given set of criteria.
class
AccountsHistory:
1450class AccountsHistory: 1451 ''' 1452 AccountsHistory records all changes to the state of an Account. 1453 See `strongdm.models.AccountHistory`. 1454 ''' 1455 def __init__(self, channel, client): 1456 self.parent = client 1457 self.stub = AccountsHistoryStub(channel) 1458 1459 def list(self, filter, *args, timeout=None): 1460 ''' 1461 List gets a list of AccountHistory records matching a given set of criteria. 1462 ''' 1463 deadline = None if timeout is None else time.time() + timeout 1464 req = AccountHistoryListRequest() 1465 req.meta.CopyFrom(ListRequestMetadata()) 1466 if self.parent.page_limit > 0: 1467 req.meta.limit = self.parent.page_limit 1468 if self.parent.snapshot_datetime is not None: 1469 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1470 1471 req.filter = plumbing.quote_filter_args(filter, *args) 1472 1473 def generator(svc, req): 1474 tries = 0 1475 while True: 1476 t = None if deadline is None else deadline - time.time() 1477 try: 1478 plumbing_response = svc.stub.List( 1479 req, 1480 metadata=svc.parent.get_metadata( 1481 'AccountsHistory.List', req), 1482 timeout=t) 1483 except Exception as e: 1484 if self.parent.shouldRetry(tries, e, deadline): 1485 tries += 1 1486 time.sleep( 1487 self.parent.exponentialBackoff(tries, deadline)) 1488 continue 1489 raise plumbing.convert_error_to_porcelain(e) from e 1490 tries = 0 1491 for plumbing_item in plumbing_response.history: 1492 yield plumbing.convert_account_history_to_porcelain( 1493 plumbing_item) 1494 if plumbing_response.meta.next_cursor == '': 1495 break 1496 req.meta.cursor = plumbing_response.meta.next_cursor 1497 1498 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)
1459 def list(self, filter, *args, timeout=None): 1460 ''' 1461 List gets a list of AccountHistory records matching a given set of criteria. 1462 ''' 1463 deadline = None if timeout is None else time.time() + timeout 1464 req = AccountHistoryListRequest() 1465 req.meta.CopyFrom(ListRequestMetadata()) 1466 if self.parent.page_limit > 0: 1467 req.meta.limit = self.parent.page_limit 1468 if self.parent.snapshot_datetime is not None: 1469 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1470 1471 req.filter = plumbing.quote_filter_args(filter, *args) 1472 1473 def generator(svc, req): 1474 tries = 0 1475 while True: 1476 t = None if deadline is None else deadline - time.time() 1477 try: 1478 plumbing_response = svc.stub.List( 1479 req, 1480 metadata=svc.parent.get_metadata( 1481 'AccountsHistory.List', req), 1482 timeout=t) 1483 except Exception as e: 1484 if self.parent.shouldRetry(tries, e, deadline): 1485 tries += 1 1486 time.sleep( 1487 self.parent.exponentialBackoff(tries, deadline)) 1488 continue 1489 raise plumbing.convert_error_to_porcelain(e) from e 1490 tries = 0 1491 for plumbing_item in plumbing_response.history: 1492 yield plumbing.convert_account_history_to_porcelain( 1493 plumbing_item) 1494 if plumbing_response.meta.next_cursor == '': 1495 break 1496 req.meta.cursor = plumbing_response.meta.next_cursor 1497 1498 return generator(self, req)
List gets a list of AccountHistory records matching a given set of criteria.
class
Activities:
1501class Activities: 1502 ''' 1503 An Activity is a record of an action taken against a strongDM deployment, e.g. 1504 a user creation, resource deletion, sso configuration change, etc. The Activities 1505 service is read-only. 1506 See `strongdm.models.Activity`. 1507 ''' 1508 def __init__(self, channel, client): 1509 self.parent = client 1510 self.stub = ActivitiesStub(channel) 1511 1512 def get(self, id, timeout=None): 1513 ''' 1514 Get reads one Activity by ID. 1515 ''' 1516 deadline = None if timeout is None else time.time() + timeout 1517 req = ActivityGetRequest() 1518 if self.parent.snapshot_datetime is not None: 1519 req.meta.CopyFrom(GetRequestMetadata()) 1520 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1521 1522 req.id = (id) 1523 tries = 0 1524 plumbing_response = None 1525 while True: 1526 t = None if deadline is None else deadline - time.time() 1527 try: 1528 plumbing_response = self.stub.Get( 1529 req, 1530 metadata=self.parent.get_metadata('Activities.Get', req), 1531 timeout=t) 1532 except Exception as e: 1533 if self.parent.shouldRetry(tries, e, deadline): 1534 tries += 1 1535 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1536 continue 1537 raise plumbing.convert_error_to_porcelain(e) from e 1538 break 1539 1540 resp = models.ActivityGetResponse() 1541 resp.activity = plumbing.convert_activity_to_porcelain( 1542 plumbing_response.activity) 1543 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1544 plumbing_response.meta) 1545 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1546 plumbing_response.rate_limit) 1547 return resp 1548 1549 def list(self, filter, *args, timeout=None): 1550 ''' 1551 List gets a list of Activities matching a given set of criteria. 1552 The 'before' and 'after' filters can be used to control the time 1553 range of the output activities. If not provided, one week of back 1554 of activities will be returned. 1555 ''' 1556 deadline = None if timeout is None else time.time() + timeout 1557 req = ActivityListRequest() 1558 req.meta.CopyFrom(ListRequestMetadata()) 1559 if self.parent.page_limit > 0: 1560 req.meta.limit = self.parent.page_limit 1561 if self.parent.snapshot_datetime is not None: 1562 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1563 1564 req.filter = plumbing.quote_filter_args(filter, *args) 1565 1566 def generator(svc, req): 1567 tries = 0 1568 while True: 1569 t = None if deadline is None else deadline - time.time() 1570 try: 1571 plumbing_response = svc.stub.List( 1572 req, 1573 metadata=svc.parent.get_metadata( 1574 'Activities.List', req), 1575 timeout=t) 1576 except Exception as e: 1577 if self.parent.shouldRetry(tries, e, deadline): 1578 tries += 1 1579 time.sleep( 1580 self.parent.exponentialBackoff(tries, deadline)) 1581 continue 1582 raise plumbing.convert_error_to_porcelain(e) from e 1583 tries = 0 1584 for plumbing_item in plumbing_response.activities: 1585 yield plumbing.convert_activity_to_porcelain(plumbing_item) 1586 if plumbing_response.meta.next_cursor == '': 1587 break 1588 req.meta.cursor = plumbing_response.meta.next_cursor 1589 1590 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)
1512 def get(self, id, timeout=None): 1513 ''' 1514 Get reads one Activity by ID. 1515 ''' 1516 deadline = None if timeout is None else time.time() + timeout 1517 req = ActivityGetRequest() 1518 if self.parent.snapshot_datetime is not None: 1519 req.meta.CopyFrom(GetRequestMetadata()) 1520 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1521 1522 req.id = (id) 1523 tries = 0 1524 plumbing_response = None 1525 while True: 1526 t = None if deadline is None else deadline - time.time() 1527 try: 1528 plumbing_response = self.stub.Get( 1529 req, 1530 metadata=self.parent.get_metadata('Activities.Get', req), 1531 timeout=t) 1532 except Exception as e: 1533 if self.parent.shouldRetry(tries, e, deadline): 1534 tries += 1 1535 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1536 continue 1537 raise plumbing.convert_error_to_porcelain(e) from e 1538 break 1539 1540 resp = models.ActivityGetResponse() 1541 resp.activity = plumbing.convert_activity_to_porcelain( 1542 plumbing_response.activity) 1543 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1544 plumbing_response.meta) 1545 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1546 plumbing_response.rate_limit) 1547 return resp
Get reads one Activity by ID.
def
list(self, filter, *args, timeout=None)
1549 def list(self, filter, *args, timeout=None): 1550 ''' 1551 List gets a list of Activities matching a given set of criteria. 1552 The 'before' and 'after' filters can be used to control the time 1553 range of the output activities. If not provided, one week of back 1554 of activities will be returned. 1555 ''' 1556 deadline = None if timeout is None else time.time() + timeout 1557 req = ActivityListRequest() 1558 req.meta.CopyFrom(ListRequestMetadata()) 1559 if self.parent.page_limit > 0: 1560 req.meta.limit = self.parent.page_limit 1561 if self.parent.snapshot_datetime is not None: 1562 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1563 1564 req.filter = plumbing.quote_filter_args(filter, *args) 1565 1566 def generator(svc, req): 1567 tries = 0 1568 while True: 1569 t = None if deadline is None else deadline - time.time() 1570 try: 1571 plumbing_response = svc.stub.List( 1572 req, 1573 metadata=svc.parent.get_metadata( 1574 'Activities.List', req), 1575 timeout=t) 1576 except Exception as e: 1577 if self.parent.shouldRetry(tries, e, deadline): 1578 tries += 1 1579 time.sleep( 1580 self.parent.exponentialBackoff(tries, deadline)) 1581 continue 1582 raise plumbing.convert_error_to_porcelain(e) from e 1583 tries = 0 1584 for plumbing_item in plumbing_response.activities: 1585 yield plumbing.convert_activity_to_porcelain(plumbing_item) 1586 if plumbing_response.meta.next_cursor == '': 1587 break 1588 req.meta.cursor = plumbing_response.meta.next_cursor 1589 1590 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:
1593class ApprovalWorkflowApprovers: 1594 ''' 1595 ApprovalWorkflowApprovers link approval workflow approvers to an ApprovalWorkflowStep 1596 See `strongdm.models.ApprovalWorkflowApprover`. 1597 ''' 1598 def __init__(self, channel, client): 1599 self.parent = client 1600 self.stub = ApprovalWorkflowApproversStub(channel) 1601 1602 def create(self, approval_workflow_approver, timeout=None): 1603 ''' 1604 Deprecated: Create creates a new approval workflow approver. 1605 ''' 1606 deadline = None if timeout is None else time.time() + timeout 1607 req = ApprovalWorkflowApproverCreateRequest() 1608 1609 if approval_workflow_approver is not None: 1610 req.approval_workflow_approver.CopyFrom( 1611 plumbing.convert_approval_workflow_approver_to_plumbing( 1612 approval_workflow_approver)) 1613 tries = 0 1614 plumbing_response = None 1615 while True: 1616 t = None if deadline is None else deadline - time.time() 1617 try: 1618 plumbing_response = self.stub.Create( 1619 req, 1620 metadata=self.parent.get_metadata( 1621 'ApprovalWorkflowApprovers.Create', req), 1622 timeout=t) 1623 except Exception as e: 1624 if self.parent.shouldRetry(tries, e, deadline): 1625 tries += 1 1626 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1627 continue 1628 raise plumbing.convert_error_to_porcelain(e) from e 1629 break 1630 1631 resp = models.ApprovalWorkflowApproverCreateResponse() 1632 resp.approval_workflow_approver = plumbing.convert_approval_workflow_approver_to_porcelain( 1633 plumbing_response.approval_workflow_approver) 1634 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1635 plumbing_response.rate_limit) 1636 return resp 1637 1638 def get(self, id, timeout=None): 1639 ''' 1640 Deprecated: Get reads one approval workflow approver by ID. 1641 ''' 1642 deadline = None if timeout is None else time.time() + timeout 1643 req = ApprovalWorkflowApproverGetRequest() 1644 if self.parent.snapshot_datetime is not None: 1645 req.meta.CopyFrom(GetRequestMetadata()) 1646 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1647 1648 req.id = (id) 1649 tries = 0 1650 plumbing_response = None 1651 while True: 1652 t = None if deadline is None else deadline - time.time() 1653 try: 1654 plumbing_response = self.stub.Get( 1655 req, 1656 metadata=self.parent.get_metadata( 1657 'ApprovalWorkflowApprovers.Get', req), 1658 timeout=t) 1659 except Exception as e: 1660 if self.parent.shouldRetry(tries, e, deadline): 1661 tries += 1 1662 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1663 continue 1664 raise plumbing.convert_error_to_porcelain(e) from e 1665 break 1666 1667 resp = models.ApprovalWorkflowApproverGetResponse() 1668 resp.approval_workflow_approver = plumbing.convert_approval_workflow_approver_to_porcelain( 1669 plumbing_response.approval_workflow_approver) 1670 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1671 plumbing_response.meta) 1672 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1673 plumbing_response.rate_limit) 1674 return resp 1675 1676 def delete(self, id, timeout=None): 1677 ''' 1678 Deprecated: Delete deletes an existing approval workflow approver. 1679 ''' 1680 deadline = None if timeout is None else time.time() + timeout 1681 req = ApprovalWorkflowApproverDeleteRequest() 1682 1683 req.id = (id) 1684 tries = 0 1685 plumbing_response = None 1686 while True: 1687 t = None if deadline is None else deadline - time.time() 1688 try: 1689 plumbing_response = self.stub.Delete( 1690 req, 1691 metadata=self.parent.get_metadata( 1692 'ApprovalWorkflowApprovers.Delete', req), 1693 timeout=t) 1694 except Exception as e: 1695 if self.parent.shouldRetry(tries, e, deadline): 1696 tries += 1 1697 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1698 continue 1699 raise plumbing.convert_error_to_porcelain(e) from e 1700 break 1701 1702 resp = models.ApprovalWorkflowApproverDeleteResponse() 1703 resp.id = (plumbing_response.id) 1704 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1705 plumbing_response.rate_limit) 1706 return resp 1707 1708 def list(self, filter, *args, timeout=None): 1709 ''' 1710 Deprecated: Lists existing approval workflow approvers. 1711 ''' 1712 deadline = None if timeout is None else time.time() + timeout 1713 req = ApprovalWorkflowApproverListRequest() 1714 req.meta.CopyFrom(ListRequestMetadata()) 1715 if self.parent.page_limit > 0: 1716 req.meta.limit = self.parent.page_limit 1717 if self.parent.snapshot_datetime is not None: 1718 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1719 1720 req.filter = plumbing.quote_filter_args(filter, *args) 1721 1722 def generator(svc, req): 1723 tries = 0 1724 while True: 1725 t = None if deadline is None else deadline - time.time() 1726 try: 1727 plumbing_response = svc.stub.List( 1728 req, 1729 metadata=svc.parent.get_metadata( 1730 'ApprovalWorkflowApprovers.List', req), 1731 timeout=t) 1732 except Exception as e: 1733 if self.parent.shouldRetry(tries, e, deadline): 1734 tries += 1 1735 time.sleep( 1736 self.parent.exponentialBackoff(tries, deadline)) 1737 continue 1738 raise plumbing.convert_error_to_porcelain(e) from e 1739 tries = 0 1740 for plumbing_item in plumbing_response.approval_workflow_approvers: 1741 yield plumbing.convert_approval_workflow_approver_to_porcelain( 1742 plumbing_item) 1743 if plumbing_response.meta.next_cursor == '': 1744 break 1745 req.meta.cursor = plumbing_response.meta.next_cursor 1746 1747 return generator(self, req)
ApprovalWorkflowApprovers link approval workflow approvers to an ApprovalWorkflowStep
See strongdm.models.ApprovalWorkflowApprover.
def
create(self, approval_workflow_approver, timeout=None)
1602 def create(self, approval_workflow_approver, timeout=None): 1603 ''' 1604 Deprecated: Create creates a new approval workflow approver. 1605 ''' 1606 deadline = None if timeout is None else time.time() + timeout 1607 req = ApprovalWorkflowApproverCreateRequest() 1608 1609 if approval_workflow_approver is not None: 1610 req.approval_workflow_approver.CopyFrom( 1611 plumbing.convert_approval_workflow_approver_to_plumbing( 1612 approval_workflow_approver)) 1613 tries = 0 1614 plumbing_response = None 1615 while True: 1616 t = None if deadline is None else deadline - time.time() 1617 try: 1618 plumbing_response = self.stub.Create( 1619 req, 1620 metadata=self.parent.get_metadata( 1621 'ApprovalWorkflowApprovers.Create', req), 1622 timeout=t) 1623 except Exception as e: 1624 if self.parent.shouldRetry(tries, e, deadline): 1625 tries += 1 1626 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1627 continue 1628 raise plumbing.convert_error_to_porcelain(e) from e 1629 break 1630 1631 resp = models.ApprovalWorkflowApproverCreateResponse() 1632 resp.approval_workflow_approver = plumbing.convert_approval_workflow_approver_to_porcelain( 1633 plumbing_response.approval_workflow_approver) 1634 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1635 plumbing_response.rate_limit) 1636 return resp
Deprecated: Create creates a new approval workflow approver.
def
get(self, id, timeout=None)
1638 def get(self, id, timeout=None): 1639 ''' 1640 Deprecated: Get reads one approval workflow approver by ID. 1641 ''' 1642 deadline = None if timeout is None else time.time() + timeout 1643 req = ApprovalWorkflowApproverGetRequest() 1644 if self.parent.snapshot_datetime is not None: 1645 req.meta.CopyFrom(GetRequestMetadata()) 1646 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1647 1648 req.id = (id) 1649 tries = 0 1650 plumbing_response = None 1651 while True: 1652 t = None if deadline is None else deadline - time.time() 1653 try: 1654 plumbing_response = self.stub.Get( 1655 req, 1656 metadata=self.parent.get_metadata( 1657 'ApprovalWorkflowApprovers.Get', req), 1658 timeout=t) 1659 except Exception as e: 1660 if self.parent.shouldRetry(tries, e, deadline): 1661 tries += 1 1662 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1663 continue 1664 raise plumbing.convert_error_to_porcelain(e) from e 1665 break 1666 1667 resp = models.ApprovalWorkflowApproverGetResponse() 1668 resp.approval_workflow_approver = plumbing.convert_approval_workflow_approver_to_porcelain( 1669 plumbing_response.approval_workflow_approver) 1670 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1671 plumbing_response.meta) 1672 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1673 plumbing_response.rate_limit) 1674 return resp
Deprecated: Get reads one approval workflow approver by ID.
def
delete(self, id, timeout=None)
1676 def delete(self, id, timeout=None): 1677 ''' 1678 Deprecated: Delete deletes an existing approval workflow approver. 1679 ''' 1680 deadline = None if timeout is None else time.time() + timeout 1681 req = ApprovalWorkflowApproverDeleteRequest() 1682 1683 req.id = (id) 1684 tries = 0 1685 plumbing_response = None 1686 while True: 1687 t = None if deadline is None else deadline - time.time() 1688 try: 1689 plumbing_response = self.stub.Delete( 1690 req, 1691 metadata=self.parent.get_metadata( 1692 'ApprovalWorkflowApprovers.Delete', req), 1693 timeout=t) 1694 except Exception as e: 1695 if self.parent.shouldRetry(tries, e, deadline): 1696 tries += 1 1697 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1698 continue 1699 raise plumbing.convert_error_to_porcelain(e) from e 1700 break 1701 1702 resp = models.ApprovalWorkflowApproverDeleteResponse() 1703 resp.id = (plumbing_response.id) 1704 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1705 plumbing_response.rate_limit) 1706 return resp
Deprecated: Delete deletes an existing approval workflow approver.
def
list(self, filter, *args, timeout=None)
1708 def list(self, filter, *args, timeout=None): 1709 ''' 1710 Deprecated: Lists existing approval workflow approvers. 1711 ''' 1712 deadline = None if timeout is None else time.time() + timeout 1713 req = ApprovalWorkflowApproverListRequest() 1714 req.meta.CopyFrom(ListRequestMetadata()) 1715 if self.parent.page_limit > 0: 1716 req.meta.limit = self.parent.page_limit 1717 if self.parent.snapshot_datetime is not None: 1718 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1719 1720 req.filter = plumbing.quote_filter_args(filter, *args) 1721 1722 def generator(svc, req): 1723 tries = 0 1724 while True: 1725 t = None if deadline is None else deadline - time.time() 1726 try: 1727 plumbing_response = svc.stub.List( 1728 req, 1729 metadata=svc.parent.get_metadata( 1730 'ApprovalWorkflowApprovers.List', req), 1731 timeout=t) 1732 except Exception as e: 1733 if self.parent.shouldRetry(tries, e, deadline): 1734 tries += 1 1735 time.sleep( 1736 self.parent.exponentialBackoff(tries, deadline)) 1737 continue 1738 raise plumbing.convert_error_to_porcelain(e) from e 1739 tries = 0 1740 for plumbing_item in plumbing_response.approval_workflow_approvers: 1741 yield plumbing.convert_approval_workflow_approver_to_porcelain( 1742 plumbing_item) 1743 if plumbing_response.meta.next_cursor == '': 1744 break 1745 req.meta.cursor = plumbing_response.meta.next_cursor 1746 1747 return generator(self, req)
Deprecated: Lists existing approval workflow approvers.
class
SnapshotApprovalWorkflowApprovers:
1750class SnapshotApprovalWorkflowApprovers: 1751 ''' 1752 SnapshotApprovalWorkflowApprovers exposes the read only methods of the ApprovalWorkflowApprovers 1753 service for historical queries. 1754 ''' 1755 def __init__(self, approval_workflow_approvers): 1756 self.approval_workflow_approvers = approval_workflow_approvers 1757 1758 def get(self, id, timeout=None): 1759 ''' 1760 Deprecated: Get reads one approval workflow approver by ID. 1761 ''' 1762 return self.approval_workflow_approvers.get(id, timeout=timeout) 1763 1764 def list(self, filter, *args, timeout=None): 1765 ''' 1766 Deprecated: Lists existing approval workflow approvers. 1767 ''' 1768 return self.approval_workflow_approvers.list(filter, 1769 *args, 1770 timeout=timeout)
SnapshotApprovalWorkflowApprovers exposes the read only methods of the ApprovalWorkflowApprovers service for historical queries.
def
get(self, id, timeout=None)
1758 def get(self, id, timeout=None): 1759 ''' 1760 Deprecated: Get reads one approval workflow approver by ID. 1761 ''' 1762 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)
1764 def list(self, filter, *args, timeout=None): 1765 ''' 1766 Deprecated: Lists existing approval workflow approvers. 1767 ''' 1768 return self.approval_workflow_approvers.list(filter, 1769 *args, 1770 timeout=timeout)
Deprecated: Lists existing approval workflow approvers.
class
ApprovalWorkflowApproversHistory:
1773class ApprovalWorkflowApproversHistory: 1774 ''' 1775 ApprovalWorkflowApproversHistory records all changes to the state of an ApprovalWorkflowApprover. 1776 See `strongdm.models.ApprovalWorkflowApproverHistory`. 1777 ''' 1778 def __init__(self, channel, client): 1779 self.parent = client 1780 self.stub = ApprovalWorkflowApproversHistoryStub(channel) 1781 1782 def list(self, filter, *args, timeout=None): 1783 ''' 1784 List gets a list of ApprovalWorkflowApproverHistory records matching a given set of criteria. 1785 ''' 1786 deadline = None if timeout is None else time.time() + timeout 1787 req = ApprovalWorkflowApproverHistoryListRequest() 1788 req.meta.CopyFrom(ListRequestMetadata()) 1789 if self.parent.page_limit > 0: 1790 req.meta.limit = self.parent.page_limit 1791 if self.parent.snapshot_datetime is not None: 1792 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1793 1794 req.filter = plumbing.quote_filter_args(filter, *args) 1795 1796 def generator(svc, req): 1797 tries = 0 1798 while True: 1799 t = None if deadline is None else deadline - time.time() 1800 try: 1801 plumbing_response = svc.stub.List( 1802 req, 1803 metadata=svc.parent.get_metadata( 1804 'ApprovalWorkflowApproversHistory.List', req), 1805 timeout=t) 1806 except Exception as e: 1807 if self.parent.shouldRetry(tries, e, deadline): 1808 tries += 1 1809 time.sleep( 1810 self.parent.exponentialBackoff(tries, deadline)) 1811 continue 1812 raise plumbing.convert_error_to_porcelain(e) from e 1813 tries = 0 1814 for plumbing_item in plumbing_response.history: 1815 yield plumbing.convert_approval_workflow_approver_history_to_porcelain( 1816 plumbing_item) 1817 if plumbing_response.meta.next_cursor == '': 1818 break 1819 req.meta.cursor = plumbing_response.meta.next_cursor 1820 1821 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)
1782 def list(self, filter, *args, timeout=None): 1783 ''' 1784 List gets a list of ApprovalWorkflowApproverHistory records matching a given set of criteria. 1785 ''' 1786 deadline = None if timeout is None else time.time() + timeout 1787 req = ApprovalWorkflowApproverHistoryListRequest() 1788 req.meta.CopyFrom(ListRequestMetadata()) 1789 if self.parent.page_limit > 0: 1790 req.meta.limit = self.parent.page_limit 1791 if self.parent.snapshot_datetime is not None: 1792 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1793 1794 req.filter = plumbing.quote_filter_args(filter, *args) 1795 1796 def generator(svc, req): 1797 tries = 0 1798 while True: 1799 t = None if deadline is None else deadline - time.time() 1800 try: 1801 plumbing_response = svc.stub.List( 1802 req, 1803 metadata=svc.parent.get_metadata( 1804 'ApprovalWorkflowApproversHistory.List', req), 1805 timeout=t) 1806 except Exception as e: 1807 if self.parent.shouldRetry(tries, e, deadline): 1808 tries += 1 1809 time.sleep( 1810 self.parent.exponentialBackoff(tries, deadline)) 1811 continue 1812 raise plumbing.convert_error_to_porcelain(e) from e 1813 tries = 0 1814 for plumbing_item in plumbing_response.history: 1815 yield plumbing.convert_approval_workflow_approver_history_to_porcelain( 1816 plumbing_item) 1817 if plumbing_response.meta.next_cursor == '': 1818 break 1819 req.meta.cursor = plumbing_response.meta.next_cursor 1820 1821 return generator(self, req)
List gets a list of ApprovalWorkflowApproverHistory records matching a given set of criteria.
class
ApprovalWorkflowSteps:
1824class ApprovalWorkflowSteps: 1825 ''' 1826 ApprovalWorkflowSteps link approval workflow steps to an ApprovalWorkflow 1827 See `strongdm.models.ApprovalWorkflowStep`. 1828 ''' 1829 def __init__(self, channel, client): 1830 self.parent = client 1831 self.stub = ApprovalWorkflowStepsStub(channel) 1832 1833 def create(self, approval_workflow_step, timeout=None): 1834 ''' 1835 Deprecated: Create creates a new approval workflow step. 1836 ''' 1837 deadline = None if timeout is None else time.time() + timeout 1838 req = ApprovalWorkflowStepCreateRequest() 1839 1840 if approval_workflow_step is not None: 1841 req.approval_workflow_step.CopyFrom( 1842 plumbing.convert_approval_workflow_step_to_plumbing( 1843 approval_workflow_step)) 1844 tries = 0 1845 plumbing_response = None 1846 while True: 1847 t = None if deadline is None else deadline - time.time() 1848 try: 1849 plumbing_response = self.stub.Create( 1850 req, 1851 metadata=self.parent.get_metadata( 1852 'ApprovalWorkflowSteps.Create', req), 1853 timeout=t) 1854 except Exception as e: 1855 if self.parent.shouldRetry(tries, e, deadline): 1856 tries += 1 1857 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1858 continue 1859 raise plumbing.convert_error_to_porcelain(e) from e 1860 break 1861 1862 resp = models.ApprovalWorkflowStepCreateResponse() 1863 resp.approval_workflow_step = plumbing.convert_approval_workflow_step_to_porcelain( 1864 plumbing_response.approval_workflow_step) 1865 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1866 plumbing_response.rate_limit) 1867 return resp 1868 1869 def get(self, id, timeout=None): 1870 ''' 1871 Deprecated: Get reads one approval workflow step by ID. 1872 ''' 1873 deadline = None if timeout is None else time.time() + timeout 1874 req = ApprovalWorkflowStepGetRequest() 1875 if self.parent.snapshot_datetime is not None: 1876 req.meta.CopyFrom(GetRequestMetadata()) 1877 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1878 1879 req.id = (id) 1880 tries = 0 1881 plumbing_response = None 1882 while True: 1883 t = None if deadline is None else deadline - time.time() 1884 try: 1885 plumbing_response = self.stub.Get( 1886 req, 1887 metadata=self.parent.get_metadata( 1888 'ApprovalWorkflowSteps.Get', req), 1889 timeout=t) 1890 except Exception as e: 1891 if self.parent.shouldRetry(tries, e, deadline): 1892 tries += 1 1893 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1894 continue 1895 raise plumbing.convert_error_to_porcelain(e) from e 1896 break 1897 1898 resp = models.ApprovalWorkflowStepGetResponse() 1899 resp.approval_workflow_step = plumbing.convert_approval_workflow_step_to_porcelain( 1900 plumbing_response.approval_workflow_step) 1901 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1902 plumbing_response.meta) 1903 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1904 plumbing_response.rate_limit) 1905 return resp 1906 1907 def delete(self, id, timeout=None): 1908 ''' 1909 Deprecated: Delete deletes an existing approval workflow step. 1910 ''' 1911 deadline = None if timeout is None else time.time() + timeout 1912 req = ApprovalWorkflowStepDeleteRequest() 1913 1914 req.id = (id) 1915 tries = 0 1916 plumbing_response = None 1917 while True: 1918 t = None if deadline is None else deadline - time.time() 1919 try: 1920 plumbing_response = self.stub.Delete( 1921 req, 1922 metadata=self.parent.get_metadata( 1923 'ApprovalWorkflowSteps.Delete', req), 1924 timeout=t) 1925 except Exception as e: 1926 if self.parent.shouldRetry(tries, e, deadline): 1927 tries += 1 1928 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1929 continue 1930 raise plumbing.convert_error_to_porcelain(e) from e 1931 break 1932 1933 resp = models.ApprovalWorkflowStepDeleteResponse() 1934 resp.id = (plumbing_response.id) 1935 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1936 plumbing_response.rate_limit) 1937 return resp 1938 1939 def list(self, filter, *args, timeout=None): 1940 ''' 1941 Deprecated: Lists existing approval workflow steps. 1942 ''' 1943 deadline = None if timeout is None else time.time() + timeout 1944 req = ApprovalWorkflowStepListRequest() 1945 req.meta.CopyFrom(ListRequestMetadata()) 1946 if self.parent.page_limit > 0: 1947 req.meta.limit = self.parent.page_limit 1948 if self.parent.snapshot_datetime is not None: 1949 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1950 1951 req.filter = plumbing.quote_filter_args(filter, *args) 1952 1953 def generator(svc, req): 1954 tries = 0 1955 while True: 1956 t = None if deadline is None else deadline - time.time() 1957 try: 1958 plumbing_response = svc.stub.List( 1959 req, 1960 metadata=svc.parent.get_metadata( 1961 'ApprovalWorkflowSteps.List', req), 1962 timeout=t) 1963 except Exception as e: 1964 if self.parent.shouldRetry(tries, e, deadline): 1965 tries += 1 1966 time.sleep( 1967 self.parent.exponentialBackoff(tries, deadline)) 1968 continue 1969 raise plumbing.convert_error_to_porcelain(e) from e 1970 tries = 0 1971 for plumbing_item in plumbing_response.approval_workflow_steps: 1972 yield plumbing.convert_approval_workflow_step_to_porcelain( 1973 plumbing_item) 1974 if plumbing_response.meta.next_cursor == '': 1975 break 1976 req.meta.cursor = plumbing_response.meta.next_cursor 1977 1978 return generator(self, req)
ApprovalWorkflowSteps link approval workflow steps to an ApprovalWorkflow
See strongdm.models.ApprovalWorkflowStep.
def
create(self, approval_workflow_step, timeout=None)
1833 def create(self, approval_workflow_step, timeout=None): 1834 ''' 1835 Deprecated: Create creates a new approval workflow step. 1836 ''' 1837 deadline = None if timeout is None else time.time() + timeout 1838 req = ApprovalWorkflowStepCreateRequest() 1839 1840 if approval_workflow_step is not None: 1841 req.approval_workflow_step.CopyFrom( 1842 plumbing.convert_approval_workflow_step_to_plumbing( 1843 approval_workflow_step)) 1844 tries = 0 1845 plumbing_response = None 1846 while True: 1847 t = None if deadline is None else deadline - time.time() 1848 try: 1849 plumbing_response = self.stub.Create( 1850 req, 1851 metadata=self.parent.get_metadata( 1852 'ApprovalWorkflowSteps.Create', req), 1853 timeout=t) 1854 except Exception as e: 1855 if self.parent.shouldRetry(tries, e, deadline): 1856 tries += 1 1857 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1858 continue 1859 raise plumbing.convert_error_to_porcelain(e) from e 1860 break 1861 1862 resp = models.ApprovalWorkflowStepCreateResponse() 1863 resp.approval_workflow_step = plumbing.convert_approval_workflow_step_to_porcelain( 1864 plumbing_response.approval_workflow_step) 1865 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1866 plumbing_response.rate_limit) 1867 return resp
Deprecated: Create creates a new approval workflow step.
def
get(self, id, timeout=None)
1869 def get(self, id, timeout=None): 1870 ''' 1871 Deprecated: Get reads one approval workflow step by ID. 1872 ''' 1873 deadline = None if timeout is None else time.time() + timeout 1874 req = ApprovalWorkflowStepGetRequest() 1875 if self.parent.snapshot_datetime is not None: 1876 req.meta.CopyFrom(GetRequestMetadata()) 1877 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1878 1879 req.id = (id) 1880 tries = 0 1881 plumbing_response = None 1882 while True: 1883 t = None if deadline is None else deadline - time.time() 1884 try: 1885 plumbing_response = self.stub.Get( 1886 req, 1887 metadata=self.parent.get_metadata( 1888 'ApprovalWorkflowSteps.Get', req), 1889 timeout=t) 1890 except Exception as e: 1891 if self.parent.shouldRetry(tries, e, deadline): 1892 tries += 1 1893 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1894 continue 1895 raise plumbing.convert_error_to_porcelain(e) from e 1896 break 1897 1898 resp = models.ApprovalWorkflowStepGetResponse() 1899 resp.approval_workflow_step = plumbing.convert_approval_workflow_step_to_porcelain( 1900 plumbing_response.approval_workflow_step) 1901 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1902 plumbing_response.meta) 1903 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1904 plumbing_response.rate_limit) 1905 return resp
Deprecated: Get reads one approval workflow step by ID.
def
delete(self, id, timeout=None)
1907 def delete(self, id, timeout=None): 1908 ''' 1909 Deprecated: Delete deletes an existing approval workflow step. 1910 ''' 1911 deadline = None if timeout is None else time.time() + timeout 1912 req = ApprovalWorkflowStepDeleteRequest() 1913 1914 req.id = (id) 1915 tries = 0 1916 plumbing_response = None 1917 while True: 1918 t = None if deadline is None else deadline - time.time() 1919 try: 1920 plumbing_response = self.stub.Delete( 1921 req, 1922 metadata=self.parent.get_metadata( 1923 'ApprovalWorkflowSteps.Delete', req), 1924 timeout=t) 1925 except Exception as e: 1926 if self.parent.shouldRetry(tries, e, deadline): 1927 tries += 1 1928 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1929 continue 1930 raise plumbing.convert_error_to_porcelain(e) from e 1931 break 1932 1933 resp = models.ApprovalWorkflowStepDeleteResponse() 1934 resp.id = (plumbing_response.id) 1935 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1936 plumbing_response.rate_limit) 1937 return resp
Deprecated: Delete deletes an existing approval workflow step.
def
list(self, filter, *args, timeout=None)
1939 def list(self, filter, *args, timeout=None): 1940 ''' 1941 Deprecated: Lists existing approval workflow steps. 1942 ''' 1943 deadline = None if timeout is None else time.time() + timeout 1944 req = ApprovalWorkflowStepListRequest() 1945 req.meta.CopyFrom(ListRequestMetadata()) 1946 if self.parent.page_limit > 0: 1947 req.meta.limit = self.parent.page_limit 1948 if self.parent.snapshot_datetime is not None: 1949 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1950 1951 req.filter = plumbing.quote_filter_args(filter, *args) 1952 1953 def generator(svc, req): 1954 tries = 0 1955 while True: 1956 t = None if deadline is None else deadline - time.time() 1957 try: 1958 plumbing_response = svc.stub.List( 1959 req, 1960 metadata=svc.parent.get_metadata( 1961 'ApprovalWorkflowSteps.List', req), 1962 timeout=t) 1963 except Exception as e: 1964 if self.parent.shouldRetry(tries, e, deadline): 1965 tries += 1 1966 time.sleep( 1967 self.parent.exponentialBackoff(tries, deadline)) 1968 continue 1969 raise plumbing.convert_error_to_porcelain(e) from e 1970 tries = 0 1971 for plumbing_item in plumbing_response.approval_workflow_steps: 1972 yield plumbing.convert_approval_workflow_step_to_porcelain( 1973 plumbing_item) 1974 if plumbing_response.meta.next_cursor == '': 1975 break 1976 req.meta.cursor = plumbing_response.meta.next_cursor 1977 1978 return generator(self, req)
Deprecated: Lists existing approval workflow steps.
class
SnapshotApprovalWorkflowSteps:
1981class SnapshotApprovalWorkflowSteps: 1982 ''' 1983 SnapshotApprovalWorkflowSteps exposes the read only methods of the ApprovalWorkflowSteps 1984 service for historical queries. 1985 ''' 1986 def __init__(self, approval_workflow_steps): 1987 self.approval_workflow_steps = approval_workflow_steps 1988 1989 def get(self, id, timeout=None): 1990 ''' 1991 Deprecated: Get reads one approval workflow step by ID. 1992 ''' 1993 return self.approval_workflow_steps.get(id, timeout=timeout) 1994 1995 def list(self, filter, *args, timeout=None): 1996 ''' 1997 Deprecated: Lists existing approval workflow steps. 1998 ''' 1999 return self.approval_workflow_steps.list(filter, 2000 *args, 2001 timeout=timeout)
SnapshotApprovalWorkflowSteps exposes the read only methods of the ApprovalWorkflowSteps service for historical queries.
def
get(self, id, timeout=None)
1989 def get(self, id, timeout=None): 1990 ''' 1991 Deprecated: Get reads one approval workflow step by ID. 1992 ''' 1993 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)
1995 def list(self, filter, *args, timeout=None): 1996 ''' 1997 Deprecated: Lists existing approval workflow steps. 1998 ''' 1999 return self.approval_workflow_steps.list(filter, 2000 *args, 2001 timeout=timeout)
Deprecated: Lists existing approval workflow steps.
class
ApprovalWorkflowStepsHistory:
2004class ApprovalWorkflowStepsHistory: 2005 ''' 2006 ApprovalWorkflowStepsHistory records all changes to the state of an ApprovalWorkflowStep. 2007 See `strongdm.models.ApprovalWorkflowStepHistory`. 2008 ''' 2009 def __init__(self, channel, client): 2010 self.parent = client 2011 self.stub = ApprovalWorkflowStepsHistoryStub(channel) 2012 2013 def list(self, filter, *args, timeout=None): 2014 ''' 2015 List gets a list of ApprovalWorkflowStepHistory records matching a given set of criteria. 2016 ''' 2017 deadline = None if timeout is None else time.time() + timeout 2018 req = ApprovalWorkflowStepHistoryListRequest() 2019 req.meta.CopyFrom(ListRequestMetadata()) 2020 if self.parent.page_limit > 0: 2021 req.meta.limit = self.parent.page_limit 2022 if self.parent.snapshot_datetime is not None: 2023 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2024 2025 req.filter = plumbing.quote_filter_args(filter, *args) 2026 2027 def generator(svc, req): 2028 tries = 0 2029 while True: 2030 t = None if deadline is None else deadline - time.time() 2031 try: 2032 plumbing_response = svc.stub.List( 2033 req, 2034 metadata=svc.parent.get_metadata( 2035 'ApprovalWorkflowStepsHistory.List', req), 2036 timeout=t) 2037 except Exception as e: 2038 if self.parent.shouldRetry(tries, e, deadline): 2039 tries += 1 2040 time.sleep( 2041 self.parent.exponentialBackoff(tries, deadline)) 2042 continue 2043 raise plumbing.convert_error_to_porcelain(e) from e 2044 tries = 0 2045 for plumbing_item in plumbing_response.history: 2046 yield plumbing.convert_approval_workflow_step_history_to_porcelain( 2047 plumbing_item) 2048 if plumbing_response.meta.next_cursor == '': 2049 break 2050 req.meta.cursor = plumbing_response.meta.next_cursor 2051 2052 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)
2013 def list(self, filter, *args, timeout=None): 2014 ''' 2015 List gets a list of ApprovalWorkflowStepHistory records matching a given set of criteria. 2016 ''' 2017 deadline = None if timeout is None else time.time() + timeout 2018 req = ApprovalWorkflowStepHistoryListRequest() 2019 req.meta.CopyFrom(ListRequestMetadata()) 2020 if self.parent.page_limit > 0: 2021 req.meta.limit = self.parent.page_limit 2022 if self.parent.snapshot_datetime is not None: 2023 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2024 2025 req.filter = plumbing.quote_filter_args(filter, *args) 2026 2027 def generator(svc, req): 2028 tries = 0 2029 while True: 2030 t = None if deadline is None else deadline - time.time() 2031 try: 2032 plumbing_response = svc.stub.List( 2033 req, 2034 metadata=svc.parent.get_metadata( 2035 'ApprovalWorkflowStepsHistory.List', req), 2036 timeout=t) 2037 except Exception as e: 2038 if self.parent.shouldRetry(tries, e, deadline): 2039 tries += 1 2040 time.sleep( 2041 self.parent.exponentialBackoff(tries, deadline)) 2042 continue 2043 raise plumbing.convert_error_to_porcelain(e) from e 2044 tries = 0 2045 for plumbing_item in plumbing_response.history: 2046 yield plumbing.convert_approval_workflow_step_history_to_porcelain( 2047 plumbing_item) 2048 if plumbing_response.meta.next_cursor == '': 2049 break 2050 req.meta.cursor = plumbing_response.meta.next_cursor 2051 2052 return generator(self, req)
List gets a list of ApprovalWorkflowStepHistory records matching a given set of criteria.
class
ApprovalWorkflows:
2055class ApprovalWorkflows: 2056 ''' 2057 ApprovalWorkflows are the mechanism by which requests for access can be viewed by authorized 2058 approvers and be approved or denied. 2059 See `strongdm.models.ApprovalWorkflow`. 2060 ''' 2061 def __init__(self, channel, client): 2062 self.parent = client 2063 self.stub = ApprovalWorkflowsStub(channel) 2064 2065 def create(self, approval_workflow, timeout=None): 2066 ''' 2067 Create creates a new approval workflow and requires a name and approval mode for the approval workflow. 2068 ''' 2069 deadline = None if timeout is None else time.time() + timeout 2070 req = ApprovalWorkflowCreateRequest() 2071 2072 if approval_workflow is not None: 2073 req.approval_workflow.CopyFrom( 2074 plumbing.convert_approval_workflow_to_plumbing( 2075 approval_workflow)) 2076 tries = 0 2077 plumbing_response = None 2078 while True: 2079 t = None if deadline is None else deadline - time.time() 2080 try: 2081 plumbing_response = self.stub.Create( 2082 req, 2083 metadata=self.parent.get_metadata( 2084 'ApprovalWorkflows.Create', req), 2085 timeout=t) 2086 except Exception as e: 2087 if self.parent.shouldRetry(tries, e, deadline): 2088 tries += 1 2089 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2090 continue 2091 raise plumbing.convert_error_to_porcelain(e) from e 2092 break 2093 2094 resp = models.ApprovalWorkflowCreateResponse() 2095 resp.approval_workflow = plumbing.convert_approval_workflow_to_porcelain( 2096 plumbing_response.approval_workflow) 2097 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2098 plumbing_response.rate_limit) 2099 return resp 2100 2101 def get(self, id, timeout=None): 2102 ''' 2103 Get reads one approval workflow by ID. 2104 ''' 2105 deadline = None if timeout is None else time.time() + timeout 2106 req = ApprovalWorkflowGetRequest() 2107 if self.parent.snapshot_datetime is not None: 2108 req.meta.CopyFrom(GetRequestMetadata()) 2109 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2110 2111 req.id = (id) 2112 tries = 0 2113 plumbing_response = None 2114 while True: 2115 t = None if deadline is None else deadline - time.time() 2116 try: 2117 plumbing_response = self.stub.Get( 2118 req, 2119 metadata=self.parent.get_metadata('ApprovalWorkflows.Get', 2120 req), 2121 timeout=t) 2122 except Exception as e: 2123 if self.parent.shouldRetry(tries, e, deadline): 2124 tries += 1 2125 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2126 continue 2127 raise plumbing.convert_error_to_porcelain(e) from e 2128 break 2129 2130 resp = models.ApprovalWorkflowGetResponse() 2131 resp.approval_workflow = plumbing.convert_approval_workflow_to_porcelain( 2132 plumbing_response.approval_workflow) 2133 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2134 plumbing_response.meta) 2135 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2136 plumbing_response.rate_limit) 2137 return resp 2138 2139 def delete(self, id, timeout=None): 2140 ''' 2141 Delete deletes an existing approval workflow. 2142 ''' 2143 deadline = None if timeout is None else time.time() + timeout 2144 req = ApprovalWorkflowDeleteRequest() 2145 2146 req.id = (id) 2147 tries = 0 2148 plumbing_response = None 2149 while True: 2150 t = None if deadline is None else deadline - time.time() 2151 try: 2152 plumbing_response = self.stub.Delete( 2153 req, 2154 metadata=self.parent.get_metadata( 2155 'ApprovalWorkflows.Delete', req), 2156 timeout=t) 2157 except Exception as e: 2158 if self.parent.shouldRetry(tries, e, deadline): 2159 tries += 1 2160 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2161 continue 2162 raise plumbing.convert_error_to_porcelain(e) from e 2163 break 2164 2165 resp = models.ApprovalWorkflowDeleteResponse() 2166 resp.id = (plumbing_response.id) 2167 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2168 plumbing_response.rate_limit) 2169 return resp 2170 2171 def update(self, approval_workflow, timeout=None): 2172 ''' 2173 Update updates an existing approval workflow. 2174 ''' 2175 deadline = None if timeout is None else time.time() + timeout 2176 req = ApprovalWorkflowUpdateRequest() 2177 2178 if approval_workflow is not None: 2179 req.approval_workflow.CopyFrom( 2180 plumbing.convert_approval_workflow_to_plumbing( 2181 approval_workflow)) 2182 tries = 0 2183 plumbing_response = None 2184 while True: 2185 t = None if deadline is None else deadline - time.time() 2186 try: 2187 plumbing_response = self.stub.Update( 2188 req, 2189 metadata=self.parent.get_metadata( 2190 'ApprovalWorkflows.Update', req), 2191 timeout=t) 2192 except Exception as e: 2193 if self.parent.shouldRetry(tries, e, deadline): 2194 tries += 1 2195 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2196 continue 2197 raise plumbing.convert_error_to_porcelain(e) from e 2198 break 2199 2200 resp = models.ApprovalWorkflowUpdateResponse() 2201 resp.approval_workflow = plumbing.convert_approval_workflow_to_porcelain( 2202 plumbing_response.approval_workflow) 2203 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2204 plumbing_response.rate_limit) 2205 return resp 2206 2207 def list(self, filter, *args, timeout=None): 2208 ''' 2209 Lists existing approval workflows. 2210 ''' 2211 deadline = None if timeout is None else time.time() + timeout 2212 req = ApprovalWorkflowListRequest() 2213 req.meta.CopyFrom(ListRequestMetadata()) 2214 if self.parent.page_limit > 0: 2215 req.meta.limit = self.parent.page_limit 2216 if self.parent.snapshot_datetime is not None: 2217 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2218 2219 req.filter = plumbing.quote_filter_args(filter, *args) 2220 2221 def generator(svc, req): 2222 tries = 0 2223 while True: 2224 t = None if deadline is None else deadline - time.time() 2225 try: 2226 plumbing_response = svc.stub.List( 2227 req, 2228 metadata=svc.parent.get_metadata( 2229 'ApprovalWorkflows.List', req), 2230 timeout=t) 2231 except Exception as e: 2232 if self.parent.shouldRetry(tries, e, deadline): 2233 tries += 1 2234 time.sleep( 2235 self.parent.exponentialBackoff(tries, deadline)) 2236 continue 2237 raise plumbing.convert_error_to_porcelain(e) from e 2238 tries = 0 2239 for plumbing_item in plumbing_response.approval_workflows: 2240 yield plumbing.convert_approval_workflow_to_porcelain( 2241 plumbing_item) 2242 if plumbing_response.meta.next_cursor == '': 2243 break 2244 req.meta.cursor = plumbing_response.meta.next_cursor 2245 2246 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)
2065 def create(self, approval_workflow, timeout=None): 2066 ''' 2067 Create creates a new approval workflow and requires a name and approval mode for the approval workflow. 2068 ''' 2069 deadline = None if timeout is None else time.time() + timeout 2070 req = ApprovalWorkflowCreateRequest() 2071 2072 if approval_workflow is not None: 2073 req.approval_workflow.CopyFrom( 2074 plumbing.convert_approval_workflow_to_plumbing( 2075 approval_workflow)) 2076 tries = 0 2077 plumbing_response = None 2078 while True: 2079 t = None if deadline is None else deadline - time.time() 2080 try: 2081 plumbing_response = self.stub.Create( 2082 req, 2083 metadata=self.parent.get_metadata( 2084 'ApprovalWorkflows.Create', req), 2085 timeout=t) 2086 except Exception as e: 2087 if self.parent.shouldRetry(tries, e, deadline): 2088 tries += 1 2089 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2090 continue 2091 raise plumbing.convert_error_to_porcelain(e) from e 2092 break 2093 2094 resp = models.ApprovalWorkflowCreateResponse() 2095 resp.approval_workflow = plumbing.convert_approval_workflow_to_porcelain( 2096 plumbing_response.approval_workflow) 2097 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2098 plumbing_response.rate_limit) 2099 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)
2101 def get(self, id, timeout=None): 2102 ''' 2103 Get reads one approval workflow by ID. 2104 ''' 2105 deadline = None if timeout is None else time.time() + timeout 2106 req = ApprovalWorkflowGetRequest() 2107 if self.parent.snapshot_datetime is not None: 2108 req.meta.CopyFrom(GetRequestMetadata()) 2109 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2110 2111 req.id = (id) 2112 tries = 0 2113 plumbing_response = None 2114 while True: 2115 t = None if deadline is None else deadline - time.time() 2116 try: 2117 plumbing_response = self.stub.Get( 2118 req, 2119 metadata=self.parent.get_metadata('ApprovalWorkflows.Get', 2120 req), 2121 timeout=t) 2122 except Exception as e: 2123 if self.parent.shouldRetry(tries, e, deadline): 2124 tries += 1 2125 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2126 continue 2127 raise plumbing.convert_error_to_porcelain(e) from e 2128 break 2129 2130 resp = models.ApprovalWorkflowGetResponse() 2131 resp.approval_workflow = plumbing.convert_approval_workflow_to_porcelain( 2132 plumbing_response.approval_workflow) 2133 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2134 plumbing_response.meta) 2135 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2136 plumbing_response.rate_limit) 2137 return resp
Get reads one approval workflow by ID.
def
delete(self, id, timeout=None)
2139 def delete(self, id, timeout=None): 2140 ''' 2141 Delete deletes an existing approval workflow. 2142 ''' 2143 deadline = None if timeout is None else time.time() + timeout 2144 req = ApprovalWorkflowDeleteRequest() 2145 2146 req.id = (id) 2147 tries = 0 2148 plumbing_response = None 2149 while True: 2150 t = None if deadline is None else deadline - time.time() 2151 try: 2152 plumbing_response = self.stub.Delete( 2153 req, 2154 metadata=self.parent.get_metadata( 2155 'ApprovalWorkflows.Delete', req), 2156 timeout=t) 2157 except Exception as e: 2158 if self.parent.shouldRetry(tries, e, deadline): 2159 tries += 1 2160 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2161 continue 2162 raise plumbing.convert_error_to_porcelain(e) from e 2163 break 2164 2165 resp = models.ApprovalWorkflowDeleteResponse() 2166 resp.id = (plumbing_response.id) 2167 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2168 plumbing_response.rate_limit) 2169 return resp
Delete deletes an existing approval workflow.
def
update(self, approval_workflow, timeout=None)
2171 def update(self, approval_workflow, timeout=None): 2172 ''' 2173 Update updates an existing approval workflow. 2174 ''' 2175 deadline = None if timeout is None else time.time() + timeout 2176 req = ApprovalWorkflowUpdateRequest() 2177 2178 if approval_workflow is not None: 2179 req.approval_workflow.CopyFrom( 2180 plumbing.convert_approval_workflow_to_plumbing( 2181 approval_workflow)) 2182 tries = 0 2183 plumbing_response = None 2184 while True: 2185 t = None if deadline is None else deadline - time.time() 2186 try: 2187 plumbing_response = self.stub.Update( 2188 req, 2189 metadata=self.parent.get_metadata( 2190 'ApprovalWorkflows.Update', req), 2191 timeout=t) 2192 except Exception as e: 2193 if self.parent.shouldRetry(tries, e, deadline): 2194 tries += 1 2195 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2196 continue 2197 raise plumbing.convert_error_to_porcelain(e) from e 2198 break 2199 2200 resp = models.ApprovalWorkflowUpdateResponse() 2201 resp.approval_workflow = plumbing.convert_approval_workflow_to_porcelain( 2202 plumbing_response.approval_workflow) 2203 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2204 plumbing_response.rate_limit) 2205 return resp
Update updates an existing approval workflow.
def
list(self, filter, *args, timeout=None)
2207 def list(self, filter, *args, timeout=None): 2208 ''' 2209 Lists existing approval workflows. 2210 ''' 2211 deadline = None if timeout is None else time.time() + timeout 2212 req = ApprovalWorkflowListRequest() 2213 req.meta.CopyFrom(ListRequestMetadata()) 2214 if self.parent.page_limit > 0: 2215 req.meta.limit = self.parent.page_limit 2216 if self.parent.snapshot_datetime is not None: 2217 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2218 2219 req.filter = plumbing.quote_filter_args(filter, *args) 2220 2221 def generator(svc, req): 2222 tries = 0 2223 while True: 2224 t = None if deadline is None else deadline - time.time() 2225 try: 2226 plumbing_response = svc.stub.List( 2227 req, 2228 metadata=svc.parent.get_metadata( 2229 'ApprovalWorkflows.List', req), 2230 timeout=t) 2231 except Exception as e: 2232 if self.parent.shouldRetry(tries, e, deadline): 2233 tries += 1 2234 time.sleep( 2235 self.parent.exponentialBackoff(tries, deadline)) 2236 continue 2237 raise plumbing.convert_error_to_porcelain(e) from e 2238 tries = 0 2239 for plumbing_item in plumbing_response.approval_workflows: 2240 yield plumbing.convert_approval_workflow_to_porcelain( 2241 plumbing_item) 2242 if plumbing_response.meta.next_cursor == '': 2243 break 2244 req.meta.cursor = plumbing_response.meta.next_cursor 2245 2246 return generator(self, req)
Lists existing approval workflows.
class
SnapshotApprovalWorkflows:
2249class SnapshotApprovalWorkflows: 2250 ''' 2251 SnapshotApprovalWorkflows exposes the read only methods of the ApprovalWorkflows 2252 service for historical queries. 2253 ''' 2254 def __init__(self, approval_workflows): 2255 self.approval_workflows = approval_workflows 2256 2257 def get(self, id, timeout=None): 2258 ''' 2259 Get reads one approval workflow by ID. 2260 ''' 2261 return self.approval_workflows.get(id, timeout=timeout) 2262 2263 def list(self, filter, *args, timeout=None): 2264 ''' 2265 Lists existing approval workflows. 2266 ''' 2267 return self.approval_workflows.list(filter, *args, timeout=timeout)
SnapshotApprovalWorkflows exposes the read only methods of the ApprovalWorkflows service for historical queries.
class
ApprovalWorkflowsHistory:
2270class ApprovalWorkflowsHistory: 2271 ''' 2272 ApprovalWorkflowsHistory records all changes to the state of an ApprovalWorkflow. 2273 See `strongdm.models.ApprovalWorkflowHistory`. 2274 ''' 2275 def __init__(self, channel, client): 2276 self.parent = client 2277 self.stub = ApprovalWorkflowsHistoryStub(channel) 2278 2279 def list(self, filter, *args, timeout=None): 2280 ''' 2281 List gets a list of ApprovalWorkflowHistory records matching a given set of criteria. 2282 ''' 2283 deadline = None if timeout is None else time.time() + timeout 2284 req = ApprovalWorkflowHistoryListRequest() 2285 req.meta.CopyFrom(ListRequestMetadata()) 2286 if self.parent.page_limit > 0: 2287 req.meta.limit = self.parent.page_limit 2288 if self.parent.snapshot_datetime is not None: 2289 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2290 2291 req.filter = plumbing.quote_filter_args(filter, *args) 2292 2293 def generator(svc, req): 2294 tries = 0 2295 while True: 2296 t = None if deadline is None else deadline - time.time() 2297 try: 2298 plumbing_response = svc.stub.List( 2299 req, 2300 metadata=svc.parent.get_metadata( 2301 'ApprovalWorkflowsHistory.List', req), 2302 timeout=t) 2303 except Exception as e: 2304 if self.parent.shouldRetry(tries, e, deadline): 2305 tries += 1 2306 time.sleep( 2307 self.parent.exponentialBackoff(tries, deadline)) 2308 continue 2309 raise plumbing.convert_error_to_porcelain(e) from e 2310 tries = 0 2311 for plumbing_item in plumbing_response.history: 2312 yield plumbing.convert_approval_workflow_history_to_porcelain( 2313 plumbing_item) 2314 if plumbing_response.meta.next_cursor == '': 2315 break 2316 req.meta.cursor = plumbing_response.meta.next_cursor 2317 2318 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)
2279 def list(self, filter, *args, timeout=None): 2280 ''' 2281 List gets a list of ApprovalWorkflowHistory records matching a given set of criteria. 2282 ''' 2283 deadline = None if timeout is None else time.time() + timeout 2284 req = ApprovalWorkflowHistoryListRequest() 2285 req.meta.CopyFrom(ListRequestMetadata()) 2286 if self.parent.page_limit > 0: 2287 req.meta.limit = self.parent.page_limit 2288 if self.parent.snapshot_datetime is not None: 2289 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2290 2291 req.filter = plumbing.quote_filter_args(filter, *args) 2292 2293 def generator(svc, req): 2294 tries = 0 2295 while True: 2296 t = None if deadline is None else deadline - time.time() 2297 try: 2298 plumbing_response = svc.stub.List( 2299 req, 2300 metadata=svc.parent.get_metadata( 2301 'ApprovalWorkflowsHistory.List', req), 2302 timeout=t) 2303 except Exception as e: 2304 if self.parent.shouldRetry(tries, e, deadline): 2305 tries += 1 2306 time.sleep( 2307 self.parent.exponentialBackoff(tries, deadline)) 2308 continue 2309 raise plumbing.convert_error_to_porcelain(e) from e 2310 tries = 0 2311 for plumbing_item in plumbing_response.history: 2312 yield plumbing.convert_approval_workflow_history_to_porcelain( 2313 plumbing_item) 2314 if plumbing_response.meta.next_cursor == '': 2315 break 2316 req.meta.cursor = plumbing_response.meta.next_cursor 2317 2318 return generator(self, req)
List gets a list of ApprovalWorkflowHistory records matching a given set of criteria.
class
ControlPanel:
2321class ControlPanel: 2322 ''' 2323 ControlPanel contains all administrative controls. 2324 ''' 2325 def __init__(self, channel, client): 2326 self.parent = client 2327 self.stub = ControlPanelStub(channel) 2328 2329 def get_sshca_public_key(self, timeout=None): 2330 ''' 2331 GetSSHCAPublicKey retrieves the SSH CA public key. 2332 ''' 2333 deadline = None if timeout is None else time.time() + timeout 2334 req = ControlPanelGetSSHCAPublicKeyRequest() 2335 2336 tries = 0 2337 plumbing_response = None 2338 while True: 2339 t = None if deadline is None else deadline - time.time() 2340 try: 2341 plumbing_response = self.stub.GetSSHCAPublicKey( 2342 req, 2343 metadata=self.parent.get_metadata( 2344 'ControlPanel.GetSSHCAPublicKey', req), 2345 timeout=t) 2346 except Exception as e: 2347 if self.parent.shouldRetry(tries, e, deadline): 2348 tries += 1 2349 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2350 continue 2351 raise plumbing.convert_error_to_porcelain(e) from e 2352 break 2353 2354 resp = models.ControlPanelGetSSHCAPublicKeyResponse() 2355 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2356 plumbing_response.meta) 2357 resp.public_key = (plumbing_response.public_key) 2358 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2359 plumbing_response.rate_limit) 2360 return resp 2361 2362 def get_rdpca_public_key(self, timeout=None): 2363 ''' 2364 GetRDPCAPublicKey retrieves the RDP CA public key. 2365 ''' 2366 deadline = None if timeout is None else time.time() + timeout 2367 req = ControlPanelGetRDPCAPublicKeyRequest() 2368 2369 tries = 0 2370 plumbing_response = None 2371 while True: 2372 t = None if deadline is None else deadline - time.time() 2373 try: 2374 plumbing_response = self.stub.GetRDPCAPublicKey( 2375 req, 2376 metadata=self.parent.get_metadata( 2377 'ControlPanel.GetRDPCAPublicKey', req), 2378 timeout=t) 2379 except Exception as e: 2380 if self.parent.shouldRetry(tries, e, deadline): 2381 tries += 1 2382 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2383 continue 2384 raise plumbing.convert_error_to_porcelain(e) from e 2385 break 2386 2387 resp = models.ControlPanelGetRDPCAPublicKeyResponse() 2388 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2389 plumbing_response.meta) 2390 resp.public_key = (plumbing_response.public_key) 2391 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2392 plumbing_response.rate_limit) 2393 return resp 2394 2395 def verify_jwt(self, token, timeout=None): 2396 ''' 2397 VerifyJWT reports whether the given JWT token (x-sdm-token) is valid. 2398 ''' 2399 deadline = None if timeout is None else time.time() + timeout 2400 req = ControlPanelVerifyJWTRequest() 2401 2402 req.token = (token) 2403 tries = 0 2404 plumbing_response = None 2405 while True: 2406 t = None if deadline is None else deadline - time.time() 2407 try: 2408 plumbing_response = self.stub.VerifyJWT( 2409 req, 2410 metadata=self.parent.get_metadata('ControlPanel.VerifyJWT', 2411 req), 2412 timeout=t) 2413 except Exception as e: 2414 if self.parent.shouldRetry(tries, e, deadline): 2415 tries += 1 2416 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2417 continue 2418 raise plumbing.convert_error_to_porcelain(e) from e 2419 break 2420 2421 resp = models.ControlPanelVerifyJWTResponse() 2422 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2423 plumbing_response.meta) 2424 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2425 plumbing_response.rate_limit) 2426 resp.valid = (plumbing_response.valid) 2427 return resp
ControlPanel contains all administrative controls.
def
get_sshca_public_key(self, timeout=None)
2329 def get_sshca_public_key(self, timeout=None): 2330 ''' 2331 GetSSHCAPublicKey retrieves the SSH CA public key. 2332 ''' 2333 deadline = None if timeout is None else time.time() + timeout 2334 req = ControlPanelGetSSHCAPublicKeyRequest() 2335 2336 tries = 0 2337 plumbing_response = None 2338 while True: 2339 t = None if deadline is None else deadline - time.time() 2340 try: 2341 plumbing_response = self.stub.GetSSHCAPublicKey( 2342 req, 2343 metadata=self.parent.get_metadata( 2344 'ControlPanel.GetSSHCAPublicKey', req), 2345 timeout=t) 2346 except Exception as e: 2347 if self.parent.shouldRetry(tries, e, deadline): 2348 tries += 1 2349 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2350 continue 2351 raise plumbing.convert_error_to_porcelain(e) from e 2352 break 2353 2354 resp = models.ControlPanelGetSSHCAPublicKeyResponse() 2355 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2356 plumbing_response.meta) 2357 resp.public_key = (plumbing_response.public_key) 2358 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2359 plumbing_response.rate_limit) 2360 return resp
GetSSHCAPublicKey retrieves the SSH CA public key.
def
get_rdpca_public_key(self, timeout=None)
2362 def get_rdpca_public_key(self, timeout=None): 2363 ''' 2364 GetRDPCAPublicKey retrieves the RDP CA public key. 2365 ''' 2366 deadline = None if timeout is None else time.time() + timeout 2367 req = ControlPanelGetRDPCAPublicKeyRequest() 2368 2369 tries = 0 2370 plumbing_response = None 2371 while True: 2372 t = None if deadline is None else deadline - time.time() 2373 try: 2374 plumbing_response = self.stub.GetRDPCAPublicKey( 2375 req, 2376 metadata=self.parent.get_metadata( 2377 'ControlPanel.GetRDPCAPublicKey', req), 2378 timeout=t) 2379 except Exception as e: 2380 if self.parent.shouldRetry(tries, e, deadline): 2381 tries += 1 2382 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2383 continue 2384 raise plumbing.convert_error_to_porcelain(e) from e 2385 break 2386 2387 resp = models.ControlPanelGetRDPCAPublicKeyResponse() 2388 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2389 plumbing_response.meta) 2390 resp.public_key = (plumbing_response.public_key) 2391 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2392 plumbing_response.rate_limit) 2393 return resp
GetRDPCAPublicKey retrieves the RDP CA public key.
def
verify_jwt(self, token, timeout=None)
2395 def verify_jwt(self, token, timeout=None): 2396 ''' 2397 VerifyJWT reports whether the given JWT token (x-sdm-token) is valid. 2398 ''' 2399 deadline = None if timeout is None else time.time() + timeout 2400 req = ControlPanelVerifyJWTRequest() 2401 2402 req.token = (token) 2403 tries = 0 2404 plumbing_response = None 2405 while True: 2406 t = None if deadline is None else deadline - time.time() 2407 try: 2408 plumbing_response = self.stub.VerifyJWT( 2409 req, 2410 metadata=self.parent.get_metadata('ControlPanel.VerifyJWT', 2411 req), 2412 timeout=t) 2413 except Exception as e: 2414 if self.parent.shouldRetry(tries, e, deadline): 2415 tries += 1 2416 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2417 continue 2418 raise plumbing.convert_error_to_porcelain(e) from e 2419 break 2420 2421 resp = models.ControlPanelVerifyJWTResponse() 2422 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2423 plumbing_response.meta) 2424 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2425 plumbing_response.rate_limit) 2426 resp.valid = (plumbing_response.valid) 2427 return resp
VerifyJWT reports whether the given JWT token (x-sdm-token) is valid.
class
DiscoveryConnectors:
2430class DiscoveryConnectors: 2431 ''' 2432 A Discovery Connector is a configuration object for performing Resource 2433 Scans in remote systems such as AWS, GCP, Azure, and other systems. 2434 See: 2435 `strongdm.models.AWSConnector` 2436 `strongdm.models.AzureConnector` 2437 `strongdm.models.GCPConnector` 2438 ''' 2439 def __init__(self, channel, client): 2440 self.parent = client 2441 self.stub = DiscoveryConnectorsStub(channel) 2442 2443 def create(self, connector, timeout=None): 2444 ''' 2445 Create adds a new Connector. 2446 ''' 2447 deadline = None if timeout is None else time.time() + timeout 2448 req = ConnectorCreateRequest() 2449 2450 if connector is not None: 2451 req.connector.CopyFrom( 2452 plumbing.convert_connector_to_plumbing(connector)) 2453 tries = 0 2454 plumbing_response = None 2455 while True: 2456 t = None if deadline is None else deadline - time.time() 2457 try: 2458 plumbing_response = self.stub.Create( 2459 req, 2460 metadata=self.parent.get_metadata( 2461 'DiscoveryConnectors.Create', req), 2462 timeout=t) 2463 except Exception as e: 2464 if self.parent.shouldRetry(tries, e, deadline): 2465 tries += 1 2466 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2467 continue 2468 raise plumbing.convert_error_to_porcelain(e) from e 2469 break 2470 2471 resp = models.ConnectorCreateResponse() 2472 resp.connector = plumbing.convert_connector_to_porcelain( 2473 plumbing_response.connector) 2474 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2475 plumbing_response.rate_limit) 2476 return resp 2477 2478 def get(self, id, timeout=None): 2479 ''' 2480 Get reads one Connector by ID 2481 ''' 2482 deadline = None if timeout is None else time.time() + timeout 2483 req = ConnectorGetRequest() 2484 if self.parent.snapshot_datetime is not None: 2485 req.meta.CopyFrom(GetRequestMetadata()) 2486 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2487 2488 req.id = (id) 2489 tries = 0 2490 plumbing_response = None 2491 while True: 2492 t = None if deadline is None else deadline - time.time() 2493 try: 2494 plumbing_response = self.stub.Get( 2495 req, 2496 metadata=self.parent.get_metadata( 2497 'DiscoveryConnectors.Get', req), 2498 timeout=t) 2499 except Exception as e: 2500 if self.parent.shouldRetry(tries, e, deadline): 2501 tries += 1 2502 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2503 continue 2504 raise plumbing.convert_error_to_porcelain(e) from e 2505 break 2506 2507 resp = models.ConnectorGetResponse() 2508 resp.connector = plumbing.convert_connector_to_porcelain( 2509 plumbing_response.connector) 2510 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2511 plumbing_response.meta) 2512 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2513 plumbing_response.rate_limit) 2514 return resp 2515 2516 def update(self, connector, timeout=None): 2517 ''' 2518 Update replaces all the fields of a Connector by ID. 2519 ''' 2520 deadline = None if timeout is None else time.time() + timeout 2521 req = ConnectorUpdateRequest() 2522 2523 if connector is not None: 2524 req.connector.CopyFrom( 2525 plumbing.convert_connector_to_plumbing(connector)) 2526 tries = 0 2527 plumbing_response = None 2528 while True: 2529 t = None if deadline is None else deadline - time.time() 2530 try: 2531 plumbing_response = self.stub.Update( 2532 req, 2533 metadata=self.parent.get_metadata( 2534 'DiscoveryConnectors.Update', req), 2535 timeout=t) 2536 except Exception as e: 2537 if self.parent.shouldRetry(tries, e, deadline): 2538 tries += 1 2539 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2540 continue 2541 raise plumbing.convert_error_to_porcelain(e) from e 2542 break 2543 2544 resp = models.ConnectorUpdateResponse() 2545 resp.connector = plumbing.convert_connector_to_porcelain( 2546 plumbing_response.connector) 2547 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2548 plumbing_response.rate_limit) 2549 return resp 2550 2551 def delete(self, id, timeout=None): 2552 ''' 2553 Delete removes a Connector by ID. 2554 ''' 2555 deadline = None if timeout is None else time.time() + timeout 2556 req = ConnectorDeleteRequest() 2557 2558 req.id = (id) 2559 tries = 0 2560 plumbing_response = None 2561 while True: 2562 t = None if deadline is None else deadline - time.time() 2563 try: 2564 plumbing_response = self.stub.Delete( 2565 req, 2566 metadata=self.parent.get_metadata( 2567 'DiscoveryConnectors.Delete', req), 2568 timeout=t) 2569 except Exception as e: 2570 if self.parent.shouldRetry(tries, e, deadline): 2571 tries += 1 2572 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2573 continue 2574 raise plumbing.convert_error_to_porcelain(e) from e 2575 break 2576 2577 resp = models.ConnectorDeleteResponse() 2578 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 2579 plumbing_response.meta) 2580 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2581 plumbing_response.rate_limit) 2582 return resp 2583 2584 def list(self, filter, *args, timeout=None): 2585 ''' 2586 List gets a list of Connectors matching a given set of criteria. 2587 ''' 2588 deadline = None if timeout is None else time.time() + timeout 2589 req = ConnectorListRequest() 2590 req.meta.CopyFrom(ListRequestMetadata()) 2591 if self.parent.page_limit > 0: 2592 req.meta.limit = self.parent.page_limit 2593 if self.parent.snapshot_datetime is not None: 2594 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2595 2596 req.filter = plumbing.quote_filter_args(filter, *args) 2597 2598 def generator(svc, req): 2599 tries = 0 2600 while True: 2601 t = None if deadline is None else deadline - time.time() 2602 try: 2603 plumbing_response = svc.stub.List( 2604 req, 2605 metadata=svc.parent.get_metadata( 2606 'DiscoveryConnectors.List', req), 2607 timeout=t) 2608 except Exception as e: 2609 if self.parent.shouldRetry(tries, e, deadline): 2610 tries += 1 2611 time.sleep( 2612 self.parent.exponentialBackoff(tries, deadline)) 2613 continue 2614 raise plumbing.convert_error_to_porcelain(e) from e 2615 tries = 0 2616 for plumbing_item in plumbing_response.connectors: 2617 yield plumbing.convert_connector_to_porcelain( 2618 plumbing_item) 2619 if plumbing_response.meta.next_cursor == '': 2620 break 2621 req.meta.cursor = plumbing_response.meta.next_cursor 2622 2623 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)
2443 def create(self, connector, timeout=None): 2444 ''' 2445 Create adds a new Connector. 2446 ''' 2447 deadline = None if timeout is None else time.time() + timeout 2448 req = ConnectorCreateRequest() 2449 2450 if connector is not None: 2451 req.connector.CopyFrom( 2452 plumbing.convert_connector_to_plumbing(connector)) 2453 tries = 0 2454 plumbing_response = None 2455 while True: 2456 t = None if deadline is None else deadline - time.time() 2457 try: 2458 plumbing_response = self.stub.Create( 2459 req, 2460 metadata=self.parent.get_metadata( 2461 'DiscoveryConnectors.Create', req), 2462 timeout=t) 2463 except Exception as e: 2464 if self.parent.shouldRetry(tries, e, deadline): 2465 tries += 1 2466 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2467 continue 2468 raise plumbing.convert_error_to_porcelain(e) from e 2469 break 2470 2471 resp = models.ConnectorCreateResponse() 2472 resp.connector = plumbing.convert_connector_to_porcelain( 2473 plumbing_response.connector) 2474 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2475 plumbing_response.rate_limit) 2476 return resp
Create adds a new Connector.
def
get(self, id, timeout=None)
2478 def get(self, id, timeout=None): 2479 ''' 2480 Get reads one Connector by ID 2481 ''' 2482 deadline = None if timeout is None else time.time() + timeout 2483 req = ConnectorGetRequest() 2484 if self.parent.snapshot_datetime is not None: 2485 req.meta.CopyFrom(GetRequestMetadata()) 2486 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2487 2488 req.id = (id) 2489 tries = 0 2490 plumbing_response = None 2491 while True: 2492 t = None if deadline is None else deadline - time.time() 2493 try: 2494 plumbing_response = self.stub.Get( 2495 req, 2496 metadata=self.parent.get_metadata( 2497 'DiscoveryConnectors.Get', req), 2498 timeout=t) 2499 except Exception as e: 2500 if self.parent.shouldRetry(tries, e, deadline): 2501 tries += 1 2502 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2503 continue 2504 raise plumbing.convert_error_to_porcelain(e) from e 2505 break 2506 2507 resp = models.ConnectorGetResponse() 2508 resp.connector = plumbing.convert_connector_to_porcelain( 2509 plumbing_response.connector) 2510 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2511 plumbing_response.meta) 2512 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2513 plumbing_response.rate_limit) 2514 return resp
Get reads one Connector by ID
def
update(self, connector, timeout=None)
2516 def update(self, connector, timeout=None): 2517 ''' 2518 Update replaces all the fields of a Connector by ID. 2519 ''' 2520 deadline = None if timeout is None else time.time() + timeout 2521 req = ConnectorUpdateRequest() 2522 2523 if connector is not None: 2524 req.connector.CopyFrom( 2525 plumbing.convert_connector_to_plumbing(connector)) 2526 tries = 0 2527 plumbing_response = None 2528 while True: 2529 t = None if deadline is None else deadline - time.time() 2530 try: 2531 plumbing_response = self.stub.Update( 2532 req, 2533 metadata=self.parent.get_metadata( 2534 'DiscoveryConnectors.Update', req), 2535 timeout=t) 2536 except Exception as e: 2537 if self.parent.shouldRetry(tries, e, deadline): 2538 tries += 1 2539 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2540 continue 2541 raise plumbing.convert_error_to_porcelain(e) from e 2542 break 2543 2544 resp = models.ConnectorUpdateResponse() 2545 resp.connector = plumbing.convert_connector_to_porcelain( 2546 plumbing_response.connector) 2547 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2548 plumbing_response.rate_limit) 2549 return resp
Update replaces all the fields of a Connector by ID.
def
delete(self, id, timeout=None)
2551 def delete(self, id, timeout=None): 2552 ''' 2553 Delete removes a Connector by ID. 2554 ''' 2555 deadline = None if timeout is None else time.time() + timeout 2556 req = ConnectorDeleteRequest() 2557 2558 req.id = (id) 2559 tries = 0 2560 plumbing_response = None 2561 while True: 2562 t = None if deadline is None else deadline - time.time() 2563 try: 2564 plumbing_response = self.stub.Delete( 2565 req, 2566 metadata=self.parent.get_metadata( 2567 'DiscoveryConnectors.Delete', req), 2568 timeout=t) 2569 except Exception as e: 2570 if self.parent.shouldRetry(tries, e, deadline): 2571 tries += 1 2572 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2573 continue 2574 raise plumbing.convert_error_to_porcelain(e) from e 2575 break 2576 2577 resp = models.ConnectorDeleteResponse() 2578 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 2579 plumbing_response.meta) 2580 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2581 plumbing_response.rate_limit) 2582 return resp
Delete removes a Connector by ID.
def
list(self, filter, *args, timeout=None)
2584 def list(self, filter, *args, timeout=None): 2585 ''' 2586 List gets a list of Connectors matching a given set of criteria. 2587 ''' 2588 deadline = None if timeout is None else time.time() + timeout 2589 req = ConnectorListRequest() 2590 req.meta.CopyFrom(ListRequestMetadata()) 2591 if self.parent.page_limit > 0: 2592 req.meta.limit = self.parent.page_limit 2593 if self.parent.snapshot_datetime is not None: 2594 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2595 2596 req.filter = plumbing.quote_filter_args(filter, *args) 2597 2598 def generator(svc, req): 2599 tries = 0 2600 while True: 2601 t = None if deadline is None else deadline - time.time() 2602 try: 2603 plumbing_response = svc.stub.List( 2604 req, 2605 metadata=svc.parent.get_metadata( 2606 'DiscoveryConnectors.List', req), 2607 timeout=t) 2608 except Exception as e: 2609 if self.parent.shouldRetry(tries, e, deadline): 2610 tries += 1 2611 time.sleep( 2612 self.parent.exponentialBackoff(tries, deadline)) 2613 continue 2614 raise plumbing.convert_error_to_porcelain(e) from e 2615 tries = 0 2616 for plumbing_item in plumbing_response.connectors: 2617 yield plumbing.convert_connector_to_porcelain( 2618 plumbing_item) 2619 if plumbing_response.meta.next_cursor == '': 2620 break 2621 req.meta.cursor = plumbing_response.meta.next_cursor 2622 2623 return generator(self, req)
List gets a list of Connectors matching a given set of criteria.
class
SnapshotDiscoveryConnectors:
2626class SnapshotDiscoveryConnectors: 2627 ''' 2628 SnapshotDiscoveryConnectors exposes the read only methods of the DiscoveryConnectors 2629 service for historical queries. 2630 ''' 2631 def __init__(self, discovery_connectors): 2632 self.discovery_connectors = discovery_connectors 2633 2634 def get(self, id, timeout=None): 2635 ''' 2636 Get reads one Connector by ID 2637 ''' 2638 return self.discovery_connectors.get(id, timeout=timeout) 2639 2640 def list(self, filter, *args, timeout=None): 2641 ''' 2642 List gets a list of Connectors matching a given set of criteria. 2643 ''' 2644 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)
2634 def get(self, id, timeout=None): 2635 ''' 2636 Get reads one Connector by ID 2637 ''' 2638 return self.discovery_connectors.get(id, timeout=timeout)
Get reads one Connector by ID
def
list(self, filter, *args, timeout=None)
2640 def list(self, filter, *args, timeout=None): 2641 ''' 2642 List gets a list of Connectors matching a given set of criteria. 2643 ''' 2644 return self.discovery_connectors.list(filter, *args, timeout=timeout)
List gets a list of Connectors matching a given set of criteria.
class
Roles:
2647class Roles: 2648 ''' 2649 A Role has a list of access rules which determine which Resources the members 2650 of the Role have access to. An Account can be a member of multiple Roles via 2651 AccountAttachments. 2652 See `strongdm.models.Role`. 2653 ''' 2654 def __init__(self, channel, client): 2655 self.parent = client 2656 self.stub = RolesStub(channel) 2657 2658 def create(self, role, timeout=None): 2659 ''' 2660 Create registers a new Role. 2661 ''' 2662 deadline = None if timeout is None else time.time() + timeout 2663 req = RoleCreateRequest() 2664 2665 if role is not None: 2666 req.role.CopyFrom(plumbing.convert_role_to_plumbing(role)) 2667 tries = 0 2668 plumbing_response = None 2669 while True: 2670 t = None if deadline is None else deadline - time.time() 2671 try: 2672 plumbing_response = self.stub.Create( 2673 req, 2674 metadata=self.parent.get_metadata('Roles.Create', req), 2675 timeout=t) 2676 except Exception as e: 2677 if self.parent.shouldRetry(tries, e, deadline): 2678 tries += 1 2679 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2680 continue 2681 raise plumbing.convert_error_to_porcelain(e) from e 2682 break 2683 2684 resp = models.RoleCreateResponse() 2685 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 2686 plumbing_response.meta) 2687 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2688 plumbing_response.rate_limit) 2689 resp.role = plumbing.convert_role_to_porcelain(plumbing_response.role) 2690 return resp 2691 2692 def get(self, id, timeout=None): 2693 ''' 2694 Get reads one Role by ID. 2695 ''' 2696 deadline = None if timeout is None else time.time() + timeout 2697 req = RoleGetRequest() 2698 if self.parent.snapshot_datetime is not None: 2699 req.meta.CopyFrom(GetRequestMetadata()) 2700 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2701 2702 req.id = (id) 2703 tries = 0 2704 plumbing_response = None 2705 while True: 2706 t = None if deadline is None else deadline - time.time() 2707 try: 2708 plumbing_response = self.stub.Get( 2709 req, 2710 metadata=self.parent.get_metadata('Roles.Get', req), 2711 timeout=t) 2712 except Exception as e: 2713 if self.parent.shouldRetry(tries, e, deadline): 2714 tries += 1 2715 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2716 continue 2717 raise plumbing.convert_error_to_porcelain(e) from e 2718 break 2719 2720 resp = models.RoleGetResponse() 2721 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2722 plumbing_response.meta) 2723 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2724 plumbing_response.rate_limit) 2725 resp.role = plumbing.convert_role_to_porcelain(plumbing_response.role) 2726 return resp 2727 2728 def update(self, role, timeout=None): 2729 ''' 2730 Update replaces all the fields of a Role by ID. 2731 ''' 2732 deadline = None if timeout is None else time.time() + timeout 2733 req = RoleUpdateRequest() 2734 2735 if role is not None: 2736 req.role.CopyFrom(plumbing.convert_role_to_plumbing(role)) 2737 tries = 0 2738 plumbing_response = None 2739 while True: 2740 t = None if deadline is None else deadline - time.time() 2741 try: 2742 plumbing_response = self.stub.Update( 2743 req, 2744 metadata=self.parent.get_metadata('Roles.Update', req), 2745 timeout=t) 2746 except Exception as e: 2747 if self.parent.shouldRetry(tries, e, deadline): 2748 tries += 1 2749 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2750 continue 2751 raise plumbing.convert_error_to_porcelain(e) from e 2752 break 2753 2754 resp = models.RoleUpdateResponse() 2755 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 2756 plumbing_response.meta) 2757 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2758 plumbing_response.rate_limit) 2759 resp.role = plumbing.convert_role_to_porcelain(plumbing_response.role) 2760 return resp 2761 2762 def delete(self, id, timeout=None): 2763 ''' 2764 Delete removes a Role by ID. 2765 ''' 2766 deadline = None if timeout is None else time.time() + timeout 2767 req = RoleDeleteRequest() 2768 2769 req.id = (id) 2770 tries = 0 2771 plumbing_response = None 2772 while True: 2773 t = None if deadline is None else deadline - time.time() 2774 try: 2775 plumbing_response = self.stub.Delete( 2776 req, 2777 metadata=self.parent.get_metadata('Roles.Delete', req), 2778 timeout=t) 2779 except Exception as e: 2780 if self.parent.shouldRetry(tries, e, deadline): 2781 tries += 1 2782 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2783 continue 2784 raise plumbing.convert_error_to_porcelain(e) from e 2785 break 2786 2787 resp = models.RoleDeleteResponse() 2788 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 2789 plumbing_response.meta) 2790 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2791 plumbing_response.rate_limit) 2792 return resp 2793 2794 def list(self, filter, *args, timeout=None): 2795 ''' 2796 List gets a list of Roles matching a given set of criteria. 2797 ''' 2798 deadline = None if timeout is None else time.time() + timeout 2799 req = RoleListRequest() 2800 req.meta.CopyFrom(ListRequestMetadata()) 2801 if self.parent.page_limit > 0: 2802 req.meta.limit = self.parent.page_limit 2803 if self.parent.snapshot_datetime is not None: 2804 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2805 2806 req.filter = plumbing.quote_filter_args(filter, *args) 2807 2808 def generator(svc, req): 2809 tries = 0 2810 while True: 2811 t = None if deadline is None else deadline - time.time() 2812 try: 2813 plumbing_response = svc.stub.List( 2814 req, 2815 metadata=svc.parent.get_metadata('Roles.List', req), 2816 timeout=t) 2817 except Exception as e: 2818 if self.parent.shouldRetry(tries, e, deadline): 2819 tries += 1 2820 time.sleep( 2821 self.parent.exponentialBackoff(tries, deadline)) 2822 continue 2823 raise plumbing.convert_error_to_porcelain(e) from e 2824 tries = 0 2825 for plumbing_item in plumbing_response.roles: 2826 yield plumbing.convert_role_to_porcelain(plumbing_item) 2827 if plumbing_response.meta.next_cursor == '': 2828 break 2829 req.meta.cursor = plumbing_response.meta.next_cursor 2830 2831 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)
2658 def create(self, role, timeout=None): 2659 ''' 2660 Create registers a new Role. 2661 ''' 2662 deadline = None if timeout is None else time.time() + timeout 2663 req = RoleCreateRequest() 2664 2665 if role is not None: 2666 req.role.CopyFrom(plumbing.convert_role_to_plumbing(role)) 2667 tries = 0 2668 plumbing_response = None 2669 while True: 2670 t = None if deadline is None else deadline - time.time() 2671 try: 2672 plumbing_response = self.stub.Create( 2673 req, 2674 metadata=self.parent.get_metadata('Roles.Create', req), 2675 timeout=t) 2676 except Exception as e: 2677 if self.parent.shouldRetry(tries, e, deadline): 2678 tries += 1 2679 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2680 continue 2681 raise plumbing.convert_error_to_porcelain(e) from e 2682 break 2683 2684 resp = models.RoleCreateResponse() 2685 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 2686 plumbing_response.meta) 2687 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2688 plumbing_response.rate_limit) 2689 resp.role = plumbing.convert_role_to_porcelain(plumbing_response.role) 2690 return resp
Create registers a new Role.
def
get(self, id, timeout=None)
2692 def get(self, id, timeout=None): 2693 ''' 2694 Get reads one Role by ID. 2695 ''' 2696 deadline = None if timeout is None else time.time() + timeout 2697 req = RoleGetRequest() 2698 if self.parent.snapshot_datetime is not None: 2699 req.meta.CopyFrom(GetRequestMetadata()) 2700 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2701 2702 req.id = (id) 2703 tries = 0 2704 plumbing_response = None 2705 while True: 2706 t = None if deadline is None else deadline - time.time() 2707 try: 2708 plumbing_response = self.stub.Get( 2709 req, 2710 metadata=self.parent.get_metadata('Roles.Get', req), 2711 timeout=t) 2712 except Exception as e: 2713 if self.parent.shouldRetry(tries, e, deadline): 2714 tries += 1 2715 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2716 continue 2717 raise plumbing.convert_error_to_porcelain(e) from e 2718 break 2719 2720 resp = models.RoleGetResponse() 2721 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2722 plumbing_response.meta) 2723 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2724 plumbing_response.rate_limit) 2725 resp.role = plumbing.convert_role_to_porcelain(plumbing_response.role) 2726 return resp
Get reads one Role by ID.
def
update(self, role, timeout=None)
2728 def update(self, role, timeout=None): 2729 ''' 2730 Update replaces all the fields of a Role by ID. 2731 ''' 2732 deadline = None if timeout is None else time.time() + timeout 2733 req = RoleUpdateRequest() 2734 2735 if role is not None: 2736 req.role.CopyFrom(plumbing.convert_role_to_plumbing(role)) 2737 tries = 0 2738 plumbing_response = None 2739 while True: 2740 t = None if deadline is None else deadline - time.time() 2741 try: 2742 plumbing_response = self.stub.Update( 2743 req, 2744 metadata=self.parent.get_metadata('Roles.Update', req), 2745 timeout=t) 2746 except Exception as e: 2747 if self.parent.shouldRetry(tries, e, deadline): 2748 tries += 1 2749 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2750 continue 2751 raise plumbing.convert_error_to_porcelain(e) from e 2752 break 2753 2754 resp = models.RoleUpdateResponse() 2755 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 2756 plumbing_response.meta) 2757 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2758 plumbing_response.rate_limit) 2759 resp.role = plumbing.convert_role_to_porcelain(plumbing_response.role) 2760 return resp
Update replaces all the fields of a Role by ID.
def
delete(self, id, timeout=None)
2762 def delete(self, id, timeout=None): 2763 ''' 2764 Delete removes a Role by ID. 2765 ''' 2766 deadline = None if timeout is None else time.time() + timeout 2767 req = RoleDeleteRequest() 2768 2769 req.id = (id) 2770 tries = 0 2771 plumbing_response = None 2772 while True: 2773 t = None if deadline is None else deadline - time.time() 2774 try: 2775 plumbing_response = self.stub.Delete( 2776 req, 2777 metadata=self.parent.get_metadata('Roles.Delete', req), 2778 timeout=t) 2779 except Exception as e: 2780 if self.parent.shouldRetry(tries, e, deadline): 2781 tries += 1 2782 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2783 continue 2784 raise plumbing.convert_error_to_porcelain(e) from e 2785 break 2786 2787 resp = models.RoleDeleteResponse() 2788 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 2789 plumbing_response.meta) 2790 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2791 plumbing_response.rate_limit) 2792 return resp
Delete removes a Role by ID.
def
list(self, filter, *args, timeout=None)
2794 def list(self, filter, *args, timeout=None): 2795 ''' 2796 List gets a list of Roles matching a given set of criteria. 2797 ''' 2798 deadline = None if timeout is None else time.time() + timeout 2799 req = RoleListRequest() 2800 req.meta.CopyFrom(ListRequestMetadata()) 2801 if self.parent.page_limit > 0: 2802 req.meta.limit = self.parent.page_limit 2803 if self.parent.snapshot_datetime is not None: 2804 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2805 2806 req.filter = plumbing.quote_filter_args(filter, *args) 2807 2808 def generator(svc, req): 2809 tries = 0 2810 while True: 2811 t = None if deadline is None else deadline - time.time() 2812 try: 2813 plumbing_response = svc.stub.List( 2814 req, 2815 metadata=svc.parent.get_metadata('Roles.List', req), 2816 timeout=t) 2817 except Exception as e: 2818 if self.parent.shouldRetry(tries, e, deadline): 2819 tries += 1 2820 time.sleep( 2821 self.parent.exponentialBackoff(tries, deadline)) 2822 continue 2823 raise plumbing.convert_error_to_porcelain(e) from e 2824 tries = 0 2825 for plumbing_item in plumbing_response.roles: 2826 yield plumbing.convert_role_to_porcelain(plumbing_item) 2827 if plumbing_response.meta.next_cursor == '': 2828 break 2829 req.meta.cursor = plumbing_response.meta.next_cursor 2830 2831 return generator(self, req)
List gets a list of Roles matching a given set of criteria.
class
SnapshotRoles:
2834class SnapshotRoles: 2835 ''' 2836 SnapshotRoles exposes the read only methods of the Roles 2837 service for historical queries. 2838 ''' 2839 def __init__(self, roles): 2840 self.roles = roles 2841 2842 def get(self, id, timeout=None): 2843 ''' 2844 Get reads one Role by ID. 2845 ''' 2846 return self.roles.get(id, timeout=timeout) 2847 2848 def list(self, filter, *args, timeout=None): 2849 ''' 2850 List gets a list of Roles matching a given set of criteria. 2851 ''' 2852 return self.roles.list(filter, *args, timeout=timeout)
SnapshotRoles exposes the read only methods of the Roles service for historical queries.
class
Groups:
2855class Groups: 2856 ''' 2857 A Group is a set of principals. 2858 See `strongdm.models.Group`. 2859 ''' 2860 def __init__(self, channel, client): 2861 self.parent = client 2862 self.stub = GroupsStub(channel) 2863 2864 def create(self, group, timeout=None): 2865 ''' 2866 Create registers a new Group. 2867 ''' 2868 deadline = None if timeout is None else time.time() + timeout 2869 req = GroupCreateRequest() 2870 2871 if group is not None: 2872 req.group.CopyFrom(plumbing.convert_group_to_plumbing(group)) 2873 tries = 0 2874 plumbing_response = None 2875 while True: 2876 t = None if deadline is None else deadline - time.time() 2877 try: 2878 plumbing_response = self.stub.Create( 2879 req, 2880 metadata=self.parent.get_metadata('Groups.Create', req), 2881 timeout=t) 2882 except Exception as e: 2883 if self.parent.shouldRetry(tries, e, deadline): 2884 tries += 1 2885 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2886 continue 2887 raise plumbing.convert_error_to_porcelain(e) from e 2888 break 2889 2890 resp = models.GroupCreateResponse() 2891 resp.group = plumbing.convert_group_to_porcelain( 2892 plumbing_response.group) 2893 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2894 plumbing_response.rate_limit) 2895 return resp 2896 2897 def create_from_roles(self, role_ids, commit, timeout=None): 2898 deadline = None if timeout is None else time.time() + timeout 2899 req = GroupCreateFromRolesRequest() 2900 2901 req.role_ids.extend((role_ids)) 2902 req.commit = (commit) 2903 tries = 0 2904 plumbing_response = None 2905 while True: 2906 t = None if deadline is None else deadline - time.time() 2907 try: 2908 plumbing_response = self.stub.CreateFromRoles( 2909 req, 2910 metadata=self.parent.get_metadata('Groups.CreateFromRoles', 2911 req), 2912 timeout=t) 2913 except Exception as e: 2914 if self.parent.shouldRetry(tries, e, deadline): 2915 tries += 1 2916 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2917 continue 2918 raise plumbing.convert_error_to_porcelain(e) from e 2919 break 2920 2921 resp = models.GroupCreateFromRolesResponse() 2922 resp.group_from_role = plumbing.convert_repeated_group_from_role_to_porcelain( 2923 plumbing_response.group_from_role) 2924 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2925 plumbing_response.rate_limit) 2926 return resp 2927 2928 def get(self, id, timeout=None): 2929 ''' 2930 Get reads one Group by ID. 2931 ''' 2932 deadline = None if timeout is None else time.time() + timeout 2933 req = GroupGetRequest() 2934 if self.parent.snapshot_datetime is not None: 2935 req.meta.CopyFrom(GetRequestMetadata()) 2936 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2937 2938 req.id = (id) 2939 tries = 0 2940 plumbing_response = None 2941 while True: 2942 t = None if deadline is None else deadline - time.time() 2943 try: 2944 plumbing_response = self.stub.Get( 2945 req, 2946 metadata=self.parent.get_metadata('Groups.Get', req), 2947 timeout=t) 2948 except Exception as e: 2949 if self.parent.shouldRetry(tries, e, deadline): 2950 tries += 1 2951 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2952 continue 2953 raise plumbing.convert_error_to_porcelain(e) from e 2954 break 2955 2956 resp = models.GroupGetResponse() 2957 resp.group = plumbing.convert_group_to_porcelain( 2958 plumbing_response.group) 2959 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2960 plumbing_response.meta) 2961 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2962 plumbing_response.rate_limit) 2963 return resp 2964 2965 def update(self, group, timeout=None): 2966 ''' 2967 Update replaces all the fields of a Group by ID. 2968 ''' 2969 deadline = None if timeout is None else time.time() + timeout 2970 req = GroupUpdateRequest() 2971 2972 if group is not None: 2973 req.group.CopyFrom(plumbing.convert_group_to_plumbing(group)) 2974 tries = 0 2975 plumbing_response = None 2976 while True: 2977 t = None if deadline is None else deadline - time.time() 2978 try: 2979 plumbing_response = self.stub.Update( 2980 req, 2981 metadata=self.parent.get_metadata('Groups.Update', req), 2982 timeout=t) 2983 except Exception as e: 2984 if self.parent.shouldRetry(tries, e, deadline): 2985 tries += 1 2986 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2987 continue 2988 raise plumbing.convert_error_to_porcelain(e) from e 2989 break 2990 2991 resp = models.GroupUpdateResponse() 2992 resp.group = plumbing.convert_group_to_porcelain( 2993 plumbing_response.group) 2994 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2995 plumbing_response.rate_limit) 2996 return resp 2997 2998 def delete(self, id, timeout=None): 2999 ''' 3000 Delete removes a Group by ID. 3001 ''' 3002 deadline = None if timeout is None else time.time() + timeout 3003 req = GroupDeleteRequest() 3004 3005 req.id = (id) 3006 tries = 0 3007 plumbing_response = None 3008 while True: 3009 t = None if deadline is None else deadline - time.time() 3010 try: 3011 plumbing_response = self.stub.Delete( 3012 req, 3013 metadata=self.parent.get_metadata('Groups.Delete', req), 3014 timeout=t) 3015 except Exception as e: 3016 if self.parent.shouldRetry(tries, e, deadline): 3017 tries += 1 3018 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3019 continue 3020 raise plumbing.convert_error_to_porcelain(e) from e 3021 break 3022 3023 resp = models.GroupDeleteResponse() 3024 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3025 plumbing_response.meta) 3026 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3027 plumbing_response.rate_limit) 3028 return resp 3029 3030 def list(self, filter, *args, timeout=None): 3031 ''' 3032 List gets a list of Groups matching a given set of criteria. 3033 ''' 3034 deadline = None if timeout is None else time.time() + timeout 3035 req = GroupListRequest() 3036 req.meta.CopyFrom(ListRequestMetadata()) 3037 if self.parent.page_limit > 0: 3038 req.meta.limit = self.parent.page_limit 3039 if self.parent.snapshot_datetime is not None: 3040 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3041 3042 req.filter = plumbing.quote_filter_args(filter, *args) 3043 3044 def generator(svc, req): 3045 tries = 0 3046 while True: 3047 t = None if deadline is None else deadline - time.time() 3048 try: 3049 plumbing_response = svc.stub.List( 3050 req, 3051 metadata=svc.parent.get_metadata('Groups.List', req), 3052 timeout=t) 3053 except Exception as e: 3054 if self.parent.shouldRetry(tries, e, deadline): 3055 tries += 1 3056 time.sleep( 3057 self.parent.exponentialBackoff(tries, deadline)) 3058 continue 3059 raise plumbing.convert_error_to_porcelain(e) from e 3060 tries = 0 3061 for plumbing_item in plumbing_response.groups: 3062 yield plumbing.convert_group_to_porcelain(plumbing_item) 3063 if plumbing_response.meta.next_cursor == '': 3064 break 3065 req.meta.cursor = plumbing_response.meta.next_cursor 3066 3067 return generator(self, req)
A Group is a set of principals.
See strongdm.models.Group.
def
create(self, group, timeout=None)
2864 def create(self, group, timeout=None): 2865 ''' 2866 Create registers a new Group. 2867 ''' 2868 deadline = None if timeout is None else time.time() + timeout 2869 req = GroupCreateRequest() 2870 2871 if group is not None: 2872 req.group.CopyFrom(plumbing.convert_group_to_plumbing(group)) 2873 tries = 0 2874 plumbing_response = None 2875 while True: 2876 t = None if deadline is None else deadline - time.time() 2877 try: 2878 plumbing_response = self.stub.Create( 2879 req, 2880 metadata=self.parent.get_metadata('Groups.Create', req), 2881 timeout=t) 2882 except Exception as e: 2883 if self.parent.shouldRetry(tries, e, deadline): 2884 tries += 1 2885 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2886 continue 2887 raise plumbing.convert_error_to_porcelain(e) from e 2888 break 2889 2890 resp = models.GroupCreateResponse() 2891 resp.group = plumbing.convert_group_to_porcelain( 2892 plumbing_response.group) 2893 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2894 plumbing_response.rate_limit) 2895 return resp
Create registers a new Group.
def
create_from_roles(self, role_ids, commit, timeout=None)
2897 def create_from_roles(self, role_ids, commit, timeout=None): 2898 deadline = None if timeout is None else time.time() + timeout 2899 req = GroupCreateFromRolesRequest() 2900 2901 req.role_ids.extend((role_ids)) 2902 req.commit = (commit) 2903 tries = 0 2904 plumbing_response = None 2905 while True: 2906 t = None if deadline is None else deadline - time.time() 2907 try: 2908 plumbing_response = self.stub.CreateFromRoles( 2909 req, 2910 metadata=self.parent.get_metadata('Groups.CreateFromRoles', 2911 req), 2912 timeout=t) 2913 except Exception as e: 2914 if self.parent.shouldRetry(tries, e, deadline): 2915 tries += 1 2916 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2917 continue 2918 raise plumbing.convert_error_to_porcelain(e) from e 2919 break 2920 2921 resp = models.GroupCreateFromRolesResponse() 2922 resp.group_from_role = plumbing.convert_repeated_group_from_role_to_porcelain( 2923 plumbing_response.group_from_role) 2924 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2925 plumbing_response.rate_limit) 2926 return resp
def
get(self, id, timeout=None)
2928 def get(self, id, timeout=None): 2929 ''' 2930 Get reads one Group by ID. 2931 ''' 2932 deadline = None if timeout is None else time.time() + timeout 2933 req = GroupGetRequest() 2934 if self.parent.snapshot_datetime is not None: 2935 req.meta.CopyFrom(GetRequestMetadata()) 2936 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2937 2938 req.id = (id) 2939 tries = 0 2940 plumbing_response = None 2941 while True: 2942 t = None if deadline is None else deadline - time.time() 2943 try: 2944 plumbing_response = self.stub.Get( 2945 req, 2946 metadata=self.parent.get_metadata('Groups.Get', req), 2947 timeout=t) 2948 except Exception as e: 2949 if self.parent.shouldRetry(tries, e, deadline): 2950 tries += 1 2951 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2952 continue 2953 raise plumbing.convert_error_to_porcelain(e) from e 2954 break 2955 2956 resp = models.GroupGetResponse() 2957 resp.group = plumbing.convert_group_to_porcelain( 2958 plumbing_response.group) 2959 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2960 plumbing_response.meta) 2961 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2962 plumbing_response.rate_limit) 2963 return resp
Get reads one Group by ID.
def
update(self, group, timeout=None)
2965 def update(self, group, timeout=None): 2966 ''' 2967 Update replaces all the fields of a Group by ID. 2968 ''' 2969 deadline = None if timeout is None else time.time() + timeout 2970 req = GroupUpdateRequest() 2971 2972 if group is not None: 2973 req.group.CopyFrom(plumbing.convert_group_to_plumbing(group)) 2974 tries = 0 2975 plumbing_response = None 2976 while True: 2977 t = None if deadline is None else deadline - time.time() 2978 try: 2979 plumbing_response = self.stub.Update( 2980 req, 2981 metadata=self.parent.get_metadata('Groups.Update', req), 2982 timeout=t) 2983 except Exception as e: 2984 if self.parent.shouldRetry(tries, e, deadline): 2985 tries += 1 2986 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2987 continue 2988 raise plumbing.convert_error_to_porcelain(e) from e 2989 break 2990 2991 resp = models.GroupUpdateResponse() 2992 resp.group = plumbing.convert_group_to_porcelain( 2993 plumbing_response.group) 2994 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2995 plumbing_response.rate_limit) 2996 return resp
Update replaces all the fields of a Group by ID.
def
delete(self, id, timeout=None)
2998 def delete(self, id, timeout=None): 2999 ''' 3000 Delete removes a Group by ID. 3001 ''' 3002 deadline = None if timeout is None else time.time() + timeout 3003 req = GroupDeleteRequest() 3004 3005 req.id = (id) 3006 tries = 0 3007 plumbing_response = None 3008 while True: 3009 t = None if deadline is None else deadline - time.time() 3010 try: 3011 plumbing_response = self.stub.Delete( 3012 req, 3013 metadata=self.parent.get_metadata('Groups.Delete', req), 3014 timeout=t) 3015 except Exception as e: 3016 if self.parent.shouldRetry(tries, e, deadline): 3017 tries += 1 3018 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3019 continue 3020 raise plumbing.convert_error_to_porcelain(e) from e 3021 break 3022 3023 resp = models.GroupDeleteResponse() 3024 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3025 plumbing_response.meta) 3026 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3027 plumbing_response.rate_limit) 3028 return resp
Delete removes a Group by ID.
def
list(self, filter, *args, timeout=None)
3030 def list(self, filter, *args, timeout=None): 3031 ''' 3032 List gets a list of Groups matching a given set of criteria. 3033 ''' 3034 deadline = None if timeout is None else time.time() + timeout 3035 req = GroupListRequest() 3036 req.meta.CopyFrom(ListRequestMetadata()) 3037 if self.parent.page_limit > 0: 3038 req.meta.limit = self.parent.page_limit 3039 if self.parent.snapshot_datetime is not None: 3040 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3041 3042 req.filter = plumbing.quote_filter_args(filter, *args) 3043 3044 def generator(svc, req): 3045 tries = 0 3046 while True: 3047 t = None if deadline is None else deadline - time.time() 3048 try: 3049 plumbing_response = svc.stub.List( 3050 req, 3051 metadata=svc.parent.get_metadata('Groups.List', req), 3052 timeout=t) 3053 except Exception as e: 3054 if self.parent.shouldRetry(tries, e, deadline): 3055 tries += 1 3056 time.sleep( 3057 self.parent.exponentialBackoff(tries, deadline)) 3058 continue 3059 raise plumbing.convert_error_to_porcelain(e) from e 3060 tries = 0 3061 for plumbing_item in plumbing_response.groups: 3062 yield plumbing.convert_group_to_porcelain(plumbing_item) 3063 if plumbing_response.meta.next_cursor == '': 3064 break 3065 req.meta.cursor = plumbing_response.meta.next_cursor 3066 3067 return generator(self, req)
List gets a list of Groups matching a given set of criteria.
class
SnapshotGroups:
3070class SnapshotGroups: 3071 ''' 3072 SnapshotGroups exposes the read only methods of the Groups 3073 service for historical queries. 3074 ''' 3075 def __init__(self, groups): 3076 self.groups = groups 3077 3078 def get(self, id, timeout=None): 3079 ''' 3080 Get reads one Group by ID. 3081 ''' 3082 return self.groups.get(id, timeout=timeout) 3083 3084 def list(self, filter, *args, timeout=None): 3085 ''' 3086 List gets a list of Groups matching a given set of criteria. 3087 ''' 3088 return self.groups.list(filter, *args, timeout=timeout)
SnapshotGroups exposes the read only methods of the Groups service for historical queries.
class
GroupsHistory:
3091class GroupsHistory: 3092 ''' 3093 GroupsHistory records all changes to the state of a Group. 3094 See `strongdm.models.GroupHistory`. 3095 ''' 3096 def __init__(self, channel, client): 3097 self.parent = client 3098 self.stub = GroupsHistoryStub(channel) 3099 3100 def list(self, filter, *args, timeout=None): 3101 ''' 3102 List gets a list of GroupHistory records matching a given set of criteria. 3103 ''' 3104 deadline = None if timeout is None else time.time() + timeout 3105 req = GroupHistoryListRequest() 3106 req.meta.CopyFrom(ListRequestMetadata()) 3107 if self.parent.page_limit > 0: 3108 req.meta.limit = self.parent.page_limit 3109 if self.parent.snapshot_datetime is not None: 3110 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3111 3112 req.filter = plumbing.quote_filter_args(filter, *args) 3113 3114 def generator(svc, req): 3115 tries = 0 3116 while True: 3117 t = None if deadline is None else deadline - time.time() 3118 try: 3119 plumbing_response = svc.stub.List( 3120 req, 3121 metadata=svc.parent.get_metadata( 3122 'GroupsHistory.List', req), 3123 timeout=t) 3124 except Exception as e: 3125 if self.parent.shouldRetry(tries, e, deadline): 3126 tries += 1 3127 time.sleep( 3128 self.parent.exponentialBackoff(tries, deadline)) 3129 continue 3130 raise plumbing.convert_error_to_porcelain(e) from e 3131 tries = 0 3132 for plumbing_item in plumbing_response.history: 3133 yield plumbing.convert_group_history_to_porcelain( 3134 plumbing_item) 3135 if plumbing_response.meta.next_cursor == '': 3136 break 3137 req.meta.cursor = plumbing_response.meta.next_cursor 3138 3139 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)
3100 def list(self, filter, *args, timeout=None): 3101 ''' 3102 List gets a list of GroupHistory records matching a given set of criteria. 3103 ''' 3104 deadline = None if timeout is None else time.time() + timeout 3105 req = GroupHistoryListRequest() 3106 req.meta.CopyFrom(ListRequestMetadata()) 3107 if self.parent.page_limit > 0: 3108 req.meta.limit = self.parent.page_limit 3109 if self.parent.snapshot_datetime is not None: 3110 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3111 3112 req.filter = plumbing.quote_filter_args(filter, *args) 3113 3114 def generator(svc, req): 3115 tries = 0 3116 while True: 3117 t = None if deadline is None else deadline - time.time() 3118 try: 3119 plumbing_response = svc.stub.List( 3120 req, 3121 metadata=svc.parent.get_metadata( 3122 'GroupsHistory.List', req), 3123 timeout=t) 3124 except Exception as e: 3125 if self.parent.shouldRetry(tries, e, deadline): 3126 tries += 1 3127 time.sleep( 3128 self.parent.exponentialBackoff(tries, deadline)) 3129 continue 3130 raise plumbing.convert_error_to_porcelain(e) from e 3131 tries = 0 3132 for plumbing_item in plumbing_response.history: 3133 yield plumbing.convert_group_history_to_porcelain( 3134 plumbing_item) 3135 if plumbing_response.meta.next_cursor == '': 3136 break 3137 req.meta.cursor = plumbing_response.meta.next_cursor 3138 3139 return generator(self, req)
List gets a list of GroupHistory records matching a given set of criteria.
class
GroupsRoles:
3142class GroupsRoles: 3143 ''' 3144 A GroupRole is an assignment of a Group to a Role. 3145 See `strongdm.models.GroupRole`. 3146 ''' 3147 def __init__(self, channel, client): 3148 self.parent = client 3149 self.stub = GroupsRolesStub(channel) 3150 3151 def create(self, group_role, timeout=None): 3152 ''' 3153 Create registers a new GroupRole. 3154 ''' 3155 deadline = None if timeout is None else time.time() + timeout 3156 req = GroupRoleCreateRequest() 3157 3158 if group_role is not None: 3159 req.group_role.CopyFrom( 3160 plumbing.convert_group_role_to_plumbing(group_role)) 3161 tries = 0 3162 plumbing_response = None 3163 while True: 3164 t = None if deadline is None else deadline - time.time() 3165 try: 3166 plumbing_response = self.stub.Create( 3167 req, 3168 metadata=self.parent.get_metadata('GroupsRoles.Create', 3169 req), 3170 timeout=t) 3171 except Exception as e: 3172 if self.parent.shouldRetry(tries, e, deadline): 3173 tries += 1 3174 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3175 continue 3176 raise plumbing.convert_error_to_porcelain(e) from e 3177 break 3178 3179 resp = models.GroupRoleCreateResponse() 3180 resp.group_role = plumbing.convert_group_role_to_porcelain( 3181 plumbing_response.group_role) 3182 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3183 plumbing_response.rate_limit) 3184 return resp 3185 3186 def get(self, id, timeout=None): 3187 ''' 3188 Get reads one GroupRole by ID. 3189 ''' 3190 deadline = None if timeout is None else time.time() + timeout 3191 req = GroupRoleGetRequest() 3192 if self.parent.snapshot_datetime is not None: 3193 req.meta.CopyFrom(GetRequestMetadata()) 3194 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3195 3196 req.id = (id) 3197 tries = 0 3198 plumbing_response = None 3199 while True: 3200 t = None if deadline is None else deadline - time.time() 3201 try: 3202 plumbing_response = self.stub.Get( 3203 req, 3204 metadata=self.parent.get_metadata('GroupsRoles.Get', req), 3205 timeout=t) 3206 except Exception as e: 3207 if self.parent.shouldRetry(tries, e, deadline): 3208 tries += 1 3209 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3210 continue 3211 raise plumbing.convert_error_to_porcelain(e) from e 3212 break 3213 3214 resp = models.GroupRoleGetResponse() 3215 resp.group_role = plumbing.convert_group_role_to_porcelain( 3216 plumbing_response.group_role) 3217 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3218 plumbing_response.meta) 3219 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3220 plumbing_response.rate_limit) 3221 return resp 3222 3223 def delete(self, id, timeout=None): 3224 ''' 3225 Delete removes a GroupRole by ID. 3226 ''' 3227 deadline = None if timeout is None else time.time() + timeout 3228 req = GroupRoleDeleteRequest() 3229 3230 req.id = (id) 3231 tries = 0 3232 plumbing_response = None 3233 while True: 3234 t = None if deadline is None else deadline - time.time() 3235 try: 3236 plumbing_response = self.stub.Delete( 3237 req, 3238 metadata=self.parent.get_metadata('GroupsRoles.Delete', 3239 req), 3240 timeout=t) 3241 except Exception as e: 3242 if self.parent.shouldRetry(tries, e, deadline): 3243 tries += 1 3244 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3245 continue 3246 raise plumbing.convert_error_to_porcelain(e) from e 3247 break 3248 3249 resp = models.GroupRoleDeleteResponse() 3250 resp.group_role = plumbing.convert_group_role_to_porcelain( 3251 plumbing_response.group_role) 3252 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3253 plumbing_response.meta) 3254 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3255 plumbing_response.rate_limit) 3256 return resp 3257 3258 def list(self, filter, *args, timeout=None): 3259 ''' 3260 List gets a list of GroupRoles matching a given set of criteria. 3261 ''' 3262 deadline = None if timeout is None else time.time() + timeout 3263 req = GroupRoleListRequest() 3264 req.meta.CopyFrom(ListRequestMetadata()) 3265 if self.parent.page_limit > 0: 3266 req.meta.limit = self.parent.page_limit 3267 if self.parent.snapshot_datetime is not None: 3268 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3269 3270 req.filter = plumbing.quote_filter_args(filter, *args) 3271 3272 def generator(svc, req): 3273 tries = 0 3274 while True: 3275 t = None if deadline is None else deadline - time.time() 3276 try: 3277 plumbing_response = svc.stub.List( 3278 req, 3279 metadata=svc.parent.get_metadata( 3280 'GroupsRoles.List', req), 3281 timeout=t) 3282 except Exception as e: 3283 if self.parent.shouldRetry(tries, e, deadline): 3284 tries += 1 3285 time.sleep( 3286 self.parent.exponentialBackoff(tries, deadline)) 3287 continue 3288 raise plumbing.convert_error_to_porcelain(e) from e 3289 tries = 0 3290 for plumbing_item in plumbing_response.groups_roles: 3291 yield plumbing.convert_group_role_to_porcelain( 3292 plumbing_item) 3293 if plumbing_response.meta.next_cursor == '': 3294 break 3295 req.meta.cursor = plumbing_response.meta.next_cursor 3296 3297 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)
3151 def create(self, group_role, timeout=None): 3152 ''' 3153 Create registers a new GroupRole. 3154 ''' 3155 deadline = None if timeout is None else time.time() + timeout 3156 req = GroupRoleCreateRequest() 3157 3158 if group_role is not None: 3159 req.group_role.CopyFrom( 3160 plumbing.convert_group_role_to_plumbing(group_role)) 3161 tries = 0 3162 plumbing_response = None 3163 while True: 3164 t = None if deadline is None else deadline - time.time() 3165 try: 3166 plumbing_response = self.stub.Create( 3167 req, 3168 metadata=self.parent.get_metadata('GroupsRoles.Create', 3169 req), 3170 timeout=t) 3171 except Exception as e: 3172 if self.parent.shouldRetry(tries, e, deadline): 3173 tries += 1 3174 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3175 continue 3176 raise plumbing.convert_error_to_porcelain(e) from e 3177 break 3178 3179 resp = models.GroupRoleCreateResponse() 3180 resp.group_role = plumbing.convert_group_role_to_porcelain( 3181 plumbing_response.group_role) 3182 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3183 plumbing_response.rate_limit) 3184 return resp
Create registers a new GroupRole.
def
get(self, id, timeout=None)
3186 def get(self, id, timeout=None): 3187 ''' 3188 Get reads one GroupRole by ID. 3189 ''' 3190 deadline = None if timeout is None else time.time() + timeout 3191 req = GroupRoleGetRequest() 3192 if self.parent.snapshot_datetime is not None: 3193 req.meta.CopyFrom(GetRequestMetadata()) 3194 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3195 3196 req.id = (id) 3197 tries = 0 3198 plumbing_response = None 3199 while True: 3200 t = None if deadline is None else deadline - time.time() 3201 try: 3202 plumbing_response = self.stub.Get( 3203 req, 3204 metadata=self.parent.get_metadata('GroupsRoles.Get', req), 3205 timeout=t) 3206 except Exception as e: 3207 if self.parent.shouldRetry(tries, e, deadline): 3208 tries += 1 3209 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3210 continue 3211 raise plumbing.convert_error_to_porcelain(e) from e 3212 break 3213 3214 resp = models.GroupRoleGetResponse() 3215 resp.group_role = plumbing.convert_group_role_to_porcelain( 3216 plumbing_response.group_role) 3217 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3218 plumbing_response.meta) 3219 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3220 plumbing_response.rate_limit) 3221 return resp
Get reads one GroupRole by ID.
def
delete(self, id, timeout=None)
3223 def delete(self, id, timeout=None): 3224 ''' 3225 Delete removes a GroupRole by ID. 3226 ''' 3227 deadline = None if timeout is None else time.time() + timeout 3228 req = GroupRoleDeleteRequest() 3229 3230 req.id = (id) 3231 tries = 0 3232 plumbing_response = None 3233 while True: 3234 t = None if deadline is None else deadline - time.time() 3235 try: 3236 plumbing_response = self.stub.Delete( 3237 req, 3238 metadata=self.parent.get_metadata('GroupsRoles.Delete', 3239 req), 3240 timeout=t) 3241 except Exception as e: 3242 if self.parent.shouldRetry(tries, e, deadline): 3243 tries += 1 3244 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3245 continue 3246 raise plumbing.convert_error_to_porcelain(e) from e 3247 break 3248 3249 resp = models.GroupRoleDeleteResponse() 3250 resp.group_role = plumbing.convert_group_role_to_porcelain( 3251 plumbing_response.group_role) 3252 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3253 plumbing_response.meta) 3254 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3255 plumbing_response.rate_limit) 3256 return resp
Delete removes a GroupRole by ID.
def
list(self, filter, *args, timeout=None)
3258 def list(self, filter, *args, timeout=None): 3259 ''' 3260 List gets a list of GroupRoles matching a given set of criteria. 3261 ''' 3262 deadline = None if timeout is None else time.time() + timeout 3263 req = GroupRoleListRequest() 3264 req.meta.CopyFrom(ListRequestMetadata()) 3265 if self.parent.page_limit > 0: 3266 req.meta.limit = self.parent.page_limit 3267 if self.parent.snapshot_datetime is not None: 3268 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3269 3270 req.filter = plumbing.quote_filter_args(filter, *args) 3271 3272 def generator(svc, req): 3273 tries = 0 3274 while True: 3275 t = None if deadline is None else deadline - time.time() 3276 try: 3277 plumbing_response = svc.stub.List( 3278 req, 3279 metadata=svc.parent.get_metadata( 3280 'GroupsRoles.List', req), 3281 timeout=t) 3282 except Exception as e: 3283 if self.parent.shouldRetry(tries, e, deadline): 3284 tries += 1 3285 time.sleep( 3286 self.parent.exponentialBackoff(tries, deadline)) 3287 continue 3288 raise plumbing.convert_error_to_porcelain(e) from e 3289 tries = 0 3290 for plumbing_item in plumbing_response.groups_roles: 3291 yield plumbing.convert_group_role_to_porcelain( 3292 plumbing_item) 3293 if plumbing_response.meta.next_cursor == '': 3294 break 3295 req.meta.cursor = plumbing_response.meta.next_cursor 3296 3297 return generator(self, req)
List gets a list of GroupRoles matching a given set of criteria.
class
SnapshotGroupsRoles:
3300class SnapshotGroupsRoles: 3301 ''' 3302 SnapshotGroupsRoles exposes the read only methods of the GroupsRoles 3303 service for historical queries. 3304 ''' 3305 def __init__(self, groups_roles): 3306 self.groups_roles = groups_roles 3307 3308 def get(self, id, timeout=None): 3309 ''' 3310 Get reads one GroupRole by ID. 3311 ''' 3312 return self.groups_roles.get(id, timeout=timeout) 3313 3314 def list(self, filter, *args, timeout=None): 3315 ''' 3316 List gets a list of GroupRoles matching a given set of criteria. 3317 ''' 3318 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)
3308 def get(self, id, timeout=None): 3309 ''' 3310 Get reads one GroupRole by ID. 3311 ''' 3312 return self.groups_roles.get(id, timeout=timeout)
Get reads one GroupRole by ID.
def
list(self, filter, *args, timeout=None)
3314 def list(self, filter, *args, timeout=None): 3315 ''' 3316 List gets a list of GroupRoles matching a given set of criteria. 3317 ''' 3318 return self.groups_roles.list(filter, *args, timeout=timeout)
List gets a list of GroupRoles matching a given set of criteria.
class
GroupsRolesHistory:
3321class GroupsRolesHistory: 3322 ''' 3323 GroupsRolesHistory records all changes to the state of a GroupRole. 3324 See `strongdm.models.GroupRoleHistory`. 3325 ''' 3326 def __init__(self, channel, client): 3327 self.parent = client 3328 self.stub = GroupsRolesHistoryStub(channel) 3329 3330 def list(self, filter, *args, timeout=None): 3331 ''' 3332 List gets a list of GroupRoleHistory records matching a given set of criteria. 3333 ''' 3334 deadline = None if timeout is None else time.time() + timeout 3335 req = GroupRoleHistoryListRequest() 3336 req.meta.CopyFrom(ListRequestMetadata()) 3337 if self.parent.page_limit > 0: 3338 req.meta.limit = self.parent.page_limit 3339 if self.parent.snapshot_datetime is not None: 3340 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3341 3342 req.filter = plumbing.quote_filter_args(filter, *args) 3343 3344 def generator(svc, req): 3345 tries = 0 3346 while True: 3347 t = None if deadline is None else deadline - time.time() 3348 try: 3349 plumbing_response = svc.stub.List( 3350 req, 3351 metadata=svc.parent.get_metadata( 3352 'GroupsRolesHistory.List', req), 3353 timeout=t) 3354 except Exception as e: 3355 if self.parent.shouldRetry(tries, e, deadline): 3356 tries += 1 3357 time.sleep( 3358 self.parent.exponentialBackoff(tries, deadline)) 3359 continue 3360 raise plumbing.convert_error_to_porcelain(e) from e 3361 tries = 0 3362 for plumbing_item in plumbing_response.history: 3363 yield plumbing.convert_group_role_history_to_porcelain( 3364 plumbing_item) 3365 if plumbing_response.meta.next_cursor == '': 3366 break 3367 req.meta.cursor = plumbing_response.meta.next_cursor 3368 3369 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)
3330 def list(self, filter, *args, timeout=None): 3331 ''' 3332 List gets a list of GroupRoleHistory records matching a given set of criteria. 3333 ''' 3334 deadline = None if timeout is None else time.time() + timeout 3335 req = GroupRoleHistoryListRequest() 3336 req.meta.CopyFrom(ListRequestMetadata()) 3337 if self.parent.page_limit > 0: 3338 req.meta.limit = self.parent.page_limit 3339 if self.parent.snapshot_datetime is not None: 3340 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3341 3342 req.filter = plumbing.quote_filter_args(filter, *args) 3343 3344 def generator(svc, req): 3345 tries = 0 3346 while True: 3347 t = None if deadline is None else deadline - time.time() 3348 try: 3349 plumbing_response = svc.stub.List( 3350 req, 3351 metadata=svc.parent.get_metadata( 3352 'GroupsRolesHistory.List', req), 3353 timeout=t) 3354 except Exception as e: 3355 if self.parent.shouldRetry(tries, e, deadline): 3356 tries += 1 3357 time.sleep( 3358 self.parent.exponentialBackoff(tries, deadline)) 3359 continue 3360 raise plumbing.convert_error_to_porcelain(e) from e 3361 tries = 0 3362 for plumbing_item in plumbing_response.history: 3363 yield plumbing.convert_group_role_history_to_porcelain( 3364 plumbing_item) 3365 if plumbing_response.meta.next_cursor == '': 3366 break 3367 req.meta.cursor = plumbing_response.meta.next_cursor 3368 3369 return generator(self, req)
List gets a list of GroupRoleHistory records matching a given set of criteria.
class
HealthChecks:
3372class HealthChecks: 3373 ''' 3374 HealthChecks lists the last healthcheck between each node and resource. 3375 Note the unconventional capitalization here is to prevent having a collision with GRPC 3376 See `strongdm.models.Healthcheck`. 3377 ''' 3378 def __init__(self, channel, client): 3379 self.parent = client 3380 self.stub = HealthChecksStub(channel) 3381 3382 def list(self, filter, *args, timeout=None): 3383 ''' 3384 List gets a list of Healthchecks matching a given set of criteria. 3385 ''' 3386 deadline = None if timeout is None else time.time() + timeout 3387 req = HealthcheckListRequest() 3388 req.meta.CopyFrom(ListRequestMetadata()) 3389 if self.parent.page_limit > 0: 3390 req.meta.limit = self.parent.page_limit 3391 if self.parent.snapshot_datetime is not None: 3392 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3393 3394 req.filter = plumbing.quote_filter_args(filter, *args) 3395 3396 def generator(svc, req): 3397 tries = 0 3398 while True: 3399 t = None if deadline is None else deadline - time.time() 3400 try: 3401 plumbing_response = svc.stub.List( 3402 req, 3403 metadata=svc.parent.get_metadata( 3404 'HealthChecks.List', req), 3405 timeout=t) 3406 except Exception as e: 3407 if self.parent.shouldRetry(tries, e, deadline): 3408 tries += 1 3409 time.sleep( 3410 self.parent.exponentialBackoff(tries, deadline)) 3411 continue 3412 raise plumbing.convert_error_to_porcelain(e) from e 3413 tries = 0 3414 for plumbing_item in plumbing_response.healthchecks: 3415 yield plumbing.convert_healthcheck_to_porcelain( 3416 plumbing_item) 3417 if plumbing_response.meta.next_cursor == '': 3418 break 3419 req.meta.cursor = plumbing_response.meta.next_cursor 3420 3421 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)
3382 def list(self, filter, *args, timeout=None): 3383 ''' 3384 List gets a list of Healthchecks matching a given set of criteria. 3385 ''' 3386 deadline = None if timeout is None else time.time() + timeout 3387 req = HealthcheckListRequest() 3388 req.meta.CopyFrom(ListRequestMetadata()) 3389 if self.parent.page_limit > 0: 3390 req.meta.limit = self.parent.page_limit 3391 if self.parent.snapshot_datetime is not None: 3392 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3393 3394 req.filter = plumbing.quote_filter_args(filter, *args) 3395 3396 def generator(svc, req): 3397 tries = 0 3398 while True: 3399 t = None if deadline is None else deadline - time.time() 3400 try: 3401 plumbing_response = svc.stub.List( 3402 req, 3403 metadata=svc.parent.get_metadata( 3404 'HealthChecks.List', req), 3405 timeout=t) 3406 except Exception as e: 3407 if self.parent.shouldRetry(tries, e, deadline): 3408 tries += 1 3409 time.sleep( 3410 self.parent.exponentialBackoff(tries, deadline)) 3411 continue 3412 raise plumbing.convert_error_to_porcelain(e) from e 3413 tries = 0 3414 for plumbing_item in plumbing_response.healthchecks: 3415 yield plumbing.convert_healthcheck_to_porcelain( 3416 plumbing_item) 3417 if plumbing_response.meta.next_cursor == '': 3418 break 3419 req.meta.cursor = plumbing_response.meta.next_cursor 3420 3421 return generator(self, req)
List gets a list of Healthchecks matching a given set of criteria.
class
IdentityAliases:
3424class IdentityAliases: 3425 ''' 3426 IdentityAliases assign an alias to an account within an IdentitySet. 3427 The alias is used as the username when connecting to a identity supported resource. 3428 See `strongdm.models.IdentityAlias`. 3429 ''' 3430 def __init__(self, channel, client): 3431 self.parent = client 3432 self.stub = IdentityAliasesStub(channel) 3433 3434 def create(self, identity_alias, timeout=None): 3435 ''' 3436 Create registers a new IdentityAlias. 3437 ''' 3438 deadline = None if timeout is None else time.time() + timeout 3439 req = IdentityAliasCreateRequest() 3440 3441 if identity_alias is not None: 3442 req.identity_alias.CopyFrom( 3443 plumbing.convert_identity_alias_to_plumbing(identity_alias)) 3444 tries = 0 3445 plumbing_response = None 3446 while True: 3447 t = None if deadline is None else deadline - time.time() 3448 try: 3449 plumbing_response = self.stub.Create( 3450 req, 3451 metadata=self.parent.get_metadata('IdentityAliases.Create', 3452 req), 3453 timeout=t) 3454 except Exception as e: 3455 if self.parent.shouldRetry(tries, e, deadline): 3456 tries += 1 3457 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3458 continue 3459 raise plumbing.convert_error_to_porcelain(e) from e 3460 break 3461 3462 resp = models.IdentityAliasCreateResponse() 3463 resp.identity_alias = plumbing.convert_identity_alias_to_porcelain( 3464 plumbing_response.identity_alias) 3465 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 3466 plumbing_response.meta) 3467 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3468 plumbing_response.rate_limit) 3469 return resp 3470 3471 def get(self, id, timeout=None): 3472 ''' 3473 Get reads one IdentityAlias by ID. 3474 ''' 3475 deadline = None if timeout is None else time.time() + timeout 3476 req = IdentityAliasGetRequest() 3477 if self.parent.snapshot_datetime is not None: 3478 req.meta.CopyFrom(GetRequestMetadata()) 3479 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3480 3481 req.id = (id) 3482 tries = 0 3483 plumbing_response = None 3484 while True: 3485 t = None if deadline is None else deadline - time.time() 3486 try: 3487 plumbing_response = self.stub.Get( 3488 req, 3489 metadata=self.parent.get_metadata('IdentityAliases.Get', 3490 req), 3491 timeout=t) 3492 except Exception as e: 3493 if self.parent.shouldRetry(tries, e, deadline): 3494 tries += 1 3495 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3496 continue 3497 raise plumbing.convert_error_to_porcelain(e) from e 3498 break 3499 3500 resp = models.IdentityAliasGetResponse() 3501 resp.identity_alias = plumbing.convert_identity_alias_to_porcelain( 3502 plumbing_response.identity_alias) 3503 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3504 plumbing_response.meta) 3505 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3506 plumbing_response.rate_limit) 3507 return resp 3508 3509 def update(self, identity_alias, timeout=None): 3510 ''' 3511 Update replaces all the fields of a IdentityAlias by ID. 3512 ''' 3513 deadline = None if timeout is None else time.time() + timeout 3514 req = IdentityAliasUpdateRequest() 3515 3516 if identity_alias is not None: 3517 req.identity_alias.CopyFrom( 3518 plumbing.convert_identity_alias_to_plumbing(identity_alias)) 3519 tries = 0 3520 plumbing_response = None 3521 while True: 3522 t = None if deadline is None else deadline - time.time() 3523 try: 3524 plumbing_response = self.stub.Update( 3525 req, 3526 metadata=self.parent.get_metadata('IdentityAliases.Update', 3527 req), 3528 timeout=t) 3529 except Exception as e: 3530 if self.parent.shouldRetry(tries, e, deadline): 3531 tries += 1 3532 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3533 continue 3534 raise plumbing.convert_error_to_porcelain(e) from e 3535 break 3536 3537 resp = models.IdentityAliasUpdateResponse() 3538 resp.identity_alias = plumbing.convert_identity_alias_to_porcelain( 3539 plumbing_response.identity_alias) 3540 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 3541 plumbing_response.meta) 3542 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3543 plumbing_response.rate_limit) 3544 return resp 3545 3546 def delete(self, id, timeout=None): 3547 ''' 3548 Delete removes a IdentityAlias by ID. 3549 ''' 3550 deadline = None if timeout is None else time.time() + timeout 3551 req = IdentityAliasDeleteRequest() 3552 3553 req.id = (id) 3554 tries = 0 3555 plumbing_response = None 3556 while True: 3557 t = None if deadline is None else deadline - time.time() 3558 try: 3559 plumbing_response = self.stub.Delete( 3560 req, 3561 metadata=self.parent.get_metadata('IdentityAliases.Delete', 3562 req), 3563 timeout=t) 3564 except Exception as e: 3565 if self.parent.shouldRetry(tries, e, deadline): 3566 tries += 1 3567 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3568 continue 3569 raise plumbing.convert_error_to_porcelain(e) from e 3570 break 3571 3572 resp = models.IdentityAliasDeleteResponse() 3573 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3574 plumbing_response.meta) 3575 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3576 plumbing_response.rate_limit) 3577 return resp 3578 3579 def list(self, filter, *args, timeout=None): 3580 ''' 3581 List gets a list of IdentityAliases matching a given set of criteria. 3582 ''' 3583 deadline = None if timeout is None else time.time() + timeout 3584 req = IdentityAliasListRequest() 3585 req.meta.CopyFrom(ListRequestMetadata()) 3586 if self.parent.page_limit > 0: 3587 req.meta.limit = self.parent.page_limit 3588 if self.parent.snapshot_datetime is not None: 3589 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3590 3591 req.filter = plumbing.quote_filter_args(filter, *args) 3592 3593 def generator(svc, req): 3594 tries = 0 3595 while True: 3596 t = None if deadline is None else deadline - time.time() 3597 try: 3598 plumbing_response = svc.stub.List( 3599 req, 3600 metadata=svc.parent.get_metadata( 3601 'IdentityAliases.List', req), 3602 timeout=t) 3603 except Exception as e: 3604 if self.parent.shouldRetry(tries, e, deadline): 3605 tries += 1 3606 time.sleep( 3607 self.parent.exponentialBackoff(tries, deadline)) 3608 continue 3609 raise plumbing.convert_error_to_porcelain(e) from e 3610 tries = 0 3611 for plumbing_item in plumbing_response.identity_aliases: 3612 yield plumbing.convert_identity_alias_to_porcelain( 3613 plumbing_item) 3614 if plumbing_response.meta.next_cursor == '': 3615 break 3616 req.meta.cursor = plumbing_response.meta.next_cursor 3617 3618 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)
3434 def create(self, identity_alias, timeout=None): 3435 ''' 3436 Create registers a new IdentityAlias. 3437 ''' 3438 deadline = None if timeout is None else time.time() + timeout 3439 req = IdentityAliasCreateRequest() 3440 3441 if identity_alias is not None: 3442 req.identity_alias.CopyFrom( 3443 plumbing.convert_identity_alias_to_plumbing(identity_alias)) 3444 tries = 0 3445 plumbing_response = None 3446 while True: 3447 t = None if deadline is None else deadline - time.time() 3448 try: 3449 plumbing_response = self.stub.Create( 3450 req, 3451 metadata=self.parent.get_metadata('IdentityAliases.Create', 3452 req), 3453 timeout=t) 3454 except Exception as e: 3455 if self.parent.shouldRetry(tries, e, deadline): 3456 tries += 1 3457 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3458 continue 3459 raise plumbing.convert_error_to_porcelain(e) from e 3460 break 3461 3462 resp = models.IdentityAliasCreateResponse() 3463 resp.identity_alias = plumbing.convert_identity_alias_to_porcelain( 3464 plumbing_response.identity_alias) 3465 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 3466 plumbing_response.meta) 3467 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3468 plumbing_response.rate_limit) 3469 return resp
Create registers a new IdentityAlias.
def
get(self, id, timeout=None)
3471 def get(self, id, timeout=None): 3472 ''' 3473 Get reads one IdentityAlias by ID. 3474 ''' 3475 deadline = None if timeout is None else time.time() + timeout 3476 req = IdentityAliasGetRequest() 3477 if self.parent.snapshot_datetime is not None: 3478 req.meta.CopyFrom(GetRequestMetadata()) 3479 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3480 3481 req.id = (id) 3482 tries = 0 3483 plumbing_response = None 3484 while True: 3485 t = None if deadline is None else deadline - time.time() 3486 try: 3487 plumbing_response = self.stub.Get( 3488 req, 3489 metadata=self.parent.get_metadata('IdentityAliases.Get', 3490 req), 3491 timeout=t) 3492 except Exception as e: 3493 if self.parent.shouldRetry(tries, e, deadline): 3494 tries += 1 3495 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3496 continue 3497 raise plumbing.convert_error_to_porcelain(e) from e 3498 break 3499 3500 resp = models.IdentityAliasGetResponse() 3501 resp.identity_alias = plumbing.convert_identity_alias_to_porcelain( 3502 plumbing_response.identity_alias) 3503 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3504 plumbing_response.meta) 3505 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3506 plumbing_response.rate_limit) 3507 return resp
Get reads one IdentityAlias by ID.
def
update(self, identity_alias, timeout=None)
3509 def update(self, identity_alias, timeout=None): 3510 ''' 3511 Update replaces all the fields of a IdentityAlias by ID. 3512 ''' 3513 deadline = None if timeout is None else time.time() + timeout 3514 req = IdentityAliasUpdateRequest() 3515 3516 if identity_alias is not None: 3517 req.identity_alias.CopyFrom( 3518 plumbing.convert_identity_alias_to_plumbing(identity_alias)) 3519 tries = 0 3520 plumbing_response = None 3521 while True: 3522 t = None if deadline is None else deadline - time.time() 3523 try: 3524 plumbing_response = self.stub.Update( 3525 req, 3526 metadata=self.parent.get_metadata('IdentityAliases.Update', 3527 req), 3528 timeout=t) 3529 except Exception as e: 3530 if self.parent.shouldRetry(tries, e, deadline): 3531 tries += 1 3532 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3533 continue 3534 raise plumbing.convert_error_to_porcelain(e) from e 3535 break 3536 3537 resp = models.IdentityAliasUpdateResponse() 3538 resp.identity_alias = plumbing.convert_identity_alias_to_porcelain( 3539 plumbing_response.identity_alias) 3540 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 3541 plumbing_response.meta) 3542 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3543 plumbing_response.rate_limit) 3544 return resp
Update replaces all the fields of a IdentityAlias by ID.
def
delete(self, id, timeout=None)
3546 def delete(self, id, timeout=None): 3547 ''' 3548 Delete removes a IdentityAlias by ID. 3549 ''' 3550 deadline = None if timeout is None else time.time() + timeout 3551 req = IdentityAliasDeleteRequest() 3552 3553 req.id = (id) 3554 tries = 0 3555 plumbing_response = None 3556 while True: 3557 t = None if deadline is None else deadline - time.time() 3558 try: 3559 plumbing_response = self.stub.Delete( 3560 req, 3561 metadata=self.parent.get_metadata('IdentityAliases.Delete', 3562 req), 3563 timeout=t) 3564 except Exception as e: 3565 if self.parent.shouldRetry(tries, e, deadline): 3566 tries += 1 3567 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3568 continue 3569 raise plumbing.convert_error_to_porcelain(e) from e 3570 break 3571 3572 resp = models.IdentityAliasDeleteResponse() 3573 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3574 plumbing_response.meta) 3575 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3576 plumbing_response.rate_limit) 3577 return resp
Delete removes a IdentityAlias by ID.
def
list(self, filter, *args, timeout=None)
3579 def list(self, filter, *args, timeout=None): 3580 ''' 3581 List gets a list of IdentityAliases matching a given set of criteria. 3582 ''' 3583 deadline = None if timeout is None else time.time() + timeout 3584 req = IdentityAliasListRequest() 3585 req.meta.CopyFrom(ListRequestMetadata()) 3586 if self.parent.page_limit > 0: 3587 req.meta.limit = self.parent.page_limit 3588 if self.parent.snapshot_datetime is not None: 3589 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3590 3591 req.filter = plumbing.quote_filter_args(filter, *args) 3592 3593 def generator(svc, req): 3594 tries = 0 3595 while True: 3596 t = None if deadline is None else deadline - time.time() 3597 try: 3598 plumbing_response = svc.stub.List( 3599 req, 3600 metadata=svc.parent.get_metadata( 3601 'IdentityAliases.List', req), 3602 timeout=t) 3603 except Exception as e: 3604 if self.parent.shouldRetry(tries, e, deadline): 3605 tries += 1 3606 time.sleep( 3607 self.parent.exponentialBackoff(tries, deadline)) 3608 continue 3609 raise plumbing.convert_error_to_porcelain(e) from e 3610 tries = 0 3611 for plumbing_item in plumbing_response.identity_aliases: 3612 yield plumbing.convert_identity_alias_to_porcelain( 3613 plumbing_item) 3614 if plumbing_response.meta.next_cursor == '': 3615 break 3616 req.meta.cursor = plumbing_response.meta.next_cursor 3617 3618 return generator(self, req)
List gets a list of IdentityAliases matching a given set of criteria.
class
SnapshotIdentityAliases:
3621class SnapshotIdentityAliases: 3622 ''' 3623 SnapshotIdentityAliases exposes the read only methods of the IdentityAliases 3624 service for historical queries. 3625 ''' 3626 def __init__(self, identity_aliases): 3627 self.identity_aliases = identity_aliases 3628 3629 def get(self, id, timeout=None): 3630 ''' 3631 Get reads one IdentityAlias by ID. 3632 ''' 3633 return self.identity_aliases.get(id, timeout=timeout) 3634 3635 def list(self, filter, *args, timeout=None): 3636 ''' 3637 List gets a list of IdentityAliases matching a given set of criteria. 3638 ''' 3639 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)
3629 def get(self, id, timeout=None): 3630 ''' 3631 Get reads one IdentityAlias by ID. 3632 ''' 3633 return self.identity_aliases.get(id, timeout=timeout)
Get reads one IdentityAlias by ID.
def
list(self, filter, *args, timeout=None)
3635 def list(self, filter, *args, timeout=None): 3636 ''' 3637 List gets a list of IdentityAliases matching a given set of criteria. 3638 ''' 3639 return self.identity_aliases.list(filter, *args, timeout=timeout)
List gets a list of IdentityAliases matching a given set of criteria.
class
IdentityAliasesHistory:
3642class IdentityAliasesHistory: 3643 ''' 3644 IdentityAliasesHistory records all changes to the state of a IdentityAlias. 3645 See `strongdm.models.IdentityAliasHistory`. 3646 ''' 3647 def __init__(self, channel, client): 3648 self.parent = client 3649 self.stub = IdentityAliasesHistoryStub(channel) 3650 3651 def list(self, filter, *args, timeout=None): 3652 ''' 3653 List gets a list of IdentityAliasHistory records matching a given set of criteria. 3654 ''' 3655 deadline = None if timeout is None else time.time() + timeout 3656 req = IdentityAliasHistoryListRequest() 3657 req.meta.CopyFrom(ListRequestMetadata()) 3658 if self.parent.page_limit > 0: 3659 req.meta.limit = self.parent.page_limit 3660 if self.parent.snapshot_datetime is not None: 3661 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3662 3663 req.filter = plumbing.quote_filter_args(filter, *args) 3664 3665 def generator(svc, req): 3666 tries = 0 3667 while True: 3668 t = None if deadline is None else deadline - time.time() 3669 try: 3670 plumbing_response = svc.stub.List( 3671 req, 3672 metadata=svc.parent.get_metadata( 3673 'IdentityAliasesHistory.List', req), 3674 timeout=t) 3675 except Exception as e: 3676 if self.parent.shouldRetry(tries, e, deadline): 3677 tries += 1 3678 time.sleep( 3679 self.parent.exponentialBackoff(tries, deadline)) 3680 continue 3681 raise plumbing.convert_error_to_porcelain(e) from e 3682 tries = 0 3683 for plumbing_item in plumbing_response.history: 3684 yield plumbing.convert_identity_alias_history_to_porcelain( 3685 plumbing_item) 3686 if plumbing_response.meta.next_cursor == '': 3687 break 3688 req.meta.cursor = plumbing_response.meta.next_cursor 3689 3690 return generator(self, req)
IdentityAliasesHistory records all changes to the state of a IdentityAlias.
See strongdm.models.IdentityAliasHistory.
def
list(self, filter, *args, timeout=None)
3651 def list(self, filter, *args, timeout=None): 3652 ''' 3653 List gets a list of IdentityAliasHistory records matching a given set of criteria. 3654 ''' 3655 deadline = None if timeout is None else time.time() + timeout 3656 req = IdentityAliasHistoryListRequest() 3657 req.meta.CopyFrom(ListRequestMetadata()) 3658 if self.parent.page_limit > 0: 3659 req.meta.limit = self.parent.page_limit 3660 if self.parent.snapshot_datetime is not None: 3661 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3662 3663 req.filter = plumbing.quote_filter_args(filter, *args) 3664 3665 def generator(svc, req): 3666 tries = 0 3667 while True: 3668 t = None if deadline is None else deadline - time.time() 3669 try: 3670 plumbing_response = svc.stub.List( 3671 req, 3672 metadata=svc.parent.get_metadata( 3673 'IdentityAliasesHistory.List', req), 3674 timeout=t) 3675 except Exception as e: 3676 if self.parent.shouldRetry(tries, e, deadline): 3677 tries += 1 3678 time.sleep( 3679 self.parent.exponentialBackoff(tries, deadline)) 3680 continue 3681 raise plumbing.convert_error_to_porcelain(e) from e 3682 tries = 0 3683 for plumbing_item in plumbing_response.history: 3684 yield plumbing.convert_identity_alias_history_to_porcelain( 3685 plumbing_item) 3686 if plumbing_response.meta.next_cursor == '': 3687 break 3688 req.meta.cursor = plumbing_response.meta.next_cursor 3689 3690 return generator(self, req)
List gets a list of IdentityAliasHistory records matching a given set of criteria.
class
IdentitySets:
3693class IdentitySets: 3694 ''' 3695 A IdentitySet is a named grouping of Identity Aliases for Accounts. 3696 An Account's relationship to a IdentitySet is defined via IdentityAlias objects. 3697 See `strongdm.models.IdentitySet`. 3698 ''' 3699 def __init__(self, channel, client): 3700 self.parent = client 3701 self.stub = IdentitySetsStub(channel) 3702 3703 def create(self, identity_set, timeout=None): 3704 ''' 3705 Create registers a new IdentitySet. 3706 ''' 3707 deadline = None if timeout is None else time.time() + timeout 3708 req = IdentitySetCreateRequest() 3709 3710 if identity_set is not None: 3711 req.identity_set.CopyFrom( 3712 plumbing.convert_identity_set_to_plumbing(identity_set)) 3713 tries = 0 3714 plumbing_response = None 3715 while True: 3716 t = None if deadline is None else deadline - time.time() 3717 try: 3718 plumbing_response = self.stub.Create( 3719 req, 3720 metadata=self.parent.get_metadata('IdentitySets.Create', 3721 req), 3722 timeout=t) 3723 except Exception as e: 3724 if self.parent.shouldRetry(tries, e, deadline): 3725 tries += 1 3726 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3727 continue 3728 raise plumbing.convert_error_to_porcelain(e) from e 3729 break 3730 3731 resp = models.IdentitySetCreateResponse() 3732 resp.identity_set = plumbing.convert_identity_set_to_porcelain( 3733 plumbing_response.identity_set) 3734 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 3735 plumbing_response.meta) 3736 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3737 plumbing_response.rate_limit) 3738 return resp 3739 3740 def get(self, id, timeout=None): 3741 ''' 3742 Get reads one IdentitySet by ID. 3743 ''' 3744 deadline = None if timeout is None else time.time() + timeout 3745 req = IdentitySetGetRequest() 3746 if self.parent.snapshot_datetime is not None: 3747 req.meta.CopyFrom(GetRequestMetadata()) 3748 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3749 3750 req.id = (id) 3751 tries = 0 3752 plumbing_response = None 3753 while True: 3754 t = None if deadline is None else deadline - time.time() 3755 try: 3756 plumbing_response = self.stub.Get( 3757 req, 3758 metadata=self.parent.get_metadata('IdentitySets.Get', req), 3759 timeout=t) 3760 except Exception as e: 3761 if self.parent.shouldRetry(tries, e, deadline): 3762 tries += 1 3763 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3764 continue 3765 raise plumbing.convert_error_to_porcelain(e) from e 3766 break 3767 3768 resp = models.IdentitySetGetResponse() 3769 resp.identity_set = plumbing.convert_identity_set_to_porcelain( 3770 plumbing_response.identity_set) 3771 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3772 plumbing_response.meta) 3773 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3774 plumbing_response.rate_limit) 3775 return resp 3776 3777 def update(self, identity_set, timeout=None): 3778 ''' 3779 Update replaces all the fields of a IdentitySet by ID. 3780 ''' 3781 deadline = None if timeout is None else time.time() + timeout 3782 req = IdentitySetUpdateRequest() 3783 3784 if identity_set is not None: 3785 req.identity_set.CopyFrom( 3786 plumbing.convert_identity_set_to_plumbing(identity_set)) 3787 tries = 0 3788 plumbing_response = None 3789 while True: 3790 t = None if deadline is None else deadline - time.time() 3791 try: 3792 plumbing_response = self.stub.Update( 3793 req, 3794 metadata=self.parent.get_metadata('IdentitySets.Update', 3795 req), 3796 timeout=t) 3797 except Exception as e: 3798 if self.parent.shouldRetry(tries, e, deadline): 3799 tries += 1 3800 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3801 continue 3802 raise plumbing.convert_error_to_porcelain(e) from e 3803 break 3804 3805 resp = models.IdentitySetUpdateResponse() 3806 resp.identity_set = plumbing.convert_identity_set_to_porcelain( 3807 plumbing_response.identity_set) 3808 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 3809 plumbing_response.meta) 3810 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3811 plumbing_response.rate_limit) 3812 return resp 3813 3814 def delete(self, id, timeout=None): 3815 ''' 3816 Delete removes a IdentitySet by ID. 3817 ''' 3818 deadline = None if timeout is None else time.time() + timeout 3819 req = IdentitySetDeleteRequest() 3820 3821 req.id = (id) 3822 tries = 0 3823 plumbing_response = None 3824 while True: 3825 t = None if deadline is None else deadline - time.time() 3826 try: 3827 plumbing_response = self.stub.Delete( 3828 req, 3829 metadata=self.parent.get_metadata('IdentitySets.Delete', 3830 req), 3831 timeout=t) 3832 except Exception as e: 3833 if self.parent.shouldRetry(tries, e, deadline): 3834 tries += 1 3835 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3836 continue 3837 raise plumbing.convert_error_to_porcelain(e) from e 3838 break 3839 3840 resp = models.IdentitySetDeleteResponse() 3841 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3842 plumbing_response.meta) 3843 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3844 plumbing_response.rate_limit) 3845 return resp 3846 3847 def list(self, filter, *args, timeout=None): 3848 ''' 3849 List gets a list of IdentitySets matching a given set of criteria. 3850 ''' 3851 deadline = None if timeout is None else time.time() + timeout 3852 req = IdentitySetListRequest() 3853 req.meta.CopyFrom(ListRequestMetadata()) 3854 if self.parent.page_limit > 0: 3855 req.meta.limit = self.parent.page_limit 3856 if self.parent.snapshot_datetime is not None: 3857 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3858 3859 req.filter = plumbing.quote_filter_args(filter, *args) 3860 3861 def generator(svc, req): 3862 tries = 0 3863 while True: 3864 t = None if deadline is None else deadline - time.time() 3865 try: 3866 plumbing_response = svc.stub.List( 3867 req, 3868 metadata=svc.parent.get_metadata( 3869 'IdentitySets.List', req), 3870 timeout=t) 3871 except Exception as e: 3872 if self.parent.shouldRetry(tries, e, deadline): 3873 tries += 1 3874 time.sleep( 3875 self.parent.exponentialBackoff(tries, deadline)) 3876 continue 3877 raise plumbing.convert_error_to_porcelain(e) from e 3878 tries = 0 3879 for plumbing_item in plumbing_response.identity_sets: 3880 yield plumbing.convert_identity_set_to_porcelain( 3881 plumbing_item) 3882 if plumbing_response.meta.next_cursor == '': 3883 break 3884 req.meta.cursor = plumbing_response.meta.next_cursor 3885 3886 return generator(self, req)
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)
3703 def create(self, identity_set, timeout=None): 3704 ''' 3705 Create registers a new IdentitySet. 3706 ''' 3707 deadline = None if timeout is None else time.time() + timeout 3708 req = IdentitySetCreateRequest() 3709 3710 if identity_set is not None: 3711 req.identity_set.CopyFrom( 3712 plumbing.convert_identity_set_to_plumbing(identity_set)) 3713 tries = 0 3714 plumbing_response = None 3715 while True: 3716 t = None if deadline is None else deadline - time.time() 3717 try: 3718 plumbing_response = self.stub.Create( 3719 req, 3720 metadata=self.parent.get_metadata('IdentitySets.Create', 3721 req), 3722 timeout=t) 3723 except Exception as e: 3724 if self.parent.shouldRetry(tries, e, deadline): 3725 tries += 1 3726 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3727 continue 3728 raise plumbing.convert_error_to_porcelain(e) from e 3729 break 3730 3731 resp = models.IdentitySetCreateResponse() 3732 resp.identity_set = plumbing.convert_identity_set_to_porcelain( 3733 plumbing_response.identity_set) 3734 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 3735 plumbing_response.meta) 3736 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3737 plumbing_response.rate_limit) 3738 return resp
Create registers a new IdentitySet.
def
get(self, id, timeout=None)
3740 def get(self, id, timeout=None): 3741 ''' 3742 Get reads one IdentitySet by ID. 3743 ''' 3744 deadline = None if timeout is None else time.time() + timeout 3745 req = IdentitySetGetRequest() 3746 if self.parent.snapshot_datetime is not None: 3747 req.meta.CopyFrom(GetRequestMetadata()) 3748 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3749 3750 req.id = (id) 3751 tries = 0 3752 plumbing_response = None 3753 while True: 3754 t = None if deadline is None else deadline - time.time() 3755 try: 3756 plumbing_response = self.stub.Get( 3757 req, 3758 metadata=self.parent.get_metadata('IdentitySets.Get', req), 3759 timeout=t) 3760 except Exception as e: 3761 if self.parent.shouldRetry(tries, e, deadline): 3762 tries += 1 3763 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3764 continue 3765 raise plumbing.convert_error_to_porcelain(e) from e 3766 break 3767 3768 resp = models.IdentitySetGetResponse() 3769 resp.identity_set = plumbing.convert_identity_set_to_porcelain( 3770 plumbing_response.identity_set) 3771 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3772 plumbing_response.meta) 3773 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3774 plumbing_response.rate_limit) 3775 return resp
Get reads one IdentitySet by ID.
def
update(self, identity_set, timeout=None)
3777 def update(self, identity_set, timeout=None): 3778 ''' 3779 Update replaces all the fields of a IdentitySet by ID. 3780 ''' 3781 deadline = None if timeout is None else time.time() + timeout 3782 req = IdentitySetUpdateRequest() 3783 3784 if identity_set is not None: 3785 req.identity_set.CopyFrom( 3786 plumbing.convert_identity_set_to_plumbing(identity_set)) 3787 tries = 0 3788 plumbing_response = None 3789 while True: 3790 t = None if deadline is None else deadline - time.time() 3791 try: 3792 plumbing_response = self.stub.Update( 3793 req, 3794 metadata=self.parent.get_metadata('IdentitySets.Update', 3795 req), 3796 timeout=t) 3797 except Exception as e: 3798 if self.parent.shouldRetry(tries, e, deadline): 3799 tries += 1 3800 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3801 continue 3802 raise plumbing.convert_error_to_porcelain(e) from e 3803 break 3804 3805 resp = models.IdentitySetUpdateResponse() 3806 resp.identity_set = plumbing.convert_identity_set_to_porcelain( 3807 plumbing_response.identity_set) 3808 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 3809 plumbing_response.meta) 3810 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3811 plumbing_response.rate_limit) 3812 return resp
Update replaces all the fields of a IdentitySet by ID.
def
delete(self, id, timeout=None)
3814 def delete(self, id, timeout=None): 3815 ''' 3816 Delete removes a IdentitySet by ID. 3817 ''' 3818 deadline = None if timeout is None else time.time() + timeout 3819 req = IdentitySetDeleteRequest() 3820 3821 req.id = (id) 3822 tries = 0 3823 plumbing_response = None 3824 while True: 3825 t = None if deadline is None else deadline - time.time() 3826 try: 3827 plumbing_response = self.stub.Delete( 3828 req, 3829 metadata=self.parent.get_metadata('IdentitySets.Delete', 3830 req), 3831 timeout=t) 3832 except Exception as e: 3833 if self.parent.shouldRetry(tries, e, deadline): 3834 tries += 1 3835 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3836 continue 3837 raise plumbing.convert_error_to_porcelain(e) from e 3838 break 3839 3840 resp = models.IdentitySetDeleteResponse() 3841 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3842 plumbing_response.meta) 3843 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3844 plumbing_response.rate_limit) 3845 return resp
Delete removes a IdentitySet by ID.
def
list(self, filter, *args, timeout=None)
3847 def list(self, filter, *args, timeout=None): 3848 ''' 3849 List gets a list of IdentitySets matching a given set of criteria. 3850 ''' 3851 deadline = None if timeout is None else time.time() + timeout 3852 req = IdentitySetListRequest() 3853 req.meta.CopyFrom(ListRequestMetadata()) 3854 if self.parent.page_limit > 0: 3855 req.meta.limit = self.parent.page_limit 3856 if self.parent.snapshot_datetime is not None: 3857 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3858 3859 req.filter = plumbing.quote_filter_args(filter, *args) 3860 3861 def generator(svc, req): 3862 tries = 0 3863 while True: 3864 t = None if deadline is None else deadline - time.time() 3865 try: 3866 plumbing_response = svc.stub.List( 3867 req, 3868 metadata=svc.parent.get_metadata( 3869 'IdentitySets.List', req), 3870 timeout=t) 3871 except Exception as e: 3872 if self.parent.shouldRetry(tries, e, deadline): 3873 tries += 1 3874 time.sleep( 3875 self.parent.exponentialBackoff(tries, deadline)) 3876 continue 3877 raise plumbing.convert_error_to_porcelain(e) from e 3878 tries = 0 3879 for plumbing_item in plumbing_response.identity_sets: 3880 yield plumbing.convert_identity_set_to_porcelain( 3881 plumbing_item) 3882 if plumbing_response.meta.next_cursor == '': 3883 break 3884 req.meta.cursor = plumbing_response.meta.next_cursor 3885 3886 return generator(self, req)
List gets a list of IdentitySets matching a given set of criteria.
class
SnapshotIdentitySets:
3889class SnapshotIdentitySets: 3890 ''' 3891 SnapshotIdentitySets exposes the read only methods of the IdentitySets 3892 service for historical queries. 3893 ''' 3894 def __init__(self, identity_sets): 3895 self.identity_sets = identity_sets 3896 3897 def get(self, id, timeout=None): 3898 ''' 3899 Get reads one IdentitySet by ID. 3900 ''' 3901 return self.identity_sets.get(id, timeout=timeout) 3902 3903 def list(self, filter, *args, timeout=None): 3904 ''' 3905 List gets a list of IdentitySets matching a given set of criteria. 3906 ''' 3907 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)
3897 def get(self, id, timeout=None): 3898 ''' 3899 Get reads one IdentitySet by ID. 3900 ''' 3901 return self.identity_sets.get(id, timeout=timeout)
Get reads one IdentitySet by ID.
def
list(self, filter, *args, timeout=None)
3903 def list(self, filter, *args, timeout=None): 3904 ''' 3905 List gets a list of IdentitySets matching a given set of criteria. 3906 ''' 3907 return self.identity_sets.list(filter, *args, timeout=timeout)
List gets a list of IdentitySets matching a given set of criteria.
class
IdentitySetsHistory:
3910class IdentitySetsHistory: 3911 ''' 3912 IdentitySetsHistory records all changes to the state of a IdentitySet. 3913 See `strongdm.models.IdentitySetHistory`. 3914 ''' 3915 def __init__(self, channel, client): 3916 self.parent = client 3917 self.stub = IdentitySetsHistoryStub(channel) 3918 3919 def list(self, filter, *args, timeout=None): 3920 ''' 3921 List gets a list of IdentitySetHistory records matching a given set of criteria. 3922 ''' 3923 deadline = None if timeout is None else time.time() + timeout 3924 req = IdentitySetHistoryListRequest() 3925 req.meta.CopyFrom(ListRequestMetadata()) 3926 if self.parent.page_limit > 0: 3927 req.meta.limit = self.parent.page_limit 3928 if self.parent.snapshot_datetime is not None: 3929 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3930 3931 req.filter = plumbing.quote_filter_args(filter, *args) 3932 3933 def generator(svc, req): 3934 tries = 0 3935 while True: 3936 t = None if deadline is None else deadline - time.time() 3937 try: 3938 plumbing_response = svc.stub.List( 3939 req, 3940 metadata=svc.parent.get_metadata( 3941 'IdentitySetsHistory.List', req), 3942 timeout=t) 3943 except Exception as e: 3944 if self.parent.shouldRetry(tries, e, deadline): 3945 tries += 1 3946 time.sleep( 3947 self.parent.exponentialBackoff(tries, deadline)) 3948 continue 3949 raise plumbing.convert_error_to_porcelain(e) from e 3950 tries = 0 3951 for plumbing_item in plumbing_response.history: 3952 yield plumbing.convert_identity_set_history_to_porcelain( 3953 plumbing_item) 3954 if plumbing_response.meta.next_cursor == '': 3955 break 3956 req.meta.cursor = plumbing_response.meta.next_cursor 3957 3958 return generator(self, req)
IdentitySetsHistory records all changes to the state of a IdentitySet.
See strongdm.models.IdentitySetHistory.
def
list(self, filter, *args, timeout=None)
3919 def list(self, filter, *args, timeout=None): 3920 ''' 3921 List gets a list of IdentitySetHistory records matching a given set of criteria. 3922 ''' 3923 deadline = None if timeout is None else time.time() + timeout 3924 req = IdentitySetHistoryListRequest() 3925 req.meta.CopyFrom(ListRequestMetadata()) 3926 if self.parent.page_limit > 0: 3927 req.meta.limit = self.parent.page_limit 3928 if self.parent.snapshot_datetime is not None: 3929 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3930 3931 req.filter = plumbing.quote_filter_args(filter, *args) 3932 3933 def generator(svc, req): 3934 tries = 0 3935 while True: 3936 t = None if deadline is None else deadline - time.time() 3937 try: 3938 plumbing_response = svc.stub.List( 3939 req, 3940 metadata=svc.parent.get_metadata( 3941 'IdentitySetsHistory.List', req), 3942 timeout=t) 3943 except Exception as e: 3944 if self.parent.shouldRetry(tries, e, deadline): 3945 tries += 1 3946 time.sleep( 3947 self.parent.exponentialBackoff(tries, deadline)) 3948 continue 3949 raise plumbing.convert_error_to_porcelain(e) from e 3950 tries = 0 3951 for plumbing_item in plumbing_response.history: 3952 yield plumbing.convert_identity_set_history_to_porcelain( 3953 plumbing_item) 3954 if plumbing_response.meta.next_cursor == '': 3955 break 3956 req.meta.cursor = plumbing_response.meta.next_cursor 3957 3958 return generator(self, req)
List gets a list of IdentitySetHistory records matching a given set of criteria.
class
ManagedSecrets:
3961class ManagedSecrets: 3962 ''' 3963 ManagedSecret is a private vertical for creating, reading, updating, 3964 deleting, listing and rotating the managed secrets in the secrets engines as 3965 an authenticated user. 3966 See `strongdm.models.ManagedSecret`. 3967 ''' 3968 def __init__(self, channel, client): 3969 self.parent = client 3970 self.stub = ManagedSecretsStub(channel) 3971 3972 def list(self, filter, *args, timeout=None): 3973 ''' 3974 List returns Managed Secrets from a Secret Engine. 3975 ''' 3976 deadline = None if timeout is None else time.time() + timeout 3977 req = ManagedSecretListRequest() 3978 req.meta.CopyFrom(ListRequestMetadata()) 3979 if self.parent.page_limit > 0: 3980 req.meta.limit = self.parent.page_limit 3981 if self.parent.snapshot_datetime is not None: 3982 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3983 3984 req.filter = plumbing.quote_filter_args(filter, *args) 3985 3986 def generator(svc, req): 3987 tries = 0 3988 while True: 3989 t = None if deadline is None else deadline - time.time() 3990 try: 3991 plumbing_response = svc.stub.List( 3992 req, 3993 metadata=svc.parent.get_metadata( 3994 'ManagedSecrets.List', req), 3995 timeout=t) 3996 except Exception as e: 3997 if self.parent.shouldRetry(tries, e, deadline): 3998 tries += 1 3999 time.sleep( 4000 self.parent.exponentialBackoff(tries, deadline)) 4001 continue 4002 raise plumbing.convert_error_to_porcelain(e) from e 4003 tries = 0 4004 for plumbing_item in plumbing_response.managed_secrets: 4005 yield plumbing.convert_managed_secret_to_porcelain( 4006 plumbing_item) 4007 if plumbing_response.meta.next_cursor == '': 4008 break 4009 req.meta.cursor = plumbing_response.meta.next_cursor 4010 4011 return generator(self, req) 4012 4013 def list_by_actor(self, filter, *args, timeout=None): 4014 ''' 4015 List returns Managed Secrets for an Actor from a Secret Engine. 4016 ''' 4017 deadline = None if timeout is None else time.time() + timeout 4018 req = ManagedSecretListRequest() 4019 req.meta.CopyFrom(ListRequestMetadata()) 4020 if self.parent.page_limit > 0: 4021 req.meta.limit = self.parent.page_limit 4022 if self.parent.snapshot_datetime is not None: 4023 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4024 4025 req.filter = plumbing.quote_filter_args(filter, *args) 4026 4027 def generator(svc, req): 4028 tries = 0 4029 while True: 4030 t = None if deadline is None else deadline - time.time() 4031 try: 4032 plumbing_response = svc.stub.ListByActor( 4033 req, 4034 metadata=svc.parent.get_metadata( 4035 'ManagedSecrets.ListByActor', req), 4036 timeout=t) 4037 except Exception as e: 4038 if self.parent.shouldRetry(tries, e, deadline): 4039 tries += 1 4040 time.sleep( 4041 self.parent.exponentialBackoff(tries, deadline)) 4042 continue 4043 raise plumbing.convert_error_to_porcelain(e) from e 4044 tries = 0 4045 for plumbing_item in plumbing_response.managed_secrets: 4046 yield plumbing.convert_managed_secret_to_porcelain( 4047 plumbing_item) 4048 if plumbing_response.meta.next_cursor == '': 4049 break 4050 req.meta.cursor = plumbing_response.meta.next_cursor 4051 4052 return generator(self, req) 4053 4054 def create(self, managed_secret, timeout=None): 4055 ''' 4056 Create creates a Managed Secret 4057 ''' 4058 deadline = None if timeout is None else time.time() + timeout 4059 req = ManagedSecretCreateRequest() 4060 4061 if managed_secret is not None: 4062 req.managed_secret.CopyFrom( 4063 plumbing.convert_managed_secret_to_plumbing(managed_secret)) 4064 tries = 0 4065 plumbing_response = None 4066 while True: 4067 t = None if deadline is None else deadline - time.time() 4068 try: 4069 plumbing_response = self.stub.Create( 4070 req, 4071 metadata=self.parent.get_metadata('ManagedSecrets.Create', 4072 req), 4073 timeout=t) 4074 except Exception as e: 4075 if self.parent.shouldRetry(tries, e, deadline): 4076 tries += 1 4077 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4078 continue 4079 raise plumbing.convert_error_to_porcelain(e) from e 4080 break 4081 4082 resp = models.ManagedSecretCreateResponse() 4083 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 4084 plumbing_response.managed_secret) 4085 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4086 plumbing_response.meta) 4087 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4088 plumbing_response.rate_limit) 4089 return resp 4090 4091 def update(self, managed_secret, timeout=None): 4092 ''' 4093 Update updates a Managed Secret 4094 ''' 4095 deadline = None if timeout is None else time.time() + timeout 4096 req = ManagedSecretUpdateRequest() 4097 4098 if managed_secret is not None: 4099 req.managed_secret.CopyFrom( 4100 plumbing.convert_managed_secret_to_plumbing(managed_secret)) 4101 tries = 0 4102 plumbing_response = None 4103 while True: 4104 t = None if deadline is None else deadline - time.time() 4105 try: 4106 plumbing_response = self.stub.Update( 4107 req, 4108 metadata=self.parent.get_metadata('ManagedSecrets.Update', 4109 req), 4110 timeout=t) 4111 except Exception as e: 4112 if self.parent.shouldRetry(tries, e, deadline): 4113 tries += 1 4114 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4115 continue 4116 raise plumbing.convert_error_to_porcelain(e) from e 4117 break 4118 4119 resp = models.ManagedSecretUpdateResponse() 4120 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 4121 plumbing_response.managed_secret) 4122 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 4123 plumbing_response.meta) 4124 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4125 plumbing_response.rate_limit) 4126 return resp 4127 4128 def rotate(self, id, timeout=None): 4129 ''' 4130 Rotate forces rotation of Managed Secret 4131 ''' 4132 deadline = None if timeout is None else time.time() + timeout 4133 req = ManagedSecretRotateRequest() 4134 4135 req.id = (id) 4136 tries = 0 4137 plumbing_response = None 4138 while True: 4139 t = None if deadline is None else deadline - time.time() 4140 try: 4141 plumbing_response = self.stub.Rotate( 4142 req, 4143 metadata=self.parent.get_metadata('ManagedSecrets.Rotate', 4144 req), 4145 timeout=t) 4146 except Exception as e: 4147 if self.parent.shouldRetry(tries, e, deadline): 4148 tries += 1 4149 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4150 continue 4151 raise plumbing.convert_error_to_porcelain(e) from e 4152 break 4153 4154 resp = models.ManagedSecretRotateResponse() 4155 resp.meta = plumbing.convert_generic_response_metadata_to_porcelain( 4156 plumbing_response.meta) 4157 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4158 plumbing_response.rate_limit) 4159 return resp 4160 4161 def delete(self, id, timeout=None): 4162 ''' 4163 Delete deletes a Managed Secret 4164 ''' 4165 deadline = None if timeout is None else time.time() + timeout 4166 req = ManagedSecretDeleteRequest() 4167 4168 req.id = (id) 4169 tries = 0 4170 plumbing_response = None 4171 while True: 4172 t = None if deadline is None else deadline - time.time() 4173 try: 4174 plumbing_response = self.stub.Delete( 4175 req, 4176 metadata=self.parent.get_metadata('ManagedSecrets.Delete', 4177 req), 4178 timeout=t) 4179 except Exception as e: 4180 if self.parent.shouldRetry(tries, e, deadline): 4181 tries += 1 4182 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4183 continue 4184 raise plumbing.convert_error_to_porcelain(e) from e 4185 break 4186 4187 resp = models.ManagedSecretDeleteResponse() 4188 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4189 plumbing_response.rate_limit) 4190 return resp 4191 4192 def force_delete(self, id, timeout=None): 4193 ''' 4194 ForceDelete deletes a Managed Secret regardless of errors on external system 4195 ''' 4196 deadline = None if timeout is None else time.time() + timeout 4197 req = ManagedSecretDeleteRequest() 4198 4199 req.id = (id) 4200 tries = 0 4201 plumbing_response = None 4202 while True: 4203 t = None if deadline is None else deadline - time.time() 4204 try: 4205 plumbing_response = self.stub.ForceDelete( 4206 req, 4207 metadata=self.parent.get_metadata( 4208 'ManagedSecrets.ForceDelete', req), 4209 timeout=t) 4210 except Exception as e: 4211 if self.parent.shouldRetry(tries, e, deadline): 4212 tries += 1 4213 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4214 continue 4215 raise plumbing.convert_error_to_porcelain(e) from e 4216 break 4217 4218 resp = models.ManagedSecretDeleteResponse() 4219 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4220 plumbing_response.rate_limit) 4221 return resp 4222 4223 def get(self, id, timeout=None): 4224 ''' 4225 Get gets details of a Managed Secret without sensitive data 4226 ''' 4227 deadline = None if timeout is None else time.time() + timeout 4228 req = ManagedSecretGetRequest() 4229 if self.parent.snapshot_datetime is not None: 4230 req.meta.CopyFrom(GetRequestMetadata()) 4231 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4232 4233 req.id = (id) 4234 tries = 0 4235 plumbing_response = None 4236 while True: 4237 t = None if deadline is None else deadline - time.time() 4238 try: 4239 plumbing_response = self.stub.Get( 4240 req, 4241 metadata=self.parent.get_metadata('ManagedSecrets.Get', 4242 req), 4243 timeout=t) 4244 except Exception as e: 4245 if self.parent.shouldRetry(tries, e, deadline): 4246 tries += 1 4247 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4248 continue 4249 raise plumbing.convert_error_to_porcelain(e) from e 4250 break 4251 4252 resp = models.ManagedSecretGetResponse() 4253 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 4254 plumbing_response.managed_secret) 4255 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4256 plumbing_response.meta) 4257 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4258 plumbing_response.rate_limit) 4259 return resp 4260 4261 def retrieve(self, id, timeout=None): 4262 ''' 4263 Retrieve returns Managed Secret with sensitive data 4264 ''' 4265 deadline = None if timeout is None else time.time() + timeout 4266 req = ManagedSecretRetrieveRequest() 4267 4268 req.id = (id) 4269 tries = 0 4270 plumbing_response = None 4271 while True: 4272 t = None if deadline is None else deadline - time.time() 4273 try: 4274 plumbing_response = self.stub.Retrieve( 4275 req, 4276 metadata=self.parent.get_metadata( 4277 'ManagedSecrets.Retrieve', req), 4278 timeout=t) 4279 except Exception as e: 4280 if self.parent.shouldRetry(tries, e, deadline): 4281 tries += 1 4282 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4283 continue 4284 raise plumbing.convert_error_to_porcelain(e) from e 4285 break 4286 4287 resp = models.ManagedSecretRetrieveResponse() 4288 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 4289 plumbing_response.managed_secret) 4290 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4291 plumbing_response.meta) 4292 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4293 plumbing_response.rate_limit) 4294 return resp 4295 4296 def validate(self, id, timeout=None): 4297 ''' 4298 Validate returns the result of testing the stored credential against the 4299 secret engine. 4300 ''' 4301 deadline = None if timeout is None else time.time() + timeout 4302 req = ManagedSecretValidateRequest() 4303 4304 req.id = (id) 4305 tries = 0 4306 plumbing_response = None 4307 while True: 4308 t = None if deadline is None else deadline - time.time() 4309 try: 4310 plumbing_response = self.stub.Validate( 4311 req, 4312 metadata=self.parent.get_metadata( 4313 'ManagedSecrets.Validate', req), 4314 timeout=t) 4315 except Exception as e: 4316 if self.parent.shouldRetry(tries, e, deadline): 4317 tries += 1 4318 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4319 continue 4320 raise plumbing.convert_error_to_porcelain(e) from e 4321 break 4322 4323 resp = models.ManagedSecretValidateResponse() 4324 resp.invalid_info = (plumbing_response.invalid_info) 4325 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4326 plumbing_response.meta) 4327 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4328 plumbing_response.rate_limit) 4329 resp.valid = (plumbing_response.valid) 4330 return resp 4331 4332 def logs(self, filter, *args, timeout=None): 4333 ''' 4334 Logs returns the audit records for the managed secret. This may be replaced 4335 in the future. 4336 ''' 4337 deadline = None if timeout is None else time.time() + timeout 4338 req = ManagedSecretLogsRequest() 4339 req.meta.CopyFrom(ListRequestMetadata()) 4340 if self.parent.page_limit > 0: 4341 req.meta.limit = self.parent.page_limit 4342 if self.parent.snapshot_datetime is not None: 4343 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4344 4345 req.filter = plumbing.quote_filter_args(filter, *args) 4346 4347 def generator(svc, req): 4348 tries = 0 4349 while True: 4350 t = None if deadline is None else deadline - time.time() 4351 try: 4352 plumbing_response = svc.stub.Logs( 4353 req, 4354 metadata=svc.parent.get_metadata( 4355 'ManagedSecrets.Logs', req), 4356 timeout=t) 4357 except Exception as e: 4358 if self.parent.shouldRetry(tries, e, deadline): 4359 tries += 1 4360 time.sleep( 4361 self.parent.exponentialBackoff(tries, deadline)) 4362 continue 4363 raise plumbing.convert_error_to_porcelain(e) from e 4364 tries = 0 4365 for plumbing_item in plumbing_response.managed_secret_logs: 4366 yield plumbing.convert_managed_secret_log_to_porcelain( 4367 plumbing_item) 4368 if plumbing_response.meta.next_cursor == '': 4369 break 4370 req.meta.cursor = plumbing_response.meta.next_cursor 4371 4372 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)
3972 def list(self, filter, *args, timeout=None): 3973 ''' 3974 List returns Managed Secrets from a Secret Engine. 3975 ''' 3976 deadline = None if timeout is None else time.time() + timeout 3977 req = ManagedSecretListRequest() 3978 req.meta.CopyFrom(ListRequestMetadata()) 3979 if self.parent.page_limit > 0: 3980 req.meta.limit = self.parent.page_limit 3981 if self.parent.snapshot_datetime is not None: 3982 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3983 3984 req.filter = plumbing.quote_filter_args(filter, *args) 3985 3986 def generator(svc, req): 3987 tries = 0 3988 while True: 3989 t = None if deadline is None else deadline - time.time() 3990 try: 3991 plumbing_response = svc.stub.List( 3992 req, 3993 metadata=svc.parent.get_metadata( 3994 'ManagedSecrets.List', req), 3995 timeout=t) 3996 except Exception as e: 3997 if self.parent.shouldRetry(tries, e, deadline): 3998 tries += 1 3999 time.sleep( 4000 self.parent.exponentialBackoff(tries, deadline)) 4001 continue 4002 raise plumbing.convert_error_to_porcelain(e) from e 4003 tries = 0 4004 for plumbing_item in plumbing_response.managed_secrets: 4005 yield plumbing.convert_managed_secret_to_porcelain( 4006 plumbing_item) 4007 if plumbing_response.meta.next_cursor == '': 4008 break 4009 req.meta.cursor = plumbing_response.meta.next_cursor 4010 4011 return generator(self, req)
List returns Managed Secrets from a Secret Engine.
def
list_by_actor(self, filter, *args, timeout=None)
4013 def list_by_actor(self, filter, *args, timeout=None): 4014 ''' 4015 List returns Managed Secrets for an Actor from a Secret Engine. 4016 ''' 4017 deadline = None if timeout is None else time.time() + timeout 4018 req = ManagedSecretListRequest() 4019 req.meta.CopyFrom(ListRequestMetadata()) 4020 if self.parent.page_limit > 0: 4021 req.meta.limit = self.parent.page_limit 4022 if self.parent.snapshot_datetime is not None: 4023 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4024 4025 req.filter = plumbing.quote_filter_args(filter, *args) 4026 4027 def generator(svc, req): 4028 tries = 0 4029 while True: 4030 t = None if deadline is None else deadline - time.time() 4031 try: 4032 plumbing_response = svc.stub.ListByActor( 4033 req, 4034 metadata=svc.parent.get_metadata( 4035 'ManagedSecrets.ListByActor', req), 4036 timeout=t) 4037 except Exception as e: 4038 if self.parent.shouldRetry(tries, e, deadline): 4039 tries += 1 4040 time.sleep( 4041 self.parent.exponentialBackoff(tries, deadline)) 4042 continue 4043 raise plumbing.convert_error_to_porcelain(e) from e 4044 tries = 0 4045 for plumbing_item in plumbing_response.managed_secrets: 4046 yield plumbing.convert_managed_secret_to_porcelain( 4047 plumbing_item) 4048 if plumbing_response.meta.next_cursor == '': 4049 break 4050 req.meta.cursor = plumbing_response.meta.next_cursor 4051 4052 return generator(self, req)
List returns Managed Secrets for an Actor from a Secret Engine.
def
create(self, managed_secret, timeout=None)
4054 def create(self, managed_secret, timeout=None): 4055 ''' 4056 Create creates a Managed Secret 4057 ''' 4058 deadline = None if timeout is None else time.time() + timeout 4059 req = ManagedSecretCreateRequest() 4060 4061 if managed_secret is not None: 4062 req.managed_secret.CopyFrom( 4063 plumbing.convert_managed_secret_to_plumbing(managed_secret)) 4064 tries = 0 4065 plumbing_response = None 4066 while True: 4067 t = None if deadline is None else deadline - time.time() 4068 try: 4069 plumbing_response = self.stub.Create( 4070 req, 4071 metadata=self.parent.get_metadata('ManagedSecrets.Create', 4072 req), 4073 timeout=t) 4074 except Exception as e: 4075 if self.parent.shouldRetry(tries, e, deadline): 4076 tries += 1 4077 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4078 continue 4079 raise plumbing.convert_error_to_porcelain(e) from e 4080 break 4081 4082 resp = models.ManagedSecretCreateResponse() 4083 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 4084 plumbing_response.managed_secret) 4085 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4086 plumbing_response.meta) 4087 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4088 plumbing_response.rate_limit) 4089 return resp
Create creates a Managed Secret
def
update(self, managed_secret, timeout=None)
4091 def update(self, managed_secret, timeout=None): 4092 ''' 4093 Update updates a Managed Secret 4094 ''' 4095 deadline = None if timeout is None else time.time() + timeout 4096 req = ManagedSecretUpdateRequest() 4097 4098 if managed_secret is not None: 4099 req.managed_secret.CopyFrom( 4100 plumbing.convert_managed_secret_to_plumbing(managed_secret)) 4101 tries = 0 4102 plumbing_response = None 4103 while True: 4104 t = None if deadline is None else deadline - time.time() 4105 try: 4106 plumbing_response = self.stub.Update( 4107 req, 4108 metadata=self.parent.get_metadata('ManagedSecrets.Update', 4109 req), 4110 timeout=t) 4111 except Exception as e: 4112 if self.parent.shouldRetry(tries, e, deadline): 4113 tries += 1 4114 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4115 continue 4116 raise plumbing.convert_error_to_porcelain(e) from e 4117 break 4118 4119 resp = models.ManagedSecretUpdateResponse() 4120 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 4121 plumbing_response.managed_secret) 4122 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 4123 plumbing_response.meta) 4124 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4125 plumbing_response.rate_limit) 4126 return resp
Update updates a Managed Secret
def
rotate(self, id, timeout=None)
4128 def rotate(self, id, timeout=None): 4129 ''' 4130 Rotate forces rotation of Managed Secret 4131 ''' 4132 deadline = None if timeout is None else time.time() + timeout 4133 req = ManagedSecretRotateRequest() 4134 4135 req.id = (id) 4136 tries = 0 4137 plumbing_response = None 4138 while True: 4139 t = None if deadline is None else deadline - time.time() 4140 try: 4141 plumbing_response = self.stub.Rotate( 4142 req, 4143 metadata=self.parent.get_metadata('ManagedSecrets.Rotate', 4144 req), 4145 timeout=t) 4146 except Exception as e: 4147 if self.parent.shouldRetry(tries, e, deadline): 4148 tries += 1 4149 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4150 continue 4151 raise plumbing.convert_error_to_porcelain(e) from e 4152 break 4153 4154 resp = models.ManagedSecretRotateResponse() 4155 resp.meta = plumbing.convert_generic_response_metadata_to_porcelain( 4156 plumbing_response.meta) 4157 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4158 plumbing_response.rate_limit) 4159 return resp
Rotate forces rotation of Managed Secret
def
delete(self, id, timeout=None)
4161 def delete(self, id, timeout=None): 4162 ''' 4163 Delete deletes a Managed Secret 4164 ''' 4165 deadline = None if timeout is None else time.time() + timeout 4166 req = ManagedSecretDeleteRequest() 4167 4168 req.id = (id) 4169 tries = 0 4170 plumbing_response = None 4171 while True: 4172 t = None if deadline is None else deadline - time.time() 4173 try: 4174 plumbing_response = self.stub.Delete( 4175 req, 4176 metadata=self.parent.get_metadata('ManagedSecrets.Delete', 4177 req), 4178 timeout=t) 4179 except Exception as e: 4180 if self.parent.shouldRetry(tries, e, deadline): 4181 tries += 1 4182 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4183 continue 4184 raise plumbing.convert_error_to_porcelain(e) from e 4185 break 4186 4187 resp = models.ManagedSecretDeleteResponse() 4188 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4189 plumbing_response.rate_limit) 4190 return resp
Delete deletes a Managed Secret
def
force_delete(self, id, timeout=None)
4192 def force_delete(self, id, timeout=None): 4193 ''' 4194 ForceDelete deletes a Managed Secret regardless of errors on external system 4195 ''' 4196 deadline = None if timeout is None else time.time() + timeout 4197 req = ManagedSecretDeleteRequest() 4198 4199 req.id = (id) 4200 tries = 0 4201 plumbing_response = None 4202 while True: 4203 t = None if deadline is None else deadline - time.time() 4204 try: 4205 plumbing_response = self.stub.ForceDelete( 4206 req, 4207 metadata=self.parent.get_metadata( 4208 'ManagedSecrets.ForceDelete', req), 4209 timeout=t) 4210 except Exception as e: 4211 if self.parent.shouldRetry(tries, e, deadline): 4212 tries += 1 4213 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4214 continue 4215 raise plumbing.convert_error_to_porcelain(e) from e 4216 break 4217 4218 resp = models.ManagedSecretDeleteResponse() 4219 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4220 plumbing_response.rate_limit) 4221 return resp
ForceDelete deletes a Managed Secret regardless of errors on external system
def
get(self, id, timeout=None)
4223 def get(self, id, timeout=None): 4224 ''' 4225 Get gets details of a Managed Secret without sensitive data 4226 ''' 4227 deadline = None if timeout is None else time.time() + timeout 4228 req = ManagedSecretGetRequest() 4229 if self.parent.snapshot_datetime is not None: 4230 req.meta.CopyFrom(GetRequestMetadata()) 4231 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4232 4233 req.id = (id) 4234 tries = 0 4235 plumbing_response = None 4236 while True: 4237 t = None if deadline is None else deadline - time.time() 4238 try: 4239 plumbing_response = self.stub.Get( 4240 req, 4241 metadata=self.parent.get_metadata('ManagedSecrets.Get', 4242 req), 4243 timeout=t) 4244 except Exception as e: 4245 if self.parent.shouldRetry(tries, e, deadline): 4246 tries += 1 4247 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4248 continue 4249 raise plumbing.convert_error_to_porcelain(e) from e 4250 break 4251 4252 resp = models.ManagedSecretGetResponse() 4253 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 4254 plumbing_response.managed_secret) 4255 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4256 plumbing_response.meta) 4257 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4258 plumbing_response.rate_limit) 4259 return resp
Get gets details of a Managed Secret without sensitive data
def
retrieve(self, id, timeout=None)
4261 def retrieve(self, id, timeout=None): 4262 ''' 4263 Retrieve returns Managed Secret with sensitive data 4264 ''' 4265 deadline = None if timeout is None else time.time() + timeout 4266 req = ManagedSecretRetrieveRequest() 4267 4268 req.id = (id) 4269 tries = 0 4270 plumbing_response = None 4271 while True: 4272 t = None if deadline is None else deadline - time.time() 4273 try: 4274 plumbing_response = self.stub.Retrieve( 4275 req, 4276 metadata=self.parent.get_metadata( 4277 'ManagedSecrets.Retrieve', req), 4278 timeout=t) 4279 except Exception as e: 4280 if self.parent.shouldRetry(tries, e, deadline): 4281 tries += 1 4282 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4283 continue 4284 raise plumbing.convert_error_to_porcelain(e) from e 4285 break 4286 4287 resp = models.ManagedSecretRetrieveResponse() 4288 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 4289 plumbing_response.managed_secret) 4290 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4291 plumbing_response.meta) 4292 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4293 plumbing_response.rate_limit) 4294 return resp
Retrieve returns Managed Secret with sensitive data
def
validate(self, id, timeout=None)
4296 def validate(self, id, timeout=None): 4297 ''' 4298 Validate returns the result of testing the stored credential against the 4299 secret engine. 4300 ''' 4301 deadline = None if timeout is None else time.time() + timeout 4302 req = ManagedSecretValidateRequest() 4303 4304 req.id = (id) 4305 tries = 0 4306 plumbing_response = None 4307 while True: 4308 t = None if deadline is None else deadline - time.time() 4309 try: 4310 plumbing_response = self.stub.Validate( 4311 req, 4312 metadata=self.parent.get_metadata( 4313 'ManagedSecrets.Validate', req), 4314 timeout=t) 4315 except Exception as e: 4316 if self.parent.shouldRetry(tries, e, deadline): 4317 tries += 1 4318 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4319 continue 4320 raise plumbing.convert_error_to_porcelain(e) from e 4321 break 4322 4323 resp = models.ManagedSecretValidateResponse() 4324 resp.invalid_info = (plumbing_response.invalid_info) 4325 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4326 plumbing_response.meta) 4327 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4328 plumbing_response.rate_limit) 4329 resp.valid = (plumbing_response.valid) 4330 return resp
Validate returns the result of testing the stored credential against the secret engine.
def
logs(self, filter, *args, timeout=None)
4332 def logs(self, filter, *args, timeout=None): 4333 ''' 4334 Logs returns the audit records for the managed secret. This may be replaced 4335 in the future. 4336 ''' 4337 deadline = None if timeout is None else time.time() + timeout 4338 req = ManagedSecretLogsRequest() 4339 req.meta.CopyFrom(ListRequestMetadata()) 4340 if self.parent.page_limit > 0: 4341 req.meta.limit = self.parent.page_limit 4342 if self.parent.snapshot_datetime is not None: 4343 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4344 4345 req.filter = plumbing.quote_filter_args(filter, *args) 4346 4347 def generator(svc, req): 4348 tries = 0 4349 while True: 4350 t = None if deadline is None else deadline - time.time() 4351 try: 4352 plumbing_response = svc.stub.Logs( 4353 req, 4354 metadata=svc.parent.get_metadata( 4355 'ManagedSecrets.Logs', req), 4356 timeout=t) 4357 except Exception as e: 4358 if self.parent.shouldRetry(tries, e, deadline): 4359 tries += 1 4360 time.sleep( 4361 self.parent.exponentialBackoff(tries, deadline)) 4362 continue 4363 raise plumbing.convert_error_to_porcelain(e) from e 4364 tries = 0 4365 for plumbing_item in plumbing_response.managed_secret_logs: 4366 yield plumbing.convert_managed_secret_log_to_porcelain( 4367 plumbing_item) 4368 if plumbing_response.meta.next_cursor == '': 4369 break 4370 req.meta.cursor = plumbing_response.meta.next_cursor 4371 4372 return generator(self, req)
Logs returns the audit records for the managed secret. This may be replaced in the future.
class
Nodes:
4375class Nodes: 4376 ''' 4377 Nodes make up the StrongDM network, and allow your users to connect securely to your resources. 4378 There are three types of nodes: 4379 1. **Relay:** creates connectivity to your datasources, while maintaining the egress-only nature of your firewall 4380 2. **Gateway:** a relay that also listens for connections from StrongDM clients 4381 3. **Proxy Cluster:** a cluster of workers that together mediate access from clients to resources 4382 See: 4383 `strongdm.models.Gateway` 4384 `strongdm.models.ProxyCluster` 4385 `strongdm.models.Relay` 4386 ''' 4387 def __init__(self, channel, client): 4388 self.parent = client 4389 self.stub = NodesStub(channel) 4390 4391 def create(self, node, timeout=None): 4392 ''' 4393 Create registers a new Node. 4394 ''' 4395 deadline = None if timeout is None else time.time() + timeout 4396 req = NodeCreateRequest() 4397 4398 if node is not None: 4399 req.node.CopyFrom(plumbing.convert_node_to_plumbing(node)) 4400 tries = 0 4401 plumbing_response = None 4402 while True: 4403 t = None if deadline is None else deadline - time.time() 4404 try: 4405 plumbing_response = self.stub.Create( 4406 req, 4407 metadata=self.parent.get_metadata('Nodes.Create', req), 4408 timeout=t) 4409 except Exception as e: 4410 if self.parent.shouldRetry(tries, e, deadline): 4411 tries += 1 4412 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4413 continue 4414 raise plumbing.convert_error_to_porcelain(e) from e 4415 break 4416 4417 resp = models.NodeCreateResponse() 4418 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4419 plumbing_response.meta) 4420 resp.node = plumbing.convert_node_to_porcelain(plumbing_response.node) 4421 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4422 plumbing_response.rate_limit) 4423 resp.token = (plumbing_response.token) 4424 return resp 4425 4426 def get(self, id, timeout=None): 4427 ''' 4428 Get reads one Node by ID. 4429 ''' 4430 deadline = None if timeout is None else time.time() + timeout 4431 req = NodeGetRequest() 4432 if self.parent.snapshot_datetime is not None: 4433 req.meta.CopyFrom(GetRequestMetadata()) 4434 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4435 4436 req.id = (id) 4437 tries = 0 4438 plumbing_response = None 4439 while True: 4440 t = None if deadline is None else deadline - time.time() 4441 try: 4442 plumbing_response = self.stub.Get( 4443 req, 4444 metadata=self.parent.get_metadata('Nodes.Get', req), 4445 timeout=t) 4446 except Exception as e: 4447 if self.parent.shouldRetry(tries, e, deadline): 4448 tries += 1 4449 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4450 continue 4451 raise plumbing.convert_error_to_porcelain(e) from e 4452 break 4453 4454 resp = models.NodeGetResponse() 4455 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4456 plumbing_response.meta) 4457 resp.node = plumbing.convert_node_to_porcelain(plumbing_response.node) 4458 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4459 plumbing_response.rate_limit) 4460 return resp 4461 4462 def update(self, node, timeout=None): 4463 ''' 4464 Update replaces all the fields of a Node by ID. 4465 ''' 4466 deadline = None if timeout is None else time.time() + timeout 4467 req = NodeUpdateRequest() 4468 4469 if node is not None: 4470 req.node.CopyFrom(plumbing.convert_node_to_plumbing(node)) 4471 tries = 0 4472 plumbing_response = None 4473 while True: 4474 t = None if deadline is None else deadline - time.time() 4475 try: 4476 plumbing_response = self.stub.Update( 4477 req, 4478 metadata=self.parent.get_metadata('Nodes.Update', req), 4479 timeout=t) 4480 except Exception as e: 4481 if self.parent.shouldRetry(tries, e, deadline): 4482 tries += 1 4483 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4484 continue 4485 raise plumbing.convert_error_to_porcelain(e) from e 4486 break 4487 4488 resp = models.NodeUpdateResponse() 4489 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 4490 plumbing_response.meta) 4491 resp.node = plumbing.convert_node_to_porcelain(plumbing_response.node) 4492 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4493 plumbing_response.rate_limit) 4494 return resp 4495 4496 def delete(self, id, timeout=None): 4497 ''' 4498 Delete removes a Node by ID. 4499 ''' 4500 deadline = None if timeout is None else time.time() + timeout 4501 req = NodeDeleteRequest() 4502 4503 req.id = (id) 4504 tries = 0 4505 plumbing_response = None 4506 while True: 4507 t = None if deadline is None else deadline - time.time() 4508 try: 4509 plumbing_response = self.stub.Delete( 4510 req, 4511 metadata=self.parent.get_metadata('Nodes.Delete', req), 4512 timeout=t) 4513 except Exception as e: 4514 if self.parent.shouldRetry(tries, e, deadline): 4515 tries += 1 4516 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4517 continue 4518 raise plumbing.convert_error_to_porcelain(e) from e 4519 break 4520 4521 resp = models.NodeDeleteResponse() 4522 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 4523 plumbing_response.meta) 4524 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4525 plumbing_response.rate_limit) 4526 return resp 4527 4528 def list(self, filter, *args, timeout=None): 4529 ''' 4530 List gets a list of Nodes matching a given set of criteria. 4531 ''' 4532 deadline = None if timeout is None else time.time() + timeout 4533 req = NodeListRequest() 4534 req.meta.CopyFrom(ListRequestMetadata()) 4535 if self.parent.page_limit > 0: 4536 req.meta.limit = self.parent.page_limit 4537 if self.parent.snapshot_datetime is not None: 4538 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4539 4540 req.filter = plumbing.quote_filter_args(filter, *args) 4541 4542 def generator(svc, req): 4543 tries = 0 4544 while True: 4545 t = None if deadline is None else deadline - time.time() 4546 try: 4547 plumbing_response = svc.stub.List( 4548 req, 4549 metadata=svc.parent.get_metadata('Nodes.List', req), 4550 timeout=t) 4551 except Exception as e: 4552 if self.parent.shouldRetry(tries, e, deadline): 4553 tries += 1 4554 time.sleep( 4555 self.parent.exponentialBackoff(tries, deadline)) 4556 continue 4557 raise plumbing.convert_error_to_porcelain(e) from e 4558 tries = 0 4559 for plumbing_item in plumbing_response.nodes: 4560 yield plumbing.convert_node_to_porcelain(plumbing_item) 4561 if plumbing_response.meta.next_cursor == '': 4562 break 4563 req.meta.cursor = plumbing_response.meta.next_cursor 4564 4565 return generator(self, req) 4566 4567 def tcp_probe(self, node_id, host, port, timeout=None): 4568 ''' 4569 TCPProbe instructs a Node to connect to an address via TCP and report the 4570 result. 4571 ''' 4572 deadline = None if timeout is None else time.time() + timeout 4573 req = NodeTCPProbeRequest() 4574 4575 req.node_id = (node_id) 4576 req.host = (host) 4577 req.port = (port) 4578 tries = 0 4579 plumbing_response = None 4580 while True: 4581 t = None if deadline is None else deadline - time.time() 4582 try: 4583 plumbing_response = self.stub.TCPProbe( 4584 req, 4585 metadata=self.parent.get_metadata('Nodes.TCPProbe', req), 4586 timeout=t) 4587 except Exception as e: 4588 if self.parent.shouldRetry(tries, e, deadline): 4589 tries += 1 4590 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4591 continue 4592 raise plumbing.convert_error_to_porcelain(e) from e 4593 break 4594 4595 resp = models.NodeTCPProbeResponse() 4596 resp.error = (plumbing_response.error) 4597 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4598 plumbing_response.meta) 4599 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4600 plumbing_response.rate_limit) 4601 resp.succeeded = (plumbing_response.succeeded) 4602 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)
4391 def create(self, node, timeout=None): 4392 ''' 4393 Create registers a new Node. 4394 ''' 4395 deadline = None if timeout is None else time.time() + timeout 4396 req = NodeCreateRequest() 4397 4398 if node is not None: 4399 req.node.CopyFrom(plumbing.convert_node_to_plumbing(node)) 4400 tries = 0 4401 plumbing_response = None 4402 while True: 4403 t = None if deadline is None else deadline - time.time() 4404 try: 4405 plumbing_response = self.stub.Create( 4406 req, 4407 metadata=self.parent.get_metadata('Nodes.Create', req), 4408 timeout=t) 4409 except Exception as e: 4410 if self.parent.shouldRetry(tries, e, deadline): 4411 tries += 1 4412 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4413 continue 4414 raise plumbing.convert_error_to_porcelain(e) from e 4415 break 4416 4417 resp = models.NodeCreateResponse() 4418 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4419 plumbing_response.meta) 4420 resp.node = plumbing.convert_node_to_porcelain(plumbing_response.node) 4421 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4422 plumbing_response.rate_limit) 4423 resp.token = (plumbing_response.token) 4424 return resp
Create registers a new Node.
def
get(self, id, timeout=None)
4426 def get(self, id, timeout=None): 4427 ''' 4428 Get reads one Node by ID. 4429 ''' 4430 deadline = None if timeout is None else time.time() + timeout 4431 req = NodeGetRequest() 4432 if self.parent.snapshot_datetime is not None: 4433 req.meta.CopyFrom(GetRequestMetadata()) 4434 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4435 4436 req.id = (id) 4437 tries = 0 4438 plumbing_response = None 4439 while True: 4440 t = None if deadline is None else deadline - time.time() 4441 try: 4442 plumbing_response = self.stub.Get( 4443 req, 4444 metadata=self.parent.get_metadata('Nodes.Get', req), 4445 timeout=t) 4446 except Exception as e: 4447 if self.parent.shouldRetry(tries, e, deadline): 4448 tries += 1 4449 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4450 continue 4451 raise plumbing.convert_error_to_porcelain(e) from e 4452 break 4453 4454 resp = models.NodeGetResponse() 4455 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4456 plumbing_response.meta) 4457 resp.node = plumbing.convert_node_to_porcelain(plumbing_response.node) 4458 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4459 plumbing_response.rate_limit) 4460 return resp
Get reads one Node by ID.
def
update(self, node, timeout=None)
4462 def update(self, node, timeout=None): 4463 ''' 4464 Update replaces all the fields of a Node by ID. 4465 ''' 4466 deadline = None if timeout is None else time.time() + timeout 4467 req = NodeUpdateRequest() 4468 4469 if node is not None: 4470 req.node.CopyFrom(plumbing.convert_node_to_plumbing(node)) 4471 tries = 0 4472 plumbing_response = None 4473 while True: 4474 t = None if deadline is None else deadline - time.time() 4475 try: 4476 plumbing_response = self.stub.Update( 4477 req, 4478 metadata=self.parent.get_metadata('Nodes.Update', req), 4479 timeout=t) 4480 except Exception as e: 4481 if self.parent.shouldRetry(tries, e, deadline): 4482 tries += 1 4483 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4484 continue 4485 raise plumbing.convert_error_to_porcelain(e) from e 4486 break 4487 4488 resp = models.NodeUpdateResponse() 4489 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 4490 plumbing_response.meta) 4491 resp.node = plumbing.convert_node_to_porcelain(plumbing_response.node) 4492 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4493 plumbing_response.rate_limit) 4494 return resp
Update replaces all the fields of a Node by ID.
def
delete(self, id, timeout=None)
4496 def delete(self, id, timeout=None): 4497 ''' 4498 Delete removes a Node by ID. 4499 ''' 4500 deadline = None if timeout is None else time.time() + timeout 4501 req = NodeDeleteRequest() 4502 4503 req.id = (id) 4504 tries = 0 4505 plumbing_response = None 4506 while True: 4507 t = None if deadline is None else deadline - time.time() 4508 try: 4509 plumbing_response = self.stub.Delete( 4510 req, 4511 metadata=self.parent.get_metadata('Nodes.Delete', req), 4512 timeout=t) 4513 except Exception as e: 4514 if self.parent.shouldRetry(tries, e, deadline): 4515 tries += 1 4516 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4517 continue 4518 raise plumbing.convert_error_to_porcelain(e) from e 4519 break 4520 4521 resp = models.NodeDeleteResponse() 4522 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 4523 plumbing_response.meta) 4524 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4525 plumbing_response.rate_limit) 4526 return resp
Delete removes a Node by ID.
def
list(self, filter, *args, timeout=None)
4528 def list(self, filter, *args, timeout=None): 4529 ''' 4530 List gets a list of Nodes matching a given set of criteria. 4531 ''' 4532 deadline = None if timeout is None else time.time() + timeout 4533 req = NodeListRequest() 4534 req.meta.CopyFrom(ListRequestMetadata()) 4535 if self.parent.page_limit > 0: 4536 req.meta.limit = self.parent.page_limit 4537 if self.parent.snapshot_datetime is not None: 4538 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4539 4540 req.filter = plumbing.quote_filter_args(filter, *args) 4541 4542 def generator(svc, req): 4543 tries = 0 4544 while True: 4545 t = None if deadline is None else deadline - time.time() 4546 try: 4547 plumbing_response = svc.stub.List( 4548 req, 4549 metadata=svc.parent.get_metadata('Nodes.List', req), 4550 timeout=t) 4551 except Exception as e: 4552 if self.parent.shouldRetry(tries, e, deadline): 4553 tries += 1 4554 time.sleep( 4555 self.parent.exponentialBackoff(tries, deadline)) 4556 continue 4557 raise plumbing.convert_error_to_porcelain(e) from e 4558 tries = 0 4559 for plumbing_item in plumbing_response.nodes: 4560 yield plumbing.convert_node_to_porcelain(plumbing_item) 4561 if plumbing_response.meta.next_cursor == '': 4562 break 4563 req.meta.cursor = plumbing_response.meta.next_cursor 4564 4565 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)
4567 def tcp_probe(self, node_id, host, port, timeout=None): 4568 ''' 4569 TCPProbe instructs a Node to connect to an address via TCP and report the 4570 result. 4571 ''' 4572 deadline = None if timeout is None else time.time() + timeout 4573 req = NodeTCPProbeRequest() 4574 4575 req.node_id = (node_id) 4576 req.host = (host) 4577 req.port = (port) 4578 tries = 0 4579 plumbing_response = None 4580 while True: 4581 t = None if deadline is None else deadline - time.time() 4582 try: 4583 plumbing_response = self.stub.TCPProbe( 4584 req, 4585 metadata=self.parent.get_metadata('Nodes.TCPProbe', req), 4586 timeout=t) 4587 except Exception as e: 4588 if self.parent.shouldRetry(tries, e, deadline): 4589 tries += 1 4590 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4591 continue 4592 raise plumbing.convert_error_to_porcelain(e) from e 4593 break 4594 4595 resp = models.NodeTCPProbeResponse() 4596 resp.error = (plumbing_response.error) 4597 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4598 plumbing_response.meta) 4599 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4600 plumbing_response.rate_limit) 4601 resp.succeeded = (plumbing_response.succeeded) 4602 return resp
TCPProbe instructs a Node to connect to an address via TCP and report the result.
class
SnapshotNodes:
4605class SnapshotNodes: 4606 ''' 4607 SnapshotNodes exposes the read only methods of the Nodes 4608 service for historical queries. 4609 ''' 4610 def __init__(self, nodes): 4611 self.nodes = nodes 4612 4613 def get(self, id, timeout=None): 4614 ''' 4615 Get reads one Node by ID. 4616 ''' 4617 return self.nodes.get(id, timeout=timeout) 4618 4619 def list(self, filter, *args, timeout=None): 4620 ''' 4621 List gets a list of Nodes matching a given set of criteria. 4622 ''' 4623 return self.nodes.list(filter, *args, timeout=timeout)
SnapshotNodes exposes the read only methods of the Nodes service for historical queries.
class
NodesHistory:
4626class NodesHistory: 4627 ''' 4628 NodesHistory records all changes to the state of a Node. 4629 See `strongdm.models.NodeHistory`. 4630 ''' 4631 def __init__(self, channel, client): 4632 self.parent = client 4633 self.stub = NodesHistoryStub(channel) 4634 4635 def list(self, filter, *args, timeout=None): 4636 ''' 4637 List gets a list of NodeHistory records matching a given set of criteria. 4638 ''' 4639 deadline = None if timeout is None else time.time() + timeout 4640 req = NodeHistoryListRequest() 4641 req.meta.CopyFrom(ListRequestMetadata()) 4642 if self.parent.page_limit > 0: 4643 req.meta.limit = self.parent.page_limit 4644 if self.parent.snapshot_datetime is not None: 4645 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4646 4647 req.filter = plumbing.quote_filter_args(filter, *args) 4648 4649 def generator(svc, req): 4650 tries = 0 4651 while True: 4652 t = None if deadline is None else deadline - time.time() 4653 try: 4654 plumbing_response = svc.stub.List( 4655 req, 4656 metadata=svc.parent.get_metadata( 4657 'NodesHistory.List', req), 4658 timeout=t) 4659 except Exception as e: 4660 if self.parent.shouldRetry(tries, e, deadline): 4661 tries += 1 4662 time.sleep( 4663 self.parent.exponentialBackoff(tries, deadline)) 4664 continue 4665 raise plumbing.convert_error_to_porcelain(e) from e 4666 tries = 0 4667 for plumbing_item in plumbing_response.history: 4668 yield plumbing.convert_node_history_to_porcelain( 4669 plumbing_item) 4670 if plumbing_response.meta.next_cursor == '': 4671 break 4672 req.meta.cursor = plumbing_response.meta.next_cursor 4673 4674 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)
4635 def list(self, filter, *args, timeout=None): 4636 ''' 4637 List gets a list of NodeHistory records matching a given set of criteria. 4638 ''' 4639 deadline = None if timeout is None else time.time() + timeout 4640 req = NodeHistoryListRequest() 4641 req.meta.CopyFrom(ListRequestMetadata()) 4642 if self.parent.page_limit > 0: 4643 req.meta.limit = self.parent.page_limit 4644 if self.parent.snapshot_datetime is not None: 4645 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4646 4647 req.filter = plumbing.quote_filter_args(filter, *args) 4648 4649 def generator(svc, req): 4650 tries = 0 4651 while True: 4652 t = None if deadline is None else deadline - time.time() 4653 try: 4654 plumbing_response = svc.stub.List( 4655 req, 4656 metadata=svc.parent.get_metadata( 4657 'NodesHistory.List', req), 4658 timeout=t) 4659 except Exception as e: 4660 if self.parent.shouldRetry(tries, e, deadline): 4661 tries += 1 4662 time.sleep( 4663 self.parent.exponentialBackoff(tries, deadline)) 4664 continue 4665 raise plumbing.convert_error_to_porcelain(e) from e 4666 tries = 0 4667 for plumbing_item in plumbing_response.history: 4668 yield plumbing.convert_node_history_to_porcelain( 4669 plumbing_item) 4670 if plumbing_response.meta.next_cursor == '': 4671 break 4672 req.meta.cursor = plumbing_response.meta.next_cursor 4673 4674 return generator(self, req)
List gets a list of NodeHistory records matching a given set of criteria.
class
OrganizationHistory:
4677class OrganizationHistory: 4678 ''' 4679 OrganizationHistory records all changes to the state of an Organization. 4680 See `strongdm.models.OrganizationHistoryRecord`. 4681 ''' 4682 def __init__(self, channel, client): 4683 self.parent = client 4684 self.stub = OrganizationHistoryStub(channel) 4685 4686 def list(self, filter, *args, timeout=None): 4687 ''' 4688 List gets a list of OrganizationHistory records matching a given set of criteria. 4689 ''' 4690 deadline = None if timeout is None else time.time() + timeout 4691 req = OrganizationHistoryListRequest() 4692 req.meta.CopyFrom(ListRequestMetadata()) 4693 if self.parent.page_limit > 0: 4694 req.meta.limit = self.parent.page_limit 4695 if self.parent.snapshot_datetime is not None: 4696 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4697 4698 req.filter = plumbing.quote_filter_args(filter, *args) 4699 4700 def generator(svc, req): 4701 tries = 0 4702 while True: 4703 t = None if deadline is None else deadline - time.time() 4704 try: 4705 plumbing_response = svc.stub.List( 4706 req, 4707 metadata=svc.parent.get_metadata( 4708 'OrganizationHistory.List', req), 4709 timeout=t) 4710 except Exception as e: 4711 if self.parent.shouldRetry(tries, e, deadline): 4712 tries += 1 4713 time.sleep( 4714 self.parent.exponentialBackoff(tries, deadline)) 4715 continue 4716 raise plumbing.convert_error_to_porcelain(e) from e 4717 tries = 0 4718 for plumbing_item in plumbing_response.history: 4719 yield plumbing.convert_organization_history_record_to_porcelain( 4720 plumbing_item) 4721 if plumbing_response.meta.next_cursor == '': 4722 break 4723 req.meta.cursor = plumbing_response.meta.next_cursor 4724 4725 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)
4686 def list(self, filter, *args, timeout=None): 4687 ''' 4688 List gets a list of OrganizationHistory records matching a given set of criteria. 4689 ''' 4690 deadline = None if timeout is None else time.time() + timeout 4691 req = OrganizationHistoryListRequest() 4692 req.meta.CopyFrom(ListRequestMetadata()) 4693 if self.parent.page_limit > 0: 4694 req.meta.limit = self.parent.page_limit 4695 if self.parent.snapshot_datetime is not None: 4696 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4697 4698 req.filter = plumbing.quote_filter_args(filter, *args) 4699 4700 def generator(svc, req): 4701 tries = 0 4702 while True: 4703 t = None if deadline is None else deadline - time.time() 4704 try: 4705 plumbing_response = svc.stub.List( 4706 req, 4707 metadata=svc.parent.get_metadata( 4708 'OrganizationHistory.List', req), 4709 timeout=t) 4710 except Exception as e: 4711 if self.parent.shouldRetry(tries, e, deadline): 4712 tries += 1 4713 time.sleep( 4714 self.parent.exponentialBackoff(tries, deadline)) 4715 continue 4716 raise plumbing.convert_error_to_porcelain(e) from e 4717 tries = 0 4718 for plumbing_item in plumbing_response.history: 4719 yield plumbing.convert_organization_history_record_to_porcelain( 4720 plumbing_item) 4721 if plumbing_response.meta.next_cursor == '': 4722 break 4723 req.meta.cursor = plumbing_response.meta.next_cursor 4724 4725 return generator(self, req)
List gets a list of OrganizationHistory records matching a given set of criteria.
class
PeeringGroupNodes:
4728class PeeringGroupNodes: 4729 ''' 4730 PeeringGroupNodes provides the building blocks necessary to obtain attach a node to a peering group. 4731 See `strongdm.models.PeeringGroupNode`. 4732 ''' 4733 def __init__(self, channel, client): 4734 self.parent = client 4735 self.stub = PeeringGroupNodesStub(channel) 4736 4737 def create(self, peering_group_node, timeout=None): 4738 ''' 4739 Create attaches a Node to a PeeringGroup 4740 ''' 4741 deadline = None if timeout is None else time.time() + timeout 4742 req = PeeringGroupNodeCreateRequest() 4743 4744 if peering_group_node is not None: 4745 req.peering_group_node.CopyFrom( 4746 plumbing.convert_peering_group_node_to_plumbing( 4747 peering_group_node)) 4748 tries = 0 4749 plumbing_response = None 4750 while True: 4751 t = None if deadline is None else deadline - time.time() 4752 try: 4753 plumbing_response = self.stub.Create( 4754 req, 4755 metadata=self.parent.get_metadata( 4756 'PeeringGroupNodes.Create', req), 4757 timeout=t) 4758 except Exception as e: 4759 if self.parent.shouldRetry(tries, e, deadline): 4760 tries += 1 4761 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4762 continue 4763 raise plumbing.convert_error_to_porcelain(e) from e 4764 break 4765 4766 resp = models.PeeringGroupNodeCreateResponse() 4767 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4768 plumbing_response.meta) 4769 resp.peering_group_node = plumbing.convert_peering_group_node_to_porcelain( 4770 plumbing_response.peering_group_node) 4771 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4772 plumbing_response.rate_limit) 4773 return resp 4774 4775 def delete(self, id, timeout=None): 4776 ''' 4777 Delete detaches a Node to a PeeringGroup. 4778 ''' 4779 deadline = None if timeout is None else time.time() + timeout 4780 req = PeeringGroupNodeDeleteRequest() 4781 4782 req.id = (id) 4783 tries = 0 4784 plumbing_response = None 4785 while True: 4786 t = None if deadline is None else deadline - time.time() 4787 try: 4788 plumbing_response = self.stub.Delete( 4789 req, 4790 metadata=self.parent.get_metadata( 4791 'PeeringGroupNodes.Delete', req), 4792 timeout=t) 4793 except Exception as e: 4794 if self.parent.shouldRetry(tries, e, deadline): 4795 tries += 1 4796 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4797 continue 4798 raise plumbing.convert_error_to_porcelain(e) from e 4799 break 4800 4801 resp = models.PeeringGroupNodeDeleteResponse() 4802 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 4803 plumbing_response.meta) 4804 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4805 plumbing_response.rate_limit) 4806 return resp 4807 4808 def get(self, id, timeout=None): 4809 ''' 4810 Get reads the information of one peering group to node attachment. 4811 ''' 4812 deadline = None if timeout is None else time.time() + timeout 4813 req = PeeringGroupNodeGetRequest() 4814 if self.parent.snapshot_datetime is not None: 4815 req.meta.CopyFrom(GetRequestMetadata()) 4816 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4817 4818 req.id = (id) 4819 tries = 0 4820 plumbing_response = None 4821 while True: 4822 t = None if deadline is None else deadline - time.time() 4823 try: 4824 plumbing_response = self.stub.Get( 4825 req, 4826 metadata=self.parent.get_metadata('PeeringGroupNodes.Get', 4827 req), 4828 timeout=t) 4829 except Exception as e: 4830 if self.parent.shouldRetry(tries, e, deadline): 4831 tries += 1 4832 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4833 continue 4834 raise plumbing.convert_error_to_porcelain(e) from e 4835 break 4836 4837 resp = models.PeeringGroupNodeGetResponse() 4838 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4839 plumbing_response.meta) 4840 resp.peering_group_node = plumbing.convert_peering_group_node_to_porcelain( 4841 plumbing_response.peering_group_node) 4842 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4843 plumbing_response.rate_limit) 4844 return resp 4845 4846 def list(self, filter, *args, timeout=None): 4847 ''' 4848 List gets a list of peering group node attachments. 4849 ''' 4850 deadline = None if timeout is None else time.time() + timeout 4851 req = PeeringGroupNodeListRequest() 4852 req.meta.CopyFrom(ListRequestMetadata()) 4853 if self.parent.page_limit > 0: 4854 req.meta.limit = self.parent.page_limit 4855 if self.parent.snapshot_datetime is not None: 4856 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4857 4858 req.filter = plumbing.quote_filter_args(filter, *args) 4859 4860 def generator(svc, req): 4861 tries = 0 4862 while True: 4863 t = None if deadline is None else deadline - time.time() 4864 try: 4865 plumbing_response = svc.stub.List( 4866 req, 4867 metadata=svc.parent.get_metadata( 4868 'PeeringGroupNodes.List', req), 4869 timeout=t) 4870 except Exception as e: 4871 if self.parent.shouldRetry(tries, e, deadline): 4872 tries += 1 4873 time.sleep( 4874 self.parent.exponentialBackoff(tries, deadline)) 4875 continue 4876 raise plumbing.convert_error_to_porcelain(e) from e 4877 tries = 0 4878 for plumbing_item in plumbing_response.peering_group_nodes: 4879 yield plumbing.convert_peering_group_node_to_porcelain( 4880 plumbing_item) 4881 if plumbing_response.meta.next_cursor == '': 4882 break 4883 req.meta.cursor = plumbing_response.meta.next_cursor 4884 4885 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)
4737 def create(self, peering_group_node, timeout=None): 4738 ''' 4739 Create attaches a Node to a PeeringGroup 4740 ''' 4741 deadline = None if timeout is None else time.time() + timeout 4742 req = PeeringGroupNodeCreateRequest() 4743 4744 if peering_group_node is not None: 4745 req.peering_group_node.CopyFrom( 4746 plumbing.convert_peering_group_node_to_plumbing( 4747 peering_group_node)) 4748 tries = 0 4749 plumbing_response = None 4750 while True: 4751 t = None if deadline is None else deadline - time.time() 4752 try: 4753 plumbing_response = self.stub.Create( 4754 req, 4755 metadata=self.parent.get_metadata( 4756 'PeeringGroupNodes.Create', req), 4757 timeout=t) 4758 except Exception as e: 4759 if self.parent.shouldRetry(tries, e, deadline): 4760 tries += 1 4761 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4762 continue 4763 raise plumbing.convert_error_to_porcelain(e) from e 4764 break 4765 4766 resp = models.PeeringGroupNodeCreateResponse() 4767 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4768 plumbing_response.meta) 4769 resp.peering_group_node = plumbing.convert_peering_group_node_to_porcelain( 4770 plumbing_response.peering_group_node) 4771 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4772 plumbing_response.rate_limit) 4773 return resp
Create attaches a Node to a PeeringGroup
def
delete(self, id, timeout=None)
4775 def delete(self, id, timeout=None): 4776 ''' 4777 Delete detaches a Node to a PeeringGroup. 4778 ''' 4779 deadline = None if timeout is None else time.time() + timeout 4780 req = PeeringGroupNodeDeleteRequest() 4781 4782 req.id = (id) 4783 tries = 0 4784 plumbing_response = None 4785 while True: 4786 t = None if deadline is None else deadline - time.time() 4787 try: 4788 plumbing_response = self.stub.Delete( 4789 req, 4790 metadata=self.parent.get_metadata( 4791 'PeeringGroupNodes.Delete', req), 4792 timeout=t) 4793 except Exception as e: 4794 if self.parent.shouldRetry(tries, e, deadline): 4795 tries += 1 4796 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4797 continue 4798 raise plumbing.convert_error_to_porcelain(e) from e 4799 break 4800 4801 resp = models.PeeringGroupNodeDeleteResponse() 4802 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 4803 plumbing_response.meta) 4804 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4805 plumbing_response.rate_limit) 4806 return resp
Delete detaches a Node to a PeeringGroup.
def
get(self, id, timeout=None)
4808 def get(self, id, timeout=None): 4809 ''' 4810 Get reads the information of one peering group to node attachment. 4811 ''' 4812 deadline = None if timeout is None else time.time() + timeout 4813 req = PeeringGroupNodeGetRequest() 4814 if self.parent.snapshot_datetime is not None: 4815 req.meta.CopyFrom(GetRequestMetadata()) 4816 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4817 4818 req.id = (id) 4819 tries = 0 4820 plumbing_response = None 4821 while True: 4822 t = None if deadline is None else deadline - time.time() 4823 try: 4824 plumbing_response = self.stub.Get( 4825 req, 4826 metadata=self.parent.get_metadata('PeeringGroupNodes.Get', 4827 req), 4828 timeout=t) 4829 except Exception as e: 4830 if self.parent.shouldRetry(tries, e, deadline): 4831 tries += 1 4832 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4833 continue 4834 raise plumbing.convert_error_to_porcelain(e) from e 4835 break 4836 4837 resp = models.PeeringGroupNodeGetResponse() 4838 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4839 plumbing_response.meta) 4840 resp.peering_group_node = plumbing.convert_peering_group_node_to_porcelain( 4841 plumbing_response.peering_group_node) 4842 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4843 plumbing_response.rate_limit) 4844 return resp
Get reads the information of one peering group to node attachment.
def
list(self, filter, *args, timeout=None)
4846 def list(self, filter, *args, timeout=None): 4847 ''' 4848 List gets a list of peering group node attachments. 4849 ''' 4850 deadline = None if timeout is None else time.time() + timeout 4851 req = PeeringGroupNodeListRequest() 4852 req.meta.CopyFrom(ListRequestMetadata()) 4853 if self.parent.page_limit > 0: 4854 req.meta.limit = self.parent.page_limit 4855 if self.parent.snapshot_datetime is not None: 4856 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4857 4858 req.filter = plumbing.quote_filter_args(filter, *args) 4859 4860 def generator(svc, req): 4861 tries = 0 4862 while True: 4863 t = None if deadline is None else deadline - time.time() 4864 try: 4865 plumbing_response = svc.stub.List( 4866 req, 4867 metadata=svc.parent.get_metadata( 4868 'PeeringGroupNodes.List', req), 4869 timeout=t) 4870 except Exception as e: 4871 if self.parent.shouldRetry(tries, e, deadline): 4872 tries += 1 4873 time.sleep( 4874 self.parent.exponentialBackoff(tries, deadline)) 4875 continue 4876 raise plumbing.convert_error_to_porcelain(e) from e 4877 tries = 0 4878 for plumbing_item in plumbing_response.peering_group_nodes: 4879 yield plumbing.convert_peering_group_node_to_porcelain( 4880 plumbing_item) 4881 if plumbing_response.meta.next_cursor == '': 4882 break 4883 req.meta.cursor = plumbing_response.meta.next_cursor 4884 4885 return generator(self, req)
List gets a list of peering group node attachments.
class
PeeringGroupPeers:
4888class PeeringGroupPeers: 4889 ''' 4890 PeeringGroupPeers provides the building blocks necessary to link two peering groups. 4891 See `strongdm.models.PeeringGroupPeer`. 4892 ''' 4893 def __init__(self, channel, client): 4894 self.parent = client 4895 self.stub = PeeringGroupPeersStub(channel) 4896 4897 def create(self, peering_group_peer, timeout=None): 4898 ''' 4899 Create links two peering groups. 4900 ''' 4901 deadline = None if timeout is None else time.time() + timeout 4902 req = PeeringGroupPeerCreateRequest() 4903 4904 if peering_group_peer is not None: 4905 req.peering_group_peer.CopyFrom( 4906 plumbing.convert_peering_group_peer_to_plumbing( 4907 peering_group_peer)) 4908 tries = 0 4909 plumbing_response = None 4910 while True: 4911 t = None if deadline is None else deadline - time.time() 4912 try: 4913 plumbing_response = self.stub.Create( 4914 req, 4915 metadata=self.parent.get_metadata( 4916 'PeeringGroupPeers.Create', req), 4917 timeout=t) 4918 except Exception as e: 4919 if self.parent.shouldRetry(tries, e, deadline): 4920 tries += 1 4921 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4922 continue 4923 raise plumbing.convert_error_to_porcelain(e) from e 4924 break 4925 4926 resp = models.PeeringGroupPeerCreateResponse() 4927 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4928 plumbing_response.meta) 4929 resp.peering_group_peer = plumbing.convert_peering_group_peer_to_porcelain( 4930 plumbing_response.peering_group_peer) 4931 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4932 plumbing_response.rate_limit) 4933 return resp 4934 4935 def delete(self, id, timeout=None): 4936 ''' 4937 Delete unlinks two peering groups. 4938 ''' 4939 deadline = None if timeout is None else time.time() + timeout 4940 req = PeeringGroupPeerDeleteRequest() 4941 4942 req.id = (id) 4943 tries = 0 4944 plumbing_response = None 4945 while True: 4946 t = None if deadline is None else deadline - time.time() 4947 try: 4948 plumbing_response = self.stub.Delete( 4949 req, 4950 metadata=self.parent.get_metadata( 4951 'PeeringGroupPeers.Delete', req), 4952 timeout=t) 4953 except Exception as e: 4954 if self.parent.shouldRetry(tries, e, deadline): 4955 tries += 1 4956 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4957 continue 4958 raise plumbing.convert_error_to_porcelain(e) from e 4959 break 4960 4961 resp = models.PeeringGroupPeerDeleteResponse() 4962 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 4963 plumbing_response.meta) 4964 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4965 plumbing_response.rate_limit) 4966 return resp 4967 4968 def get(self, id, timeout=None): 4969 ''' 4970 Get reads the information of one peering group link. 4971 ''' 4972 deadline = None if timeout is None else time.time() + timeout 4973 req = PeeringGroupPeerGetRequest() 4974 if self.parent.snapshot_datetime is not None: 4975 req.meta.CopyFrom(GetRequestMetadata()) 4976 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4977 4978 req.id = (id) 4979 tries = 0 4980 plumbing_response = None 4981 while True: 4982 t = None if deadline is None else deadline - time.time() 4983 try: 4984 plumbing_response = self.stub.Get( 4985 req, 4986 metadata=self.parent.get_metadata('PeeringGroupPeers.Get', 4987 req), 4988 timeout=t) 4989 except Exception as e: 4990 if self.parent.shouldRetry(tries, e, deadline): 4991 tries += 1 4992 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4993 continue 4994 raise plumbing.convert_error_to_porcelain(e) from e 4995 break 4996 4997 resp = models.PeeringGroupPeerGetResponse() 4998 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4999 plumbing_response.meta) 5000 resp.peering_group_peer = plumbing.convert_peering_group_peer_to_porcelain( 5001 plumbing_response.peering_group_peer) 5002 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5003 plumbing_response.rate_limit) 5004 return resp 5005 5006 def list(self, filter, *args, timeout=None): 5007 ''' 5008 List gets a list of peering group links. 5009 ''' 5010 deadline = None if timeout is None else time.time() + timeout 5011 req = PeeringGroupPeerListRequest() 5012 req.meta.CopyFrom(ListRequestMetadata()) 5013 if self.parent.page_limit > 0: 5014 req.meta.limit = self.parent.page_limit 5015 if self.parent.snapshot_datetime is not None: 5016 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5017 5018 req.filter = plumbing.quote_filter_args(filter, *args) 5019 5020 def generator(svc, req): 5021 tries = 0 5022 while True: 5023 t = None if deadline is None else deadline - time.time() 5024 try: 5025 plumbing_response = svc.stub.List( 5026 req, 5027 metadata=svc.parent.get_metadata( 5028 'PeeringGroupPeers.List', req), 5029 timeout=t) 5030 except Exception as e: 5031 if self.parent.shouldRetry(tries, e, deadline): 5032 tries += 1 5033 time.sleep( 5034 self.parent.exponentialBackoff(tries, deadline)) 5035 continue 5036 raise plumbing.convert_error_to_porcelain(e) from e 5037 tries = 0 5038 for plumbing_item in plumbing_response.peering_group_peers: 5039 yield plumbing.convert_peering_group_peer_to_porcelain( 5040 plumbing_item) 5041 if plumbing_response.meta.next_cursor == '': 5042 break 5043 req.meta.cursor = plumbing_response.meta.next_cursor 5044 5045 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)
4897 def create(self, peering_group_peer, timeout=None): 4898 ''' 4899 Create links two peering groups. 4900 ''' 4901 deadline = None if timeout is None else time.time() + timeout 4902 req = PeeringGroupPeerCreateRequest() 4903 4904 if peering_group_peer is not None: 4905 req.peering_group_peer.CopyFrom( 4906 plumbing.convert_peering_group_peer_to_plumbing( 4907 peering_group_peer)) 4908 tries = 0 4909 plumbing_response = None 4910 while True: 4911 t = None if deadline is None else deadline - time.time() 4912 try: 4913 plumbing_response = self.stub.Create( 4914 req, 4915 metadata=self.parent.get_metadata( 4916 'PeeringGroupPeers.Create', req), 4917 timeout=t) 4918 except Exception as e: 4919 if self.parent.shouldRetry(tries, e, deadline): 4920 tries += 1 4921 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4922 continue 4923 raise plumbing.convert_error_to_porcelain(e) from e 4924 break 4925 4926 resp = models.PeeringGroupPeerCreateResponse() 4927 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4928 plumbing_response.meta) 4929 resp.peering_group_peer = plumbing.convert_peering_group_peer_to_porcelain( 4930 plumbing_response.peering_group_peer) 4931 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4932 plumbing_response.rate_limit) 4933 return resp
Create links two peering groups.
def
delete(self, id, timeout=None)
4935 def delete(self, id, timeout=None): 4936 ''' 4937 Delete unlinks two peering groups. 4938 ''' 4939 deadline = None if timeout is None else time.time() + timeout 4940 req = PeeringGroupPeerDeleteRequest() 4941 4942 req.id = (id) 4943 tries = 0 4944 plumbing_response = None 4945 while True: 4946 t = None if deadline is None else deadline - time.time() 4947 try: 4948 plumbing_response = self.stub.Delete( 4949 req, 4950 metadata=self.parent.get_metadata( 4951 'PeeringGroupPeers.Delete', req), 4952 timeout=t) 4953 except Exception as e: 4954 if self.parent.shouldRetry(tries, e, deadline): 4955 tries += 1 4956 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4957 continue 4958 raise plumbing.convert_error_to_porcelain(e) from e 4959 break 4960 4961 resp = models.PeeringGroupPeerDeleteResponse() 4962 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 4963 plumbing_response.meta) 4964 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4965 plumbing_response.rate_limit) 4966 return resp
Delete unlinks two peering groups.
def
get(self, id, timeout=None)
4968 def get(self, id, timeout=None): 4969 ''' 4970 Get reads the information of one peering group link. 4971 ''' 4972 deadline = None if timeout is None else time.time() + timeout 4973 req = PeeringGroupPeerGetRequest() 4974 if self.parent.snapshot_datetime is not None: 4975 req.meta.CopyFrom(GetRequestMetadata()) 4976 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4977 4978 req.id = (id) 4979 tries = 0 4980 plumbing_response = None 4981 while True: 4982 t = None if deadline is None else deadline - time.time() 4983 try: 4984 plumbing_response = self.stub.Get( 4985 req, 4986 metadata=self.parent.get_metadata('PeeringGroupPeers.Get', 4987 req), 4988 timeout=t) 4989 except Exception as e: 4990 if self.parent.shouldRetry(tries, e, deadline): 4991 tries += 1 4992 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4993 continue 4994 raise plumbing.convert_error_to_porcelain(e) from e 4995 break 4996 4997 resp = models.PeeringGroupPeerGetResponse() 4998 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4999 plumbing_response.meta) 5000 resp.peering_group_peer = plumbing.convert_peering_group_peer_to_porcelain( 5001 plumbing_response.peering_group_peer) 5002 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5003 plumbing_response.rate_limit) 5004 return resp
Get reads the information of one peering group link.
def
list(self, filter, *args, timeout=None)
5006 def list(self, filter, *args, timeout=None): 5007 ''' 5008 List gets a list of peering group links. 5009 ''' 5010 deadline = None if timeout is None else time.time() + timeout 5011 req = PeeringGroupPeerListRequest() 5012 req.meta.CopyFrom(ListRequestMetadata()) 5013 if self.parent.page_limit > 0: 5014 req.meta.limit = self.parent.page_limit 5015 if self.parent.snapshot_datetime is not None: 5016 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5017 5018 req.filter = plumbing.quote_filter_args(filter, *args) 5019 5020 def generator(svc, req): 5021 tries = 0 5022 while True: 5023 t = None if deadline is None else deadline - time.time() 5024 try: 5025 plumbing_response = svc.stub.List( 5026 req, 5027 metadata=svc.parent.get_metadata( 5028 'PeeringGroupPeers.List', req), 5029 timeout=t) 5030 except Exception as e: 5031 if self.parent.shouldRetry(tries, e, deadline): 5032 tries += 1 5033 time.sleep( 5034 self.parent.exponentialBackoff(tries, deadline)) 5035 continue 5036 raise plumbing.convert_error_to_porcelain(e) from e 5037 tries = 0 5038 for plumbing_item in plumbing_response.peering_group_peers: 5039 yield plumbing.convert_peering_group_peer_to_porcelain( 5040 plumbing_item) 5041 if plumbing_response.meta.next_cursor == '': 5042 break 5043 req.meta.cursor = plumbing_response.meta.next_cursor 5044 5045 return generator(self, req)
List gets a list of peering group links.
class
PeeringGroupResources:
5048class PeeringGroupResources: 5049 ''' 5050 PeeringGroupResources provides the building blocks necessary to obtain attach a resource to a peering group. 5051 See `strongdm.models.PeeringGroupResource`. 5052 ''' 5053 def __init__(self, channel, client): 5054 self.parent = client 5055 self.stub = PeeringGroupResourcesStub(channel) 5056 5057 def create(self, peering_group_resource, timeout=None): 5058 ''' 5059 Create attaches a Resource to a PeeringGroup 5060 ''' 5061 deadline = None if timeout is None else time.time() + timeout 5062 req = PeeringGroupResourceCreateRequest() 5063 5064 if peering_group_resource is not None: 5065 req.peering_group_resource.CopyFrom( 5066 plumbing.convert_peering_group_resource_to_plumbing( 5067 peering_group_resource)) 5068 tries = 0 5069 plumbing_response = None 5070 while True: 5071 t = None if deadline is None else deadline - time.time() 5072 try: 5073 plumbing_response = self.stub.Create( 5074 req, 5075 metadata=self.parent.get_metadata( 5076 'PeeringGroupResources.Create', req), 5077 timeout=t) 5078 except Exception as e: 5079 if self.parent.shouldRetry(tries, e, deadline): 5080 tries += 1 5081 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5082 continue 5083 raise plumbing.convert_error_to_porcelain(e) from e 5084 break 5085 5086 resp = models.PeeringGroupResourceCreateResponse() 5087 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5088 plumbing_response.meta) 5089 resp.peering_group_resource = plumbing.convert_peering_group_resource_to_porcelain( 5090 plumbing_response.peering_group_resource) 5091 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5092 plumbing_response.rate_limit) 5093 return resp 5094 5095 def delete(self, id, timeout=None): 5096 ''' 5097 Delete detaches a Resource to a PeeringGroup 5098 ''' 5099 deadline = None if timeout is None else time.time() + timeout 5100 req = PeeringGroupResourceDeleteRequest() 5101 5102 req.id = (id) 5103 tries = 0 5104 plumbing_response = None 5105 while True: 5106 t = None if deadline is None else deadline - time.time() 5107 try: 5108 plumbing_response = self.stub.Delete( 5109 req, 5110 metadata=self.parent.get_metadata( 5111 'PeeringGroupResources.Delete', req), 5112 timeout=t) 5113 except Exception as e: 5114 if self.parent.shouldRetry(tries, e, deadline): 5115 tries += 1 5116 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5117 continue 5118 raise plumbing.convert_error_to_porcelain(e) from e 5119 break 5120 5121 resp = models.PeeringGroupResourceDeleteResponse() 5122 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 5123 plumbing_response.meta) 5124 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5125 plumbing_response.rate_limit) 5126 return resp 5127 5128 def get(self, id, timeout=None): 5129 ''' 5130 Get reads the information of one peering group to resource attachment. 5131 ''' 5132 deadline = None if timeout is None else time.time() + timeout 5133 req = PeeringGroupResourceGetRequest() 5134 if self.parent.snapshot_datetime is not None: 5135 req.meta.CopyFrom(GetRequestMetadata()) 5136 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5137 5138 req.id = (id) 5139 tries = 0 5140 plumbing_response = None 5141 while True: 5142 t = None if deadline is None else deadline - time.time() 5143 try: 5144 plumbing_response = self.stub.Get( 5145 req, 5146 metadata=self.parent.get_metadata( 5147 'PeeringGroupResources.Get', req), 5148 timeout=t) 5149 except Exception as e: 5150 if self.parent.shouldRetry(tries, e, deadline): 5151 tries += 1 5152 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5153 continue 5154 raise plumbing.convert_error_to_porcelain(e) from e 5155 break 5156 5157 resp = models.PeeringGroupResourceGetResponse() 5158 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5159 plumbing_response.meta) 5160 resp.peering_group_resource = plumbing.convert_peering_group_resource_to_porcelain( 5161 plumbing_response.peering_group_resource) 5162 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5163 plumbing_response.rate_limit) 5164 return resp 5165 5166 def list(self, filter, *args, timeout=None): 5167 ''' 5168 List gets a list of peering group resource attachments. 5169 ''' 5170 deadline = None if timeout is None else time.time() + timeout 5171 req = PeeringGroupResourceListRequest() 5172 req.meta.CopyFrom(ListRequestMetadata()) 5173 if self.parent.page_limit > 0: 5174 req.meta.limit = self.parent.page_limit 5175 if self.parent.snapshot_datetime is not None: 5176 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5177 5178 req.filter = plumbing.quote_filter_args(filter, *args) 5179 5180 def generator(svc, req): 5181 tries = 0 5182 while True: 5183 t = None if deadline is None else deadline - time.time() 5184 try: 5185 plumbing_response = svc.stub.List( 5186 req, 5187 metadata=svc.parent.get_metadata( 5188 'PeeringGroupResources.List', req), 5189 timeout=t) 5190 except Exception as e: 5191 if self.parent.shouldRetry(tries, e, deadline): 5192 tries += 1 5193 time.sleep( 5194 self.parent.exponentialBackoff(tries, deadline)) 5195 continue 5196 raise plumbing.convert_error_to_porcelain(e) from e 5197 tries = 0 5198 for plumbing_item in plumbing_response.peering_group_resources: 5199 yield plumbing.convert_peering_group_resource_to_porcelain( 5200 plumbing_item) 5201 if plumbing_response.meta.next_cursor == '': 5202 break 5203 req.meta.cursor = plumbing_response.meta.next_cursor 5204 5205 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)
5057 def create(self, peering_group_resource, timeout=None): 5058 ''' 5059 Create attaches a Resource to a PeeringGroup 5060 ''' 5061 deadline = None if timeout is None else time.time() + timeout 5062 req = PeeringGroupResourceCreateRequest() 5063 5064 if peering_group_resource is not None: 5065 req.peering_group_resource.CopyFrom( 5066 plumbing.convert_peering_group_resource_to_plumbing( 5067 peering_group_resource)) 5068 tries = 0 5069 plumbing_response = None 5070 while True: 5071 t = None if deadline is None else deadline - time.time() 5072 try: 5073 plumbing_response = self.stub.Create( 5074 req, 5075 metadata=self.parent.get_metadata( 5076 'PeeringGroupResources.Create', req), 5077 timeout=t) 5078 except Exception as e: 5079 if self.parent.shouldRetry(tries, e, deadline): 5080 tries += 1 5081 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5082 continue 5083 raise plumbing.convert_error_to_porcelain(e) from e 5084 break 5085 5086 resp = models.PeeringGroupResourceCreateResponse() 5087 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5088 plumbing_response.meta) 5089 resp.peering_group_resource = plumbing.convert_peering_group_resource_to_porcelain( 5090 plumbing_response.peering_group_resource) 5091 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5092 plumbing_response.rate_limit) 5093 return resp
Create attaches a Resource to a PeeringGroup
def
delete(self, id, timeout=None)
5095 def delete(self, id, timeout=None): 5096 ''' 5097 Delete detaches a Resource to a PeeringGroup 5098 ''' 5099 deadline = None if timeout is None else time.time() + timeout 5100 req = PeeringGroupResourceDeleteRequest() 5101 5102 req.id = (id) 5103 tries = 0 5104 plumbing_response = None 5105 while True: 5106 t = None if deadline is None else deadline - time.time() 5107 try: 5108 plumbing_response = self.stub.Delete( 5109 req, 5110 metadata=self.parent.get_metadata( 5111 'PeeringGroupResources.Delete', req), 5112 timeout=t) 5113 except Exception as e: 5114 if self.parent.shouldRetry(tries, e, deadline): 5115 tries += 1 5116 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5117 continue 5118 raise plumbing.convert_error_to_porcelain(e) from e 5119 break 5120 5121 resp = models.PeeringGroupResourceDeleteResponse() 5122 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 5123 plumbing_response.meta) 5124 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5125 plumbing_response.rate_limit) 5126 return resp
Delete detaches a Resource to a PeeringGroup
def
get(self, id, timeout=None)
5128 def get(self, id, timeout=None): 5129 ''' 5130 Get reads the information of one peering group to resource attachment. 5131 ''' 5132 deadline = None if timeout is None else time.time() + timeout 5133 req = PeeringGroupResourceGetRequest() 5134 if self.parent.snapshot_datetime is not None: 5135 req.meta.CopyFrom(GetRequestMetadata()) 5136 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5137 5138 req.id = (id) 5139 tries = 0 5140 plumbing_response = None 5141 while True: 5142 t = None if deadline is None else deadline - time.time() 5143 try: 5144 plumbing_response = self.stub.Get( 5145 req, 5146 metadata=self.parent.get_metadata( 5147 'PeeringGroupResources.Get', req), 5148 timeout=t) 5149 except Exception as e: 5150 if self.parent.shouldRetry(tries, e, deadline): 5151 tries += 1 5152 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5153 continue 5154 raise plumbing.convert_error_to_porcelain(e) from e 5155 break 5156 5157 resp = models.PeeringGroupResourceGetResponse() 5158 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5159 plumbing_response.meta) 5160 resp.peering_group_resource = plumbing.convert_peering_group_resource_to_porcelain( 5161 plumbing_response.peering_group_resource) 5162 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5163 plumbing_response.rate_limit) 5164 return resp
Get reads the information of one peering group to resource attachment.
def
list(self, filter, *args, timeout=None)
5166 def list(self, filter, *args, timeout=None): 5167 ''' 5168 List gets a list of peering group resource attachments. 5169 ''' 5170 deadline = None if timeout is None else time.time() + timeout 5171 req = PeeringGroupResourceListRequest() 5172 req.meta.CopyFrom(ListRequestMetadata()) 5173 if self.parent.page_limit > 0: 5174 req.meta.limit = self.parent.page_limit 5175 if self.parent.snapshot_datetime is not None: 5176 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5177 5178 req.filter = plumbing.quote_filter_args(filter, *args) 5179 5180 def generator(svc, req): 5181 tries = 0 5182 while True: 5183 t = None if deadline is None else deadline - time.time() 5184 try: 5185 plumbing_response = svc.stub.List( 5186 req, 5187 metadata=svc.parent.get_metadata( 5188 'PeeringGroupResources.List', req), 5189 timeout=t) 5190 except Exception as e: 5191 if self.parent.shouldRetry(tries, e, deadline): 5192 tries += 1 5193 time.sleep( 5194 self.parent.exponentialBackoff(tries, deadline)) 5195 continue 5196 raise plumbing.convert_error_to_porcelain(e) from e 5197 tries = 0 5198 for plumbing_item in plumbing_response.peering_group_resources: 5199 yield plumbing.convert_peering_group_resource_to_porcelain( 5200 plumbing_item) 5201 if plumbing_response.meta.next_cursor == '': 5202 break 5203 req.meta.cursor = plumbing_response.meta.next_cursor 5204 5205 return generator(self, req)
List gets a list of peering group resource attachments.
class
PeeringGroups:
5208class PeeringGroups: 5209 ''' 5210 PeeringGroups provides the building blocks necessary to obtain explicit network topology and routing. 5211 See `strongdm.models.PeeringGroup`. 5212 ''' 5213 def __init__(self, channel, client): 5214 self.parent = client 5215 self.stub = PeeringGroupsStub(channel) 5216 5217 def create(self, peering_group, timeout=None): 5218 ''' 5219 Create registers a new PeeringGroup. 5220 ''' 5221 deadline = None if timeout is None else time.time() + timeout 5222 req = PeeringGroupCreateRequest() 5223 5224 if peering_group is not None: 5225 req.peering_group.CopyFrom( 5226 plumbing.convert_peering_group_to_plumbing(peering_group)) 5227 tries = 0 5228 plumbing_response = None 5229 while True: 5230 t = None if deadline is None else deadline - time.time() 5231 try: 5232 plumbing_response = self.stub.Create( 5233 req, 5234 metadata=self.parent.get_metadata('PeeringGroups.Create', 5235 req), 5236 timeout=t) 5237 except Exception as e: 5238 if self.parent.shouldRetry(tries, e, deadline): 5239 tries += 1 5240 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5241 continue 5242 raise plumbing.convert_error_to_porcelain(e) from e 5243 break 5244 5245 resp = models.PeeringGroupCreateResponse() 5246 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5247 plumbing_response.meta) 5248 resp.peering_group = plumbing.convert_peering_group_to_porcelain( 5249 plumbing_response.peering_group) 5250 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5251 plumbing_response.rate_limit) 5252 return resp 5253 5254 def delete(self, id, timeout=None): 5255 ''' 5256 Delete removes a PeeringGroup by ID. 5257 ''' 5258 deadline = None if timeout is None else time.time() + timeout 5259 req = PeeringGroupDeleteRequest() 5260 5261 req.id = (id) 5262 tries = 0 5263 plumbing_response = None 5264 while True: 5265 t = None if deadline is None else deadline - time.time() 5266 try: 5267 plumbing_response = self.stub.Delete( 5268 req, 5269 metadata=self.parent.get_metadata('PeeringGroups.Delete', 5270 req), 5271 timeout=t) 5272 except Exception as e: 5273 if self.parent.shouldRetry(tries, e, deadline): 5274 tries += 1 5275 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5276 continue 5277 raise plumbing.convert_error_to_porcelain(e) from e 5278 break 5279 5280 resp = models.PeeringGroupDeleteResponse() 5281 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 5282 plumbing_response.meta) 5283 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5284 plumbing_response.rate_limit) 5285 return resp 5286 5287 def get(self, id, timeout=None): 5288 ''' 5289 Get reads one PeeringGroup by ID. It will load all its dependencies. 5290 ''' 5291 deadline = None if timeout is None else time.time() + timeout 5292 req = PeeringGroupGetRequest() 5293 if self.parent.snapshot_datetime is not None: 5294 req.meta.CopyFrom(GetRequestMetadata()) 5295 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5296 5297 req.id = (id) 5298 tries = 0 5299 plumbing_response = None 5300 while True: 5301 t = None if deadline is None else deadline - time.time() 5302 try: 5303 plumbing_response = self.stub.Get( 5304 req, 5305 metadata=self.parent.get_metadata('PeeringGroups.Get', 5306 req), 5307 timeout=t) 5308 except Exception as e: 5309 if self.parent.shouldRetry(tries, e, deadline): 5310 tries += 1 5311 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5312 continue 5313 raise plumbing.convert_error_to_porcelain(e) from e 5314 break 5315 5316 resp = models.PeeringGroupGetResponse() 5317 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5318 plumbing_response.meta) 5319 resp.peering_group = plumbing.convert_peering_group_to_porcelain( 5320 plumbing_response.peering_group) 5321 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5322 plumbing_response.rate_limit) 5323 return resp 5324 5325 def list(self, filter, *args, timeout=None): 5326 ''' 5327 List gets a list of Peering Groups. 5328 ''' 5329 deadline = None if timeout is None else time.time() + timeout 5330 req = PeeringGroupListRequest() 5331 req.meta.CopyFrom(ListRequestMetadata()) 5332 if self.parent.page_limit > 0: 5333 req.meta.limit = self.parent.page_limit 5334 if self.parent.snapshot_datetime is not None: 5335 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5336 5337 req.filter = plumbing.quote_filter_args(filter, *args) 5338 5339 def generator(svc, req): 5340 tries = 0 5341 while True: 5342 t = None if deadline is None else deadline - time.time() 5343 try: 5344 plumbing_response = svc.stub.List( 5345 req, 5346 metadata=svc.parent.get_metadata( 5347 'PeeringGroups.List', req), 5348 timeout=t) 5349 except Exception as e: 5350 if self.parent.shouldRetry(tries, e, deadline): 5351 tries += 1 5352 time.sleep( 5353 self.parent.exponentialBackoff(tries, deadline)) 5354 continue 5355 raise plumbing.convert_error_to_porcelain(e) from e 5356 tries = 0 5357 for plumbing_item in plumbing_response.peering_groups: 5358 yield plumbing.convert_peering_group_to_porcelain( 5359 plumbing_item) 5360 if plumbing_response.meta.next_cursor == '': 5361 break 5362 req.meta.cursor = plumbing_response.meta.next_cursor 5363 5364 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)
5217 def create(self, peering_group, timeout=None): 5218 ''' 5219 Create registers a new PeeringGroup. 5220 ''' 5221 deadline = None if timeout is None else time.time() + timeout 5222 req = PeeringGroupCreateRequest() 5223 5224 if peering_group is not None: 5225 req.peering_group.CopyFrom( 5226 plumbing.convert_peering_group_to_plumbing(peering_group)) 5227 tries = 0 5228 plumbing_response = None 5229 while True: 5230 t = None if deadline is None else deadline - time.time() 5231 try: 5232 plumbing_response = self.stub.Create( 5233 req, 5234 metadata=self.parent.get_metadata('PeeringGroups.Create', 5235 req), 5236 timeout=t) 5237 except Exception as e: 5238 if self.parent.shouldRetry(tries, e, deadline): 5239 tries += 1 5240 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5241 continue 5242 raise plumbing.convert_error_to_porcelain(e) from e 5243 break 5244 5245 resp = models.PeeringGroupCreateResponse() 5246 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5247 plumbing_response.meta) 5248 resp.peering_group = plumbing.convert_peering_group_to_porcelain( 5249 plumbing_response.peering_group) 5250 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5251 plumbing_response.rate_limit) 5252 return resp
Create registers a new PeeringGroup.
def
delete(self, id, timeout=None)
5254 def delete(self, id, timeout=None): 5255 ''' 5256 Delete removes a PeeringGroup by ID. 5257 ''' 5258 deadline = None if timeout is None else time.time() + timeout 5259 req = PeeringGroupDeleteRequest() 5260 5261 req.id = (id) 5262 tries = 0 5263 plumbing_response = None 5264 while True: 5265 t = None if deadline is None else deadline - time.time() 5266 try: 5267 plumbing_response = self.stub.Delete( 5268 req, 5269 metadata=self.parent.get_metadata('PeeringGroups.Delete', 5270 req), 5271 timeout=t) 5272 except Exception as e: 5273 if self.parent.shouldRetry(tries, e, deadline): 5274 tries += 1 5275 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5276 continue 5277 raise plumbing.convert_error_to_porcelain(e) from e 5278 break 5279 5280 resp = models.PeeringGroupDeleteResponse() 5281 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 5282 plumbing_response.meta) 5283 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5284 plumbing_response.rate_limit) 5285 return resp
Delete removes a PeeringGroup by ID.
def
get(self, id, timeout=None)
5287 def get(self, id, timeout=None): 5288 ''' 5289 Get reads one PeeringGroup by ID. It will load all its dependencies. 5290 ''' 5291 deadline = None if timeout is None else time.time() + timeout 5292 req = PeeringGroupGetRequest() 5293 if self.parent.snapshot_datetime is not None: 5294 req.meta.CopyFrom(GetRequestMetadata()) 5295 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5296 5297 req.id = (id) 5298 tries = 0 5299 plumbing_response = None 5300 while True: 5301 t = None if deadline is None else deadline - time.time() 5302 try: 5303 plumbing_response = self.stub.Get( 5304 req, 5305 metadata=self.parent.get_metadata('PeeringGroups.Get', 5306 req), 5307 timeout=t) 5308 except Exception as e: 5309 if self.parent.shouldRetry(tries, e, deadline): 5310 tries += 1 5311 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5312 continue 5313 raise plumbing.convert_error_to_porcelain(e) from e 5314 break 5315 5316 resp = models.PeeringGroupGetResponse() 5317 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5318 plumbing_response.meta) 5319 resp.peering_group = plumbing.convert_peering_group_to_porcelain( 5320 plumbing_response.peering_group) 5321 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5322 plumbing_response.rate_limit) 5323 return resp
Get reads one PeeringGroup by ID. It will load all its dependencies.
def
list(self, filter, *args, timeout=None)
5325 def list(self, filter, *args, timeout=None): 5326 ''' 5327 List gets a list of Peering Groups. 5328 ''' 5329 deadline = None if timeout is None else time.time() + timeout 5330 req = PeeringGroupListRequest() 5331 req.meta.CopyFrom(ListRequestMetadata()) 5332 if self.parent.page_limit > 0: 5333 req.meta.limit = self.parent.page_limit 5334 if self.parent.snapshot_datetime is not None: 5335 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5336 5337 req.filter = plumbing.quote_filter_args(filter, *args) 5338 5339 def generator(svc, req): 5340 tries = 0 5341 while True: 5342 t = None if deadline is None else deadline - time.time() 5343 try: 5344 plumbing_response = svc.stub.List( 5345 req, 5346 metadata=svc.parent.get_metadata( 5347 'PeeringGroups.List', req), 5348 timeout=t) 5349 except Exception as e: 5350 if self.parent.shouldRetry(tries, e, deadline): 5351 tries += 1 5352 time.sleep( 5353 self.parent.exponentialBackoff(tries, deadline)) 5354 continue 5355 raise plumbing.convert_error_to_porcelain(e) from e 5356 tries = 0 5357 for plumbing_item in plumbing_response.peering_groups: 5358 yield plumbing.convert_peering_group_to_porcelain( 5359 plumbing_item) 5360 if plumbing_response.meta.next_cursor == '': 5361 break 5362 req.meta.cursor = plumbing_response.meta.next_cursor 5363 5364 return generator(self, req)
List gets a list of Peering Groups.
class
Policies:
5367class Policies: 5368 ''' 5369 Policies are the collection of one or more statements that enforce fine-grained access 5370 control for the users of an organization. 5371 See `strongdm.models.Policy`. 5372 ''' 5373 def __init__(self, channel, client): 5374 self.parent = client 5375 self.stub = PoliciesStub(channel) 5376 5377 def create(self, policy, timeout=None): 5378 ''' 5379 Create creates a new Policy. 5380 ''' 5381 deadline = None if timeout is None else time.time() + timeout 5382 req = PolicyCreateRequest() 5383 5384 if policy is not None: 5385 req.policy.CopyFrom(plumbing.convert_policy_to_plumbing(policy)) 5386 tries = 0 5387 plumbing_response = None 5388 while True: 5389 t = None if deadline is None else deadline - time.time() 5390 try: 5391 plumbing_response = self.stub.Create( 5392 req, 5393 metadata=self.parent.get_metadata('Policies.Create', req), 5394 timeout=t) 5395 except Exception as e: 5396 if self.parent.shouldRetry(tries, e, deadline): 5397 tries += 1 5398 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5399 continue 5400 raise plumbing.convert_error_to_porcelain(e) from e 5401 break 5402 5403 resp = models.PolicyCreateResponse() 5404 resp.policy = plumbing.convert_policy_to_porcelain( 5405 plumbing_response.policy) 5406 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5407 plumbing_response.rate_limit) 5408 return resp 5409 5410 def delete(self, id, timeout=None): 5411 ''' 5412 Delete removes a Policy by ID. 5413 ''' 5414 deadline = None if timeout is None else time.time() + timeout 5415 req = PolicyDeleteRequest() 5416 5417 req.id = (id) 5418 tries = 0 5419 plumbing_response = None 5420 while True: 5421 t = None if deadline is None else deadline - time.time() 5422 try: 5423 plumbing_response = self.stub.Delete( 5424 req, 5425 metadata=self.parent.get_metadata('Policies.Delete', req), 5426 timeout=t) 5427 except Exception as e: 5428 if self.parent.shouldRetry(tries, e, deadline): 5429 tries += 1 5430 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5431 continue 5432 raise plumbing.convert_error_to_porcelain(e) from e 5433 break 5434 5435 resp = models.PolicyDeleteResponse() 5436 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5437 plumbing_response.rate_limit) 5438 return resp 5439 5440 def update(self, policy, timeout=None): 5441 ''' 5442 Update replaces all the fields of a Policy by ID. 5443 ''' 5444 deadline = None if timeout is None else time.time() + timeout 5445 req = PolicyUpdateRequest() 5446 5447 if policy is not None: 5448 req.policy.CopyFrom(plumbing.convert_policy_to_plumbing(policy)) 5449 tries = 0 5450 plumbing_response = None 5451 while True: 5452 t = None if deadline is None else deadline - time.time() 5453 try: 5454 plumbing_response = self.stub.Update( 5455 req, 5456 metadata=self.parent.get_metadata('Policies.Update', req), 5457 timeout=t) 5458 except Exception as e: 5459 if self.parent.shouldRetry(tries, e, deadline): 5460 tries += 1 5461 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5462 continue 5463 raise plumbing.convert_error_to_porcelain(e) from e 5464 break 5465 5466 resp = models.PolicyUpdateResponse() 5467 resp.policy = plumbing.convert_policy_to_porcelain( 5468 plumbing_response.policy) 5469 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5470 plumbing_response.rate_limit) 5471 return resp 5472 5473 def get(self, id, timeout=None): 5474 ''' 5475 Get reads one Policy by ID. 5476 ''' 5477 deadline = None if timeout is None else time.time() + timeout 5478 req = PolicyGetRequest() 5479 if self.parent.snapshot_datetime is not None: 5480 req.meta.CopyFrom(GetRequestMetadata()) 5481 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5482 5483 req.id = (id) 5484 tries = 0 5485 plumbing_response = None 5486 while True: 5487 t = None if deadline is None else deadline - time.time() 5488 try: 5489 plumbing_response = self.stub.Get( 5490 req, 5491 metadata=self.parent.get_metadata('Policies.Get', req), 5492 timeout=t) 5493 except Exception as e: 5494 if self.parent.shouldRetry(tries, e, deadline): 5495 tries += 1 5496 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5497 continue 5498 raise plumbing.convert_error_to_porcelain(e) from e 5499 break 5500 5501 resp = models.PolicyGetResponse() 5502 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5503 plumbing_response.meta) 5504 resp.policy = plumbing.convert_policy_to_porcelain( 5505 plumbing_response.policy) 5506 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5507 plumbing_response.rate_limit) 5508 return resp 5509 5510 def list(self, filter, *args, timeout=None): 5511 ''' 5512 List gets a list of Policy matching a given set of criteria 5513 ''' 5514 deadline = None if timeout is None else time.time() + timeout 5515 req = PolicyListRequest() 5516 req.meta.CopyFrom(ListRequestMetadata()) 5517 if self.parent.page_limit > 0: 5518 req.meta.limit = self.parent.page_limit 5519 if self.parent.snapshot_datetime is not None: 5520 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5521 5522 req.filter = plumbing.quote_filter_args(filter, *args) 5523 5524 def generator(svc, req): 5525 tries = 0 5526 while True: 5527 t = None if deadline is None else deadline - time.time() 5528 try: 5529 plumbing_response = svc.stub.List( 5530 req, 5531 metadata=svc.parent.get_metadata('Policies.List', req), 5532 timeout=t) 5533 except Exception as e: 5534 if self.parent.shouldRetry(tries, e, deadline): 5535 tries += 1 5536 time.sleep( 5537 self.parent.exponentialBackoff(tries, deadline)) 5538 continue 5539 raise plumbing.convert_error_to_porcelain(e) from e 5540 tries = 0 5541 for plumbing_item in plumbing_response.policies: 5542 yield plumbing.convert_policy_to_porcelain(plumbing_item) 5543 if plumbing_response.meta.next_cursor == '': 5544 break 5545 req.meta.cursor = plumbing_response.meta.next_cursor 5546 5547 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)
5377 def create(self, policy, timeout=None): 5378 ''' 5379 Create creates a new Policy. 5380 ''' 5381 deadline = None if timeout is None else time.time() + timeout 5382 req = PolicyCreateRequest() 5383 5384 if policy is not None: 5385 req.policy.CopyFrom(plumbing.convert_policy_to_plumbing(policy)) 5386 tries = 0 5387 plumbing_response = None 5388 while True: 5389 t = None if deadline is None else deadline - time.time() 5390 try: 5391 plumbing_response = self.stub.Create( 5392 req, 5393 metadata=self.parent.get_metadata('Policies.Create', req), 5394 timeout=t) 5395 except Exception as e: 5396 if self.parent.shouldRetry(tries, e, deadline): 5397 tries += 1 5398 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5399 continue 5400 raise plumbing.convert_error_to_porcelain(e) from e 5401 break 5402 5403 resp = models.PolicyCreateResponse() 5404 resp.policy = plumbing.convert_policy_to_porcelain( 5405 plumbing_response.policy) 5406 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5407 plumbing_response.rate_limit) 5408 return resp
Create creates a new Policy.
def
delete(self, id, timeout=None)
5410 def delete(self, id, timeout=None): 5411 ''' 5412 Delete removes a Policy by ID. 5413 ''' 5414 deadline = None if timeout is None else time.time() + timeout 5415 req = PolicyDeleteRequest() 5416 5417 req.id = (id) 5418 tries = 0 5419 plumbing_response = None 5420 while True: 5421 t = None if deadline is None else deadline - time.time() 5422 try: 5423 plumbing_response = self.stub.Delete( 5424 req, 5425 metadata=self.parent.get_metadata('Policies.Delete', req), 5426 timeout=t) 5427 except Exception as e: 5428 if self.parent.shouldRetry(tries, e, deadline): 5429 tries += 1 5430 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5431 continue 5432 raise plumbing.convert_error_to_porcelain(e) from e 5433 break 5434 5435 resp = models.PolicyDeleteResponse() 5436 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5437 plumbing_response.rate_limit) 5438 return resp
Delete removes a Policy by ID.
def
update(self, policy, timeout=None)
5440 def update(self, policy, timeout=None): 5441 ''' 5442 Update replaces all the fields of a Policy by ID. 5443 ''' 5444 deadline = None if timeout is None else time.time() + timeout 5445 req = PolicyUpdateRequest() 5446 5447 if policy is not None: 5448 req.policy.CopyFrom(plumbing.convert_policy_to_plumbing(policy)) 5449 tries = 0 5450 plumbing_response = None 5451 while True: 5452 t = None if deadline is None else deadline - time.time() 5453 try: 5454 plumbing_response = self.stub.Update( 5455 req, 5456 metadata=self.parent.get_metadata('Policies.Update', req), 5457 timeout=t) 5458 except Exception as e: 5459 if self.parent.shouldRetry(tries, e, deadline): 5460 tries += 1 5461 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5462 continue 5463 raise plumbing.convert_error_to_porcelain(e) from e 5464 break 5465 5466 resp = models.PolicyUpdateResponse() 5467 resp.policy = plumbing.convert_policy_to_porcelain( 5468 plumbing_response.policy) 5469 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5470 plumbing_response.rate_limit) 5471 return resp
Update replaces all the fields of a Policy by ID.
def
get(self, id, timeout=None)
5473 def get(self, id, timeout=None): 5474 ''' 5475 Get reads one Policy by ID. 5476 ''' 5477 deadline = None if timeout is None else time.time() + timeout 5478 req = PolicyGetRequest() 5479 if self.parent.snapshot_datetime is not None: 5480 req.meta.CopyFrom(GetRequestMetadata()) 5481 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5482 5483 req.id = (id) 5484 tries = 0 5485 plumbing_response = None 5486 while True: 5487 t = None if deadline is None else deadline - time.time() 5488 try: 5489 plumbing_response = self.stub.Get( 5490 req, 5491 metadata=self.parent.get_metadata('Policies.Get', req), 5492 timeout=t) 5493 except Exception as e: 5494 if self.parent.shouldRetry(tries, e, deadline): 5495 tries += 1 5496 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5497 continue 5498 raise plumbing.convert_error_to_porcelain(e) from e 5499 break 5500 5501 resp = models.PolicyGetResponse() 5502 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5503 plumbing_response.meta) 5504 resp.policy = plumbing.convert_policy_to_porcelain( 5505 plumbing_response.policy) 5506 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5507 plumbing_response.rate_limit) 5508 return resp
Get reads one Policy by ID.
def
list(self, filter, *args, timeout=None)
5510 def list(self, filter, *args, timeout=None): 5511 ''' 5512 List gets a list of Policy matching a given set of criteria 5513 ''' 5514 deadline = None if timeout is None else time.time() + timeout 5515 req = PolicyListRequest() 5516 req.meta.CopyFrom(ListRequestMetadata()) 5517 if self.parent.page_limit > 0: 5518 req.meta.limit = self.parent.page_limit 5519 if self.parent.snapshot_datetime is not None: 5520 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5521 5522 req.filter = plumbing.quote_filter_args(filter, *args) 5523 5524 def generator(svc, req): 5525 tries = 0 5526 while True: 5527 t = None if deadline is None else deadline - time.time() 5528 try: 5529 plumbing_response = svc.stub.List( 5530 req, 5531 metadata=svc.parent.get_metadata('Policies.List', req), 5532 timeout=t) 5533 except Exception as e: 5534 if self.parent.shouldRetry(tries, e, deadline): 5535 tries += 1 5536 time.sleep( 5537 self.parent.exponentialBackoff(tries, deadline)) 5538 continue 5539 raise plumbing.convert_error_to_porcelain(e) from e 5540 tries = 0 5541 for plumbing_item in plumbing_response.policies: 5542 yield plumbing.convert_policy_to_porcelain(plumbing_item) 5543 if plumbing_response.meta.next_cursor == '': 5544 break 5545 req.meta.cursor = plumbing_response.meta.next_cursor 5546 5547 return generator(self, req)
List gets a list of Policy matching a given set of criteria
class
SnapshotPolicies:
5550class SnapshotPolicies: 5551 ''' 5552 SnapshotPolicies exposes the read only methods of the Policies 5553 service for historical queries. 5554 ''' 5555 def __init__(self, policies): 5556 self.policies = policies 5557 5558 def get(self, id, timeout=None): 5559 ''' 5560 Get reads one Policy by ID. 5561 ''' 5562 return self.policies.get(id, timeout=timeout) 5563 5564 def list(self, filter, *args, timeout=None): 5565 ''' 5566 List gets a list of Policy matching a given set of criteria 5567 ''' 5568 return self.policies.list(filter, *args, timeout=timeout)
SnapshotPolicies exposes the read only methods of the Policies service for historical queries.
class
PoliciesHistory:
5571class PoliciesHistory: 5572 ''' 5573 PoliciesHistory records all changes to the state of a Policy. 5574 See `strongdm.models.PolicyHistory`. 5575 ''' 5576 def __init__(self, channel, client): 5577 self.parent = client 5578 self.stub = PoliciesHistoryStub(channel) 5579 5580 def list(self, filter, *args, timeout=None): 5581 ''' 5582 List gets a list of PolicyHistory records matching a given set of criteria. 5583 ''' 5584 deadline = None if timeout is None else time.time() + timeout 5585 req = PoliciesHistoryListRequest() 5586 req.meta.CopyFrom(ListRequestMetadata()) 5587 if self.parent.page_limit > 0: 5588 req.meta.limit = self.parent.page_limit 5589 if self.parent.snapshot_datetime is not None: 5590 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5591 5592 req.filter = plumbing.quote_filter_args(filter, *args) 5593 5594 def generator(svc, req): 5595 tries = 0 5596 while True: 5597 t = None if deadline is None else deadline - time.time() 5598 try: 5599 plumbing_response = svc.stub.List( 5600 req, 5601 metadata=svc.parent.get_metadata( 5602 'PoliciesHistory.List', req), 5603 timeout=t) 5604 except Exception as e: 5605 if self.parent.shouldRetry(tries, e, deadline): 5606 tries += 1 5607 time.sleep( 5608 self.parent.exponentialBackoff(tries, deadline)) 5609 continue 5610 raise plumbing.convert_error_to_porcelain(e) from e 5611 tries = 0 5612 for plumbing_item in plumbing_response.history: 5613 yield plumbing.convert_policy_history_to_porcelain( 5614 plumbing_item) 5615 if plumbing_response.meta.next_cursor == '': 5616 break 5617 req.meta.cursor = plumbing_response.meta.next_cursor 5618 5619 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)
5580 def list(self, filter, *args, timeout=None): 5581 ''' 5582 List gets a list of PolicyHistory records matching a given set of criteria. 5583 ''' 5584 deadline = None if timeout is None else time.time() + timeout 5585 req = PoliciesHistoryListRequest() 5586 req.meta.CopyFrom(ListRequestMetadata()) 5587 if self.parent.page_limit > 0: 5588 req.meta.limit = self.parent.page_limit 5589 if self.parent.snapshot_datetime is not None: 5590 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5591 5592 req.filter = plumbing.quote_filter_args(filter, *args) 5593 5594 def generator(svc, req): 5595 tries = 0 5596 while True: 5597 t = None if deadline is None else deadline - time.time() 5598 try: 5599 plumbing_response = svc.stub.List( 5600 req, 5601 metadata=svc.parent.get_metadata( 5602 'PoliciesHistory.List', req), 5603 timeout=t) 5604 except Exception as e: 5605 if self.parent.shouldRetry(tries, e, deadline): 5606 tries += 1 5607 time.sleep( 5608 self.parent.exponentialBackoff(tries, deadline)) 5609 continue 5610 raise plumbing.convert_error_to_porcelain(e) from e 5611 tries = 0 5612 for plumbing_item in plumbing_response.history: 5613 yield plumbing.convert_policy_history_to_porcelain( 5614 plumbing_item) 5615 if plumbing_response.meta.next_cursor == '': 5616 break 5617 req.meta.cursor = plumbing_response.meta.next_cursor 5618 5619 return generator(self, req)
List gets a list of PolicyHistory records matching a given set of criteria.
class
ProxyClusterKeys:
5622class ProxyClusterKeys: 5623 ''' 5624 Proxy Cluster Keys are authentication keys for all proxies within a cluster. 5625 The proxies within a cluster share the same key. One cluster can have 5626 multiple keys in order to facilitate key rotation. 5627 See `strongdm.models.ProxyClusterKey`. 5628 ''' 5629 def __init__(self, channel, client): 5630 self.parent = client 5631 self.stub = ProxyClusterKeysStub(channel) 5632 5633 def create(self, proxy_cluster_key, timeout=None): 5634 ''' 5635 Create registers a new ProxyClusterKey. 5636 ''' 5637 deadline = None if timeout is None else time.time() + timeout 5638 req = ProxyClusterKeyCreateRequest() 5639 5640 if proxy_cluster_key is not None: 5641 req.proxy_cluster_key.CopyFrom( 5642 plumbing.convert_proxy_cluster_key_to_plumbing( 5643 proxy_cluster_key)) 5644 tries = 0 5645 plumbing_response = None 5646 while True: 5647 t = None if deadline is None else deadline - time.time() 5648 try: 5649 plumbing_response = self.stub.Create( 5650 req, 5651 metadata=self.parent.get_metadata( 5652 'ProxyClusterKeys.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.ProxyClusterKeyCreateResponse() 5663 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5664 plumbing_response.meta) 5665 resp.proxy_cluster_key = plumbing.convert_proxy_cluster_key_to_porcelain( 5666 plumbing_response.proxy_cluster_key) 5667 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5668 plumbing_response.rate_limit) 5669 resp.secret_key = (plumbing_response.secret_key) 5670 return resp 5671 5672 def get(self, id, timeout=None): 5673 ''' 5674 Get reads one ProxyClusterKey by ID. 5675 ''' 5676 deadline = None if timeout is None else time.time() + timeout 5677 req = ProxyClusterKeyGetRequest() 5678 if self.parent.snapshot_datetime is not None: 5679 req.meta.CopyFrom(GetRequestMetadata()) 5680 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5681 5682 req.id = (id) 5683 tries = 0 5684 plumbing_response = None 5685 while True: 5686 t = None if deadline is None else deadline - time.time() 5687 try: 5688 plumbing_response = self.stub.Get( 5689 req, 5690 metadata=self.parent.get_metadata('ProxyClusterKeys.Get', 5691 req), 5692 timeout=t) 5693 except Exception as e: 5694 if self.parent.shouldRetry(tries, e, deadline): 5695 tries += 1 5696 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5697 continue 5698 raise plumbing.convert_error_to_porcelain(e) from e 5699 break 5700 5701 resp = models.ProxyClusterKeyGetResponse() 5702 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5703 plumbing_response.meta) 5704 resp.proxy_cluster_key = plumbing.convert_proxy_cluster_key_to_porcelain( 5705 plumbing_response.proxy_cluster_key) 5706 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5707 plumbing_response.rate_limit) 5708 return resp 5709 5710 def delete(self, id, timeout=None): 5711 ''' 5712 Delete removes a ProxyClusterKey by ID. 5713 ''' 5714 deadline = None if timeout is None else time.time() + timeout 5715 req = ProxyClusterKeyDeleteRequest() 5716 5717 req.id = (id) 5718 tries = 0 5719 plumbing_response = None 5720 while True: 5721 t = None if deadline is None else deadline - time.time() 5722 try: 5723 plumbing_response = self.stub.Delete( 5724 req, 5725 metadata=self.parent.get_metadata( 5726 'ProxyClusterKeys.Delete', req), 5727 timeout=t) 5728 except Exception as e: 5729 if self.parent.shouldRetry(tries, e, deadline): 5730 tries += 1 5731 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5732 continue 5733 raise plumbing.convert_error_to_porcelain(e) from e 5734 break 5735 5736 resp = models.ProxyClusterKeyDeleteResponse() 5737 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 5738 plumbing_response.meta) 5739 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5740 plumbing_response.rate_limit) 5741 return resp 5742 5743 def list(self, filter, *args, timeout=None): 5744 ''' 5745 List gets a list of ProxyClusterKeys matching a given set of criteria. 5746 ''' 5747 deadline = None if timeout is None else time.time() + timeout 5748 req = ProxyClusterKeyListRequest() 5749 req.meta.CopyFrom(ListRequestMetadata()) 5750 if self.parent.page_limit > 0: 5751 req.meta.limit = self.parent.page_limit 5752 if self.parent.snapshot_datetime is not None: 5753 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5754 5755 req.filter = plumbing.quote_filter_args(filter, *args) 5756 5757 def generator(svc, req): 5758 tries = 0 5759 while True: 5760 t = None if deadline is None else deadline - time.time() 5761 try: 5762 plumbing_response = svc.stub.List( 5763 req, 5764 metadata=svc.parent.get_metadata( 5765 'ProxyClusterKeys.List', req), 5766 timeout=t) 5767 except Exception as e: 5768 if self.parent.shouldRetry(tries, e, deadline): 5769 tries += 1 5770 time.sleep( 5771 self.parent.exponentialBackoff(tries, deadline)) 5772 continue 5773 raise plumbing.convert_error_to_porcelain(e) from e 5774 tries = 0 5775 for plumbing_item in plumbing_response.proxy_cluster_keys: 5776 yield plumbing.convert_proxy_cluster_key_to_porcelain( 5777 plumbing_item) 5778 if plumbing_response.meta.next_cursor == '': 5779 break 5780 req.meta.cursor = plumbing_response.meta.next_cursor 5781 5782 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)
5633 def create(self, proxy_cluster_key, timeout=None): 5634 ''' 5635 Create registers a new ProxyClusterKey. 5636 ''' 5637 deadline = None if timeout is None else time.time() + timeout 5638 req = ProxyClusterKeyCreateRequest() 5639 5640 if proxy_cluster_key is not None: 5641 req.proxy_cluster_key.CopyFrom( 5642 plumbing.convert_proxy_cluster_key_to_plumbing( 5643 proxy_cluster_key)) 5644 tries = 0 5645 plumbing_response = None 5646 while True: 5647 t = None if deadline is None else deadline - time.time() 5648 try: 5649 plumbing_response = self.stub.Create( 5650 req, 5651 metadata=self.parent.get_metadata( 5652 'ProxyClusterKeys.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.ProxyClusterKeyCreateResponse() 5663 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5664 plumbing_response.meta) 5665 resp.proxy_cluster_key = plumbing.convert_proxy_cluster_key_to_porcelain( 5666 plumbing_response.proxy_cluster_key) 5667 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5668 plumbing_response.rate_limit) 5669 resp.secret_key = (plumbing_response.secret_key) 5670 return resp
Create registers a new ProxyClusterKey.
def
get(self, id, timeout=None)
5672 def get(self, id, timeout=None): 5673 ''' 5674 Get reads one ProxyClusterKey by ID. 5675 ''' 5676 deadline = None if timeout is None else time.time() + timeout 5677 req = ProxyClusterKeyGetRequest() 5678 if self.parent.snapshot_datetime is not None: 5679 req.meta.CopyFrom(GetRequestMetadata()) 5680 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5681 5682 req.id = (id) 5683 tries = 0 5684 plumbing_response = None 5685 while True: 5686 t = None if deadline is None else deadline - time.time() 5687 try: 5688 plumbing_response = self.stub.Get( 5689 req, 5690 metadata=self.parent.get_metadata('ProxyClusterKeys.Get', 5691 req), 5692 timeout=t) 5693 except Exception as e: 5694 if self.parent.shouldRetry(tries, e, deadline): 5695 tries += 1 5696 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5697 continue 5698 raise plumbing.convert_error_to_porcelain(e) from e 5699 break 5700 5701 resp = models.ProxyClusterKeyGetResponse() 5702 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5703 plumbing_response.meta) 5704 resp.proxy_cluster_key = plumbing.convert_proxy_cluster_key_to_porcelain( 5705 plumbing_response.proxy_cluster_key) 5706 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5707 plumbing_response.rate_limit) 5708 return resp
Get reads one ProxyClusterKey by ID.
def
delete(self, id, timeout=None)
5710 def delete(self, id, timeout=None): 5711 ''' 5712 Delete removes a ProxyClusterKey by ID. 5713 ''' 5714 deadline = None if timeout is None else time.time() + timeout 5715 req = ProxyClusterKeyDeleteRequest() 5716 5717 req.id = (id) 5718 tries = 0 5719 plumbing_response = None 5720 while True: 5721 t = None if deadline is None else deadline - time.time() 5722 try: 5723 plumbing_response = self.stub.Delete( 5724 req, 5725 metadata=self.parent.get_metadata( 5726 'ProxyClusterKeys.Delete', req), 5727 timeout=t) 5728 except Exception as e: 5729 if self.parent.shouldRetry(tries, e, deadline): 5730 tries += 1 5731 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5732 continue 5733 raise plumbing.convert_error_to_porcelain(e) from e 5734 break 5735 5736 resp = models.ProxyClusterKeyDeleteResponse() 5737 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 5738 plumbing_response.meta) 5739 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5740 plumbing_response.rate_limit) 5741 return resp
Delete removes a ProxyClusterKey by ID.
def
list(self, filter, *args, timeout=None)
5743 def list(self, filter, *args, timeout=None): 5744 ''' 5745 List gets a list of ProxyClusterKeys matching a given set of criteria. 5746 ''' 5747 deadline = None if timeout is None else time.time() + timeout 5748 req = ProxyClusterKeyListRequest() 5749 req.meta.CopyFrom(ListRequestMetadata()) 5750 if self.parent.page_limit > 0: 5751 req.meta.limit = self.parent.page_limit 5752 if self.parent.snapshot_datetime is not None: 5753 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5754 5755 req.filter = plumbing.quote_filter_args(filter, *args) 5756 5757 def generator(svc, req): 5758 tries = 0 5759 while True: 5760 t = None if deadline is None else deadline - time.time() 5761 try: 5762 plumbing_response = svc.stub.List( 5763 req, 5764 metadata=svc.parent.get_metadata( 5765 'ProxyClusterKeys.List', req), 5766 timeout=t) 5767 except Exception as e: 5768 if self.parent.shouldRetry(tries, e, deadline): 5769 tries += 1 5770 time.sleep( 5771 self.parent.exponentialBackoff(tries, deadline)) 5772 continue 5773 raise plumbing.convert_error_to_porcelain(e) from e 5774 tries = 0 5775 for plumbing_item in plumbing_response.proxy_cluster_keys: 5776 yield plumbing.convert_proxy_cluster_key_to_porcelain( 5777 plumbing_item) 5778 if plumbing_response.meta.next_cursor == '': 5779 break 5780 req.meta.cursor = plumbing_response.meta.next_cursor 5781 5782 return generator(self, req)
List gets a list of ProxyClusterKeys matching a given set of criteria.
class
SnapshotProxyClusterKeys:
5785class SnapshotProxyClusterKeys: 5786 ''' 5787 SnapshotProxyClusterKeys exposes the read only methods of the ProxyClusterKeys 5788 service for historical queries. 5789 ''' 5790 def __init__(self, proxy_cluster_keys): 5791 self.proxy_cluster_keys = proxy_cluster_keys 5792 5793 def get(self, id, timeout=None): 5794 ''' 5795 Get reads one ProxyClusterKey by ID. 5796 ''' 5797 return self.proxy_cluster_keys.get(id, timeout=timeout) 5798 5799 def list(self, filter, *args, timeout=None): 5800 ''' 5801 List gets a list of ProxyClusterKeys matching a given set of criteria. 5802 ''' 5803 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)
5793 def get(self, id, timeout=None): 5794 ''' 5795 Get reads one ProxyClusterKey by ID. 5796 ''' 5797 return self.proxy_cluster_keys.get(id, timeout=timeout)
Get reads one ProxyClusterKey by ID.
def
list(self, filter, *args, timeout=None)
5799 def list(self, filter, *args, timeout=None): 5800 ''' 5801 List gets a list of ProxyClusterKeys matching a given set of criteria. 5802 ''' 5803 return self.proxy_cluster_keys.list(filter, *args, timeout=timeout)
List gets a list of ProxyClusterKeys matching a given set of criteria.
class
Queries:
5806class Queries: 5807 ''' 5808 A Query is a record of a single client request to a resource, such as a SQL query. 5809 Long-running SSH, RDP, or Kubernetes interactive sessions also count as queries. 5810 The Queries service is read-only. 5811 See `strongdm.models.Query`. 5812 ''' 5813 def __init__(self, channel, client): 5814 self.parent = client 5815 self.stub = QueriesStub(channel) 5816 5817 def list(self, filter, *args, timeout=None): 5818 ''' 5819 List gets a list of Queries matching a given set of criteria. 5820 ''' 5821 deadline = None if timeout is None else time.time() + timeout 5822 req = QueryListRequest() 5823 req.meta.CopyFrom(ListRequestMetadata()) 5824 if self.parent.page_limit > 0: 5825 req.meta.limit = self.parent.page_limit 5826 if self.parent.snapshot_datetime is not None: 5827 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5828 5829 req.filter = plumbing.quote_filter_args(filter, *args) 5830 5831 def generator(svc, req): 5832 tries = 0 5833 while True: 5834 t = None if deadline is None else deadline - time.time() 5835 try: 5836 plumbing_response = svc.stub.List( 5837 req, 5838 metadata=svc.parent.get_metadata('Queries.List', req), 5839 timeout=t) 5840 except Exception as e: 5841 if self.parent.shouldRetry(tries, e, deadline): 5842 tries += 1 5843 time.sleep( 5844 self.parent.exponentialBackoff(tries, deadline)) 5845 continue 5846 raise plumbing.convert_error_to_porcelain(e) from e 5847 tries = 0 5848 for plumbing_item in plumbing_response.queries: 5849 yield plumbing.convert_query_to_porcelain(plumbing_item) 5850 if plumbing_response.meta.next_cursor == '': 5851 break 5852 req.meta.cursor = plumbing_response.meta.next_cursor 5853 5854 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)
5817 def list(self, filter, *args, timeout=None): 5818 ''' 5819 List gets a list of Queries matching a given set of criteria. 5820 ''' 5821 deadline = None if timeout is None else time.time() + timeout 5822 req = QueryListRequest() 5823 req.meta.CopyFrom(ListRequestMetadata()) 5824 if self.parent.page_limit > 0: 5825 req.meta.limit = self.parent.page_limit 5826 if self.parent.snapshot_datetime is not None: 5827 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5828 5829 req.filter = plumbing.quote_filter_args(filter, *args) 5830 5831 def generator(svc, req): 5832 tries = 0 5833 while True: 5834 t = None if deadline is None else deadline - time.time() 5835 try: 5836 plumbing_response = svc.stub.List( 5837 req, 5838 metadata=svc.parent.get_metadata('Queries.List', req), 5839 timeout=t) 5840 except Exception as e: 5841 if self.parent.shouldRetry(tries, e, deadline): 5842 tries += 1 5843 time.sleep( 5844 self.parent.exponentialBackoff(tries, deadline)) 5845 continue 5846 raise plumbing.convert_error_to_porcelain(e) from e 5847 tries = 0 5848 for plumbing_item in plumbing_response.queries: 5849 yield plumbing.convert_query_to_porcelain(plumbing_item) 5850 if plumbing_response.meta.next_cursor == '': 5851 break 5852 req.meta.cursor = plumbing_response.meta.next_cursor 5853 5854 return generator(self, req)
List gets a list of Queries matching a given set of criteria.
class
RemoteIdentities:
5857class RemoteIdentities: 5858 ''' 5859 RemoteIdentities assign a resource directly to an account, giving the account the permission to connect to that resource. 5860 See `strongdm.models.RemoteIdentity`. 5861 ''' 5862 def __init__(self, channel, client): 5863 self.parent = client 5864 self.stub = RemoteIdentitiesStub(channel) 5865 5866 def create(self, remote_identity, timeout=None): 5867 ''' 5868 Create registers a new RemoteIdentity. 5869 ''' 5870 deadline = None if timeout is None else time.time() + timeout 5871 req = RemoteIdentityCreateRequest() 5872 5873 if remote_identity is not None: 5874 req.remote_identity.CopyFrom( 5875 plumbing.convert_remote_identity_to_plumbing(remote_identity)) 5876 tries = 0 5877 plumbing_response = None 5878 while True: 5879 t = None if deadline is None else deadline - time.time() 5880 try: 5881 plumbing_response = self.stub.Create( 5882 req, 5883 metadata=self.parent.get_metadata( 5884 'RemoteIdentities.Create', req), 5885 timeout=t) 5886 except Exception as e: 5887 if self.parent.shouldRetry(tries, e, deadline): 5888 tries += 1 5889 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5890 continue 5891 raise plumbing.convert_error_to_porcelain(e) from e 5892 break 5893 5894 resp = models.RemoteIdentityCreateResponse() 5895 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5896 plumbing_response.meta) 5897 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5898 plumbing_response.rate_limit) 5899 resp.remote_identity = plumbing.convert_remote_identity_to_porcelain( 5900 plumbing_response.remote_identity) 5901 return resp 5902 5903 def get(self, id, timeout=None): 5904 ''' 5905 Get reads one RemoteIdentity by ID. 5906 ''' 5907 deadline = None if timeout is None else time.time() + timeout 5908 req = RemoteIdentityGetRequest() 5909 if self.parent.snapshot_datetime is not None: 5910 req.meta.CopyFrom(GetRequestMetadata()) 5911 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5912 5913 req.id = (id) 5914 tries = 0 5915 plumbing_response = None 5916 while True: 5917 t = None if deadline is None else deadline - time.time() 5918 try: 5919 plumbing_response = self.stub.Get( 5920 req, 5921 metadata=self.parent.get_metadata('RemoteIdentities.Get', 5922 req), 5923 timeout=t) 5924 except Exception as e: 5925 if self.parent.shouldRetry(tries, e, deadline): 5926 tries += 1 5927 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5928 continue 5929 raise plumbing.convert_error_to_porcelain(e) from e 5930 break 5931 5932 resp = models.RemoteIdentityGetResponse() 5933 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5934 plumbing_response.meta) 5935 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5936 plumbing_response.rate_limit) 5937 resp.remote_identity = plumbing.convert_remote_identity_to_porcelain( 5938 plumbing_response.remote_identity) 5939 return resp 5940 5941 def update(self, remote_identity, timeout=None): 5942 ''' 5943 Update replaces all the fields of a RemoteIdentity by ID. 5944 ''' 5945 deadline = None if timeout is None else time.time() + timeout 5946 req = RemoteIdentityUpdateRequest() 5947 5948 if remote_identity is not None: 5949 req.remote_identity.CopyFrom( 5950 plumbing.convert_remote_identity_to_plumbing(remote_identity)) 5951 tries = 0 5952 plumbing_response = None 5953 while True: 5954 t = None if deadline is None else deadline - time.time() 5955 try: 5956 plumbing_response = self.stub.Update( 5957 req, 5958 metadata=self.parent.get_metadata( 5959 'RemoteIdentities.Update', req), 5960 timeout=t) 5961 except Exception as e: 5962 if self.parent.shouldRetry(tries, e, deadline): 5963 tries += 1 5964 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5965 continue 5966 raise plumbing.convert_error_to_porcelain(e) from e 5967 break 5968 5969 resp = models.RemoteIdentityUpdateResponse() 5970 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 5971 plumbing_response.meta) 5972 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5973 plumbing_response.rate_limit) 5974 resp.remote_identity = plumbing.convert_remote_identity_to_porcelain( 5975 plumbing_response.remote_identity) 5976 return resp 5977 5978 def delete(self, id, timeout=None): 5979 ''' 5980 Delete removes a RemoteIdentity by ID. 5981 ''' 5982 deadline = None if timeout is None else time.time() + timeout 5983 req = RemoteIdentityDeleteRequest() 5984 5985 req.id = (id) 5986 tries = 0 5987 plumbing_response = None 5988 while True: 5989 t = None if deadline is None else deadline - time.time() 5990 try: 5991 plumbing_response = self.stub.Delete( 5992 req, 5993 metadata=self.parent.get_metadata( 5994 'RemoteIdentities.Delete', req), 5995 timeout=t) 5996 except Exception as e: 5997 if self.parent.shouldRetry(tries, e, deadline): 5998 tries += 1 5999 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6000 continue 6001 raise plumbing.convert_error_to_porcelain(e) from e 6002 break 6003 6004 resp = models.RemoteIdentityDeleteResponse() 6005 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 6006 plumbing_response.meta) 6007 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6008 plumbing_response.rate_limit) 6009 return resp 6010 6011 def list(self, filter, *args, timeout=None): 6012 ''' 6013 List gets a list of RemoteIdentities matching a given set of criteria. 6014 ''' 6015 deadline = None if timeout is None else time.time() + timeout 6016 req = RemoteIdentityListRequest() 6017 req.meta.CopyFrom(ListRequestMetadata()) 6018 if self.parent.page_limit > 0: 6019 req.meta.limit = self.parent.page_limit 6020 if self.parent.snapshot_datetime is not None: 6021 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6022 6023 req.filter = plumbing.quote_filter_args(filter, *args) 6024 6025 def generator(svc, req): 6026 tries = 0 6027 while True: 6028 t = None if deadline is None else deadline - time.time() 6029 try: 6030 plumbing_response = svc.stub.List( 6031 req, 6032 metadata=svc.parent.get_metadata( 6033 'RemoteIdentities.List', req), 6034 timeout=t) 6035 except Exception as e: 6036 if self.parent.shouldRetry(tries, e, deadline): 6037 tries += 1 6038 time.sleep( 6039 self.parent.exponentialBackoff(tries, deadline)) 6040 continue 6041 raise plumbing.convert_error_to_porcelain(e) from e 6042 tries = 0 6043 for plumbing_item in plumbing_response.remote_identities: 6044 yield plumbing.convert_remote_identity_to_porcelain( 6045 plumbing_item) 6046 if plumbing_response.meta.next_cursor == '': 6047 break 6048 req.meta.cursor = plumbing_response.meta.next_cursor 6049 6050 return generator(self, req)
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)
5866 def create(self, remote_identity, timeout=None): 5867 ''' 5868 Create registers a new RemoteIdentity. 5869 ''' 5870 deadline = None if timeout is None else time.time() + timeout 5871 req = RemoteIdentityCreateRequest() 5872 5873 if remote_identity is not None: 5874 req.remote_identity.CopyFrom( 5875 plumbing.convert_remote_identity_to_plumbing(remote_identity)) 5876 tries = 0 5877 plumbing_response = None 5878 while True: 5879 t = None if deadline is None else deadline - time.time() 5880 try: 5881 plumbing_response = self.stub.Create( 5882 req, 5883 metadata=self.parent.get_metadata( 5884 'RemoteIdentities.Create', req), 5885 timeout=t) 5886 except Exception as e: 5887 if self.parent.shouldRetry(tries, e, deadline): 5888 tries += 1 5889 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5890 continue 5891 raise plumbing.convert_error_to_porcelain(e) from e 5892 break 5893 5894 resp = models.RemoteIdentityCreateResponse() 5895 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5896 plumbing_response.meta) 5897 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5898 plumbing_response.rate_limit) 5899 resp.remote_identity = plumbing.convert_remote_identity_to_porcelain( 5900 plumbing_response.remote_identity) 5901 return resp
Create registers a new RemoteIdentity.
def
get(self, id, timeout=None)
5903 def get(self, id, timeout=None): 5904 ''' 5905 Get reads one RemoteIdentity by ID. 5906 ''' 5907 deadline = None if timeout is None else time.time() + timeout 5908 req = RemoteIdentityGetRequest() 5909 if self.parent.snapshot_datetime is not None: 5910 req.meta.CopyFrom(GetRequestMetadata()) 5911 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5912 5913 req.id = (id) 5914 tries = 0 5915 plumbing_response = None 5916 while True: 5917 t = None if deadline is None else deadline - time.time() 5918 try: 5919 plumbing_response = self.stub.Get( 5920 req, 5921 metadata=self.parent.get_metadata('RemoteIdentities.Get', 5922 req), 5923 timeout=t) 5924 except Exception as e: 5925 if self.parent.shouldRetry(tries, e, deadline): 5926 tries += 1 5927 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5928 continue 5929 raise plumbing.convert_error_to_porcelain(e) from e 5930 break 5931 5932 resp = models.RemoteIdentityGetResponse() 5933 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5934 plumbing_response.meta) 5935 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5936 plumbing_response.rate_limit) 5937 resp.remote_identity = plumbing.convert_remote_identity_to_porcelain( 5938 plumbing_response.remote_identity) 5939 return resp
Get reads one RemoteIdentity by ID.
def
update(self, remote_identity, timeout=None)
5941 def update(self, remote_identity, timeout=None): 5942 ''' 5943 Update replaces all the fields of a RemoteIdentity by ID. 5944 ''' 5945 deadline = None if timeout is None else time.time() + timeout 5946 req = RemoteIdentityUpdateRequest() 5947 5948 if remote_identity is not None: 5949 req.remote_identity.CopyFrom( 5950 plumbing.convert_remote_identity_to_plumbing(remote_identity)) 5951 tries = 0 5952 plumbing_response = None 5953 while True: 5954 t = None if deadline is None else deadline - time.time() 5955 try: 5956 plumbing_response = self.stub.Update( 5957 req, 5958 metadata=self.parent.get_metadata( 5959 'RemoteIdentities.Update', req), 5960 timeout=t) 5961 except Exception as e: 5962 if self.parent.shouldRetry(tries, e, deadline): 5963 tries += 1 5964 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5965 continue 5966 raise plumbing.convert_error_to_porcelain(e) from e 5967 break 5968 5969 resp = models.RemoteIdentityUpdateResponse() 5970 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 5971 plumbing_response.meta) 5972 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5973 plumbing_response.rate_limit) 5974 resp.remote_identity = plumbing.convert_remote_identity_to_porcelain( 5975 plumbing_response.remote_identity) 5976 return resp
Update replaces all the fields of a RemoteIdentity by ID.
def
delete(self, id, timeout=None)
5978 def delete(self, id, timeout=None): 5979 ''' 5980 Delete removes a RemoteIdentity by ID. 5981 ''' 5982 deadline = None if timeout is None else time.time() + timeout 5983 req = RemoteIdentityDeleteRequest() 5984 5985 req.id = (id) 5986 tries = 0 5987 plumbing_response = None 5988 while True: 5989 t = None if deadline is None else deadline - time.time() 5990 try: 5991 plumbing_response = self.stub.Delete( 5992 req, 5993 metadata=self.parent.get_metadata( 5994 'RemoteIdentities.Delete', req), 5995 timeout=t) 5996 except Exception as e: 5997 if self.parent.shouldRetry(tries, e, deadline): 5998 tries += 1 5999 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6000 continue 6001 raise plumbing.convert_error_to_porcelain(e) from e 6002 break 6003 6004 resp = models.RemoteIdentityDeleteResponse() 6005 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 6006 plumbing_response.meta) 6007 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6008 plumbing_response.rate_limit) 6009 return resp
Delete removes a RemoteIdentity by ID.
def
list(self, filter, *args, timeout=None)
6011 def list(self, filter, *args, timeout=None): 6012 ''' 6013 List gets a list of RemoteIdentities matching a given set of criteria. 6014 ''' 6015 deadline = None if timeout is None else time.time() + timeout 6016 req = RemoteIdentityListRequest() 6017 req.meta.CopyFrom(ListRequestMetadata()) 6018 if self.parent.page_limit > 0: 6019 req.meta.limit = self.parent.page_limit 6020 if self.parent.snapshot_datetime is not None: 6021 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6022 6023 req.filter = plumbing.quote_filter_args(filter, *args) 6024 6025 def generator(svc, req): 6026 tries = 0 6027 while True: 6028 t = None if deadline is None else deadline - time.time() 6029 try: 6030 plumbing_response = svc.stub.List( 6031 req, 6032 metadata=svc.parent.get_metadata( 6033 'RemoteIdentities.List', req), 6034 timeout=t) 6035 except Exception as e: 6036 if self.parent.shouldRetry(tries, e, deadline): 6037 tries += 1 6038 time.sleep( 6039 self.parent.exponentialBackoff(tries, deadline)) 6040 continue 6041 raise plumbing.convert_error_to_porcelain(e) from e 6042 tries = 0 6043 for plumbing_item in plumbing_response.remote_identities: 6044 yield plumbing.convert_remote_identity_to_porcelain( 6045 plumbing_item) 6046 if plumbing_response.meta.next_cursor == '': 6047 break 6048 req.meta.cursor = plumbing_response.meta.next_cursor 6049 6050 return generator(self, req)
List gets a list of RemoteIdentities matching a given set of criteria.
class
SnapshotRemoteIdentities:
6053class SnapshotRemoteIdentities: 6054 ''' 6055 SnapshotRemoteIdentities exposes the read only methods of the RemoteIdentities 6056 service for historical queries. 6057 ''' 6058 def __init__(self, remote_identities): 6059 self.remote_identities = remote_identities 6060 6061 def get(self, id, timeout=None): 6062 ''' 6063 Get reads one RemoteIdentity by ID. 6064 ''' 6065 return self.remote_identities.get(id, timeout=timeout) 6066 6067 def list(self, filter, *args, timeout=None): 6068 ''' 6069 List gets a list of RemoteIdentities matching a given set of criteria. 6070 ''' 6071 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)
6061 def get(self, id, timeout=None): 6062 ''' 6063 Get reads one RemoteIdentity by ID. 6064 ''' 6065 return self.remote_identities.get(id, timeout=timeout)
Get reads one RemoteIdentity by ID.
def
list(self, filter, *args, timeout=None)
6067 def list(self, filter, *args, timeout=None): 6068 ''' 6069 List gets a list of RemoteIdentities matching a given set of criteria. 6070 ''' 6071 return self.remote_identities.list(filter, *args, timeout=timeout)
List gets a list of RemoteIdentities matching a given set of criteria.
class
RemoteIdentitiesHistory:
6074class RemoteIdentitiesHistory: 6075 ''' 6076 RemoteIdentitiesHistory records all changes to the state of a RemoteIdentity. 6077 See `strongdm.models.RemoteIdentityHistory`. 6078 ''' 6079 def __init__(self, channel, client): 6080 self.parent = client 6081 self.stub = RemoteIdentitiesHistoryStub(channel) 6082 6083 def list(self, filter, *args, timeout=None): 6084 ''' 6085 List gets a list of RemoteIdentityHistory records matching a given set of criteria. 6086 ''' 6087 deadline = None if timeout is None else time.time() + timeout 6088 req = RemoteIdentityHistoryListRequest() 6089 req.meta.CopyFrom(ListRequestMetadata()) 6090 if self.parent.page_limit > 0: 6091 req.meta.limit = self.parent.page_limit 6092 if self.parent.snapshot_datetime is not None: 6093 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6094 6095 req.filter = plumbing.quote_filter_args(filter, *args) 6096 6097 def generator(svc, req): 6098 tries = 0 6099 while True: 6100 t = None if deadline is None else deadline - time.time() 6101 try: 6102 plumbing_response = svc.stub.List( 6103 req, 6104 metadata=svc.parent.get_metadata( 6105 'RemoteIdentitiesHistory.List', req), 6106 timeout=t) 6107 except Exception as e: 6108 if self.parent.shouldRetry(tries, e, deadline): 6109 tries += 1 6110 time.sleep( 6111 self.parent.exponentialBackoff(tries, deadline)) 6112 continue 6113 raise plumbing.convert_error_to_porcelain(e) from e 6114 tries = 0 6115 for plumbing_item in plumbing_response.history: 6116 yield plumbing.convert_remote_identity_history_to_porcelain( 6117 plumbing_item) 6118 if plumbing_response.meta.next_cursor == '': 6119 break 6120 req.meta.cursor = plumbing_response.meta.next_cursor 6121 6122 return generator(self, req)
RemoteIdentitiesHistory records all changes to the state of a RemoteIdentity.
See strongdm.models.RemoteIdentityHistory.
def
list(self, filter, *args, timeout=None)
6083 def list(self, filter, *args, timeout=None): 6084 ''' 6085 List gets a list of RemoteIdentityHistory records matching a given set of criteria. 6086 ''' 6087 deadline = None if timeout is None else time.time() + timeout 6088 req = RemoteIdentityHistoryListRequest() 6089 req.meta.CopyFrom(ListRequestMetadata()) 6090 if self.parent.page_limit > 0: 6091 req.meta.limit = self.parent.page_limit 6092 if self.parent.snapshot_datetime is not None: 6093 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6094 6095 req.filter = plumbing.quote_filter_args(filter, *args) 6096 6097 def generator(svc, req): 6098 tries = 0 6099 while True: 6100 t = None if deadline is None else deadline - time.time() 6101 try: 6102 plumbing_response = svc.stub.List( 6103 req, 6104 metadata=svc.parent.get_metadata( 6105 'RemoteIdentitiesHistory.List', req), 6106 timeout=t) 6107 except Exception as e: 6108 if self.parent.shouldRetry(tries, e, deadline): 6109 tries += 1 6110 time.sleep( 6111 self.parent.exponentialBackoff(tries, deadline)) 6112 continue 6113 raise plumbing.convert_error_to_porcelain(e) from e 6114 tries = 0 6115 for plumbing_item in plumbing_response.history: 6116 yield plumbing.convert_remote_identity_history_to_porcelain( 6117 plumbing_item) 6118 if plumbing_response.meta.next_cursor == '': 6119 break 6120 req.meta.cursor = plumbing_response.meta.next_cursor 6121 6122 return generator(self, req)
List gets a list of RemoteIdentityHistory records matching a given set of criteria.
class
RemoteIdentityGroups:
6125class RemoteIdentityGroups: 6126 ''' 6127 A RemoteIdentityGroup is a named grouping of Remote Identities for Accounts. 6128 An Account's relationship to a RemoteIdentityGroup is defined via RemoteIdentity objects. 6129 See `strongdm.models.RemoteIdentityGroup`. 6130 ''' 6131 def __init__(self, channel, client): 6132 self.parent = client 6133 self.stub = RemoteIdentityGroupsStub(channel) 6134 6135 def get(self, id, timeout=None): 6136 ''' 6137 Get reads one RemoteIdentityGroup by ID. 6138 ''' 6139 deadline = None if timeout is None else time.time() + timeout 6140 req = RemoteIdentityGroupGetRequest() 6141 if self.parent.snapshot_datetime is not None: 6142 req.meta.CopyFrom(GetRequestMetadata()) 6143 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6144 6145 req.id = (id) 6146 tries = 0 6147 plumbing_response = None 6148 while True: 6149 t = None if deadline is None else deadline - time.time() 6150 try: 6151 plumbing_response = self.stub.Get( 6152 req, 6153 metadata=self.parent.get_metadata( 6154 'RemoteIdentityGroups.Get', req), 6155 timeout=t) 6156 except Exception as e: 6157 if self.parent.shouldRetry(tries, e, deadline): 6158 tries += 1 6159 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6160 continue 6161 raise plumbing.convert_error_to_porcelain(e) from e 6162 break 6163 6164 resp = models.RemoteIdentityGroupGetResponse() 6165 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 6166 plumbing_response.meta) 6167 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6168 plumbing_response.rate_limit) 6169 resp.remote_identity_group = plumbing.convert_remote_identity_group_to_porcelain( 6170 plumbing_response.remote_identity_group) 6171 return resp 6172 6173 def list(self, filter, *args, timeout=None): 6174 ''' 6175 List gets a list of RemoteIdentityGroups matching a given set of criteria. 6176 ''' 6177 deadline = None if timeout is None else time.time() + timeout 6178 req = RemoteIdentityGroupListRequest() 6179 req.meta.CopyFrom(ListRequestMetadata()) 6180 if self.parent.page_limit > 0: 6181 req.meta.limit = self.parent.page_limit 6182 if self.parent.snapshot_datetime is not None: 6183 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6184 6185 req.filter = plumbing.quote_filter_args(filter, *args) 6186 6187 def generator(svc, req): 6188 tries = 0 6189 while True: 6190 t = None if deadline is None else deadline - time.time() 6191 try: 6192 plumbing_response = svc.stub.List( 6193 req, 6194 metadata=svc.parent.get_metadata( 6195 'RemoteIdentityGroups.List', req), 6196 timeout=t) 6197 except Exception as e: 6198 if self.parent.shouldRetry(tries, e, deadline): 6199 tries += 1 6200 time.sleep( 6201 self.parent.exponentialBackoff(tries, deadline)) 6202 continue 6203 raise plumbing.convert_error_to_porcelain(e) from e 6204 tries = 0 6205 for plumbing_item in plumbing_response.remote_identity_groups: 6206 yield plumbing.convert_remote_identity_group_to_porcelain( 6207 plumbing_item) 6208 if plumbing_response.meta.next_cursor == '': 6209 break 6210 req.meta.cursor = plumbing_response.meta.next_cursor 6211 6212 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)
6135 def get(self, id, timeout=None): 6136 ''' 6137 Get reads one RemoteIdentityGroup by ID. 6138 ''' 6139 deadline = None if timeout is None else time.time() + timeout 6140 req = RemoteIdentityGroupGetRequest() 6141 if self.parent.snapshot_datetime is not None: 6142 req.meta.CopyFrom(GetRequestMetadata()) 6143 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6144 6145 req.id = (id) 6146 tries = 0 6147 plumbing_response = None 6148 while True: 6149 t = None if deadline is None else deadline - time.time() 6150 try: 6151 plumbing_response = self.stub.Get( 6152 req, 6153 metadata=self.parent.get_metadata( 6154 'RemoteIdentityGroups.Get', req), 6155 timeout=t) 6156 except Exception as e: 6157 if self.parent.shouldRetry(tries, e, deadline): 6158 tries += 1 6159 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6160 continue 6161 raise plumbing.convert_error_to_porcelain(e) from e 6162 break 6163 6164 resp = models.RemoteIdentityGroupGetResponse() 6165 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 6166 plumbing_response.meta) 6167 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6168 plumbing_response.rate_limit) 6169 resp.remote_identity_group = plumbing.convert_remote_identity_group_to_porcelain( 6170 plumbing_response.remote_identity_group) 6171 return resp
Get reads one RemoteIdentityGroup by ID.
def
list(self, filter, *args, timeout=None)
6173 def list(self, filter, *args, timeout=None): 6174 ''' 6175 List gets a list of RemoteIdentityGroups matching a given set of criteria. 6176 ''' 6177 deadline = None if timeout is None else time.time() + timeout 6178 req = RemoteIdentityGroupListRequest() 6179 req.meta.CopyFrom(ListRequestMetadata()) 6180 if self.parent.page_limit > 0: 6181 req.meta.limit = self.parent.page_limit 6182 if self.parent.snapshot_datetime is not None: 6183 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6184 6185 req.filter = plumbing.quote_filter_args(filter, *args) 6186 6187 def generator(svc, req): 6188 tries = 0 6189 while True: 6190 t = None if deadline is None else deadline - time.time() 6191 try: 6192 plumbing_response = svc.stub.List( 6193 req, 6194 metadata=svc.parent.get_metadata( 6195 'RemoteIdentityGroups.List', req), 6196 timeout=t) 6197 except Exception as e: 6198 if self.parent.shouldRetry(tries, e, deadline): 6199 tries += 1 6200 time.sleep( 6201 self.parent.exponentialBackoff(tries, deadline)) 6202 continue 6203 raise plumbing.convert_error_to_porcelain(e) from e 6204 tries = 0 6205 for plumbing_item in plumbing_response.remote_identity_groups: 6206 yield plumbing.convert_remote_identity_group_to_porcelain( 6207 plumbing_item) 6208 if plumbing_response.meta.next_cursor == '': 6209 break 6210 req.meta.cursor = plumbing_response.meta.next_cursor 6211 6212 return generator(self, req)
List gets a list of RemoteIdentityGroups matching a given set of criteria.
class
SnapshotRemoteIdentityGroups:
6215class SnapshotRemoteIdentityGroups: 6216 ''' 6217 SnapshotRemoteIdentityGroups exposes the read only methods of the RemoteIdentityGroups 6218 service for historical queries. 6219 ''' 6220 def __init__(self, remote_identity_groups): 6221 self.remote_identity_groups = remote_identity_groups 6222 6223 def get(self, id, timeout=None): 6224 ''' 6225 Get reads one RemoteIdentityGroup by ID. 6226 ''' 6227 return self.remote_identity_groups.get(id, timeout=timeout) 6228 6229 def list(self, filter, *args, timeout=None): 6230 ''' 6231 List gets a list of RemoteIdentityGroups matching a given set of criteria. 6232 ''' 6233 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)
6223 def get(self, id, timeout=None): 6224 ''' 6225 Get reads one RemoteIdentityGroup by ID. 6226 ''' 6227 return self.remote_identity_groups.get(id, timeout=timeout)
Get reads one RemoteIdentityGroup by ID.
def
list(self, filter, *args, timeout=None)
6229 def list(self, filter, *args, timeout=None): 6230 ''' 6231 List gets a list of RemoteIdentityGroups matching a given set of criteria. 6232 ''' 6233 return self.remote_identity_groups.list(filter, *args, timeout=timeout)
List gets a list of RemoteIdentityGroups matching a given set of criteria.
class
RemoteIdentityGroupsHistory:
6236class RemoteIdentityGroupsHistory: 6237 ''' 6238 RemoteIdentityGroupsHistory records all changes to the state of a RemoteIdentityGroup. 6239 See `strongdm.models.RemoteIdentityGroupHistory`. 6240 ''' 6241 def __init__(self, channel, client): 6242 self.parent = client 6243 self.stub = RemoteIdentityGroupsHistoryStub(channel) 6244 6245 def list(self, filter, *args, timeout=None): 6246 ''' 6247 List gets a list of RemoteIdentityGroupHistory records matching a given set of criteria. 6248 ''' 6249 deadline = None if timeout is None else time.time() + timeout 6250 req = RemoteIdentityGroupHistoryListRequest() 6251 req.meta.CopyFrom(ListRequestMetadata()) 6252 if self.parent.page_limit > 0: 6253 req.meta.limit = self.parent.page_limit 6254 if self.parent.snapshot_datetime is not None: 6255 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6256 6257 req.filter = plumbing.quote_filter_args(filter, *args) 6258 6259 def generator(svc, req): 6260 tries = 0 6261 while True: 6262 t = None if deadline is None else deadline - time.time() 6263 try: 6264 plumbing_response = svc.stub.List( 6265 req, 6266 metadata=svc.parent.get_metadata( 6267 'RemoteIdentityGroupsHistory.List', req), 6268 timeout=t) 6269 except Exception as e: 6270 if self.parent.shouldRetry(tries, e, deadline): 6271 tries += 1 6272 time.sleep( 6273 self.parent.exponentialBackoff(tries, deadline)) 6274 continue 6275 raise plumbing.convert_error_to_porcelain(e) from e 6276 tries = 0 6277 for plumbing_item in plumbing_response.history: 6278 yield plumbing.convert_remote_identity_group_history_to_porcelain( 6279 plumbing_item) 6280 if plumbing_response.meta.next_cursor == '': 6281 break 6282 req.meta.cursor = plumbing_response.meta.next_cursor 6283 6284 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)
6245 def list(self, filter, *args, timeout=None): 6246 ''' 6247 List gets a list of RemoteIdentityGroupHistory records matching a given set of criteria. 6248 ''' 6249 deadline = None if timeout is None else time.time() + timeout 6250 req = RemoteIdentityGroupHistoryListRequest() 6251 req.meta.CopyFrom(ListRequestMetadata()) 6252 if self.parent.page_limit > 0: 6253 req.meta.limit = self.parent.page_limit 6254 if self.parent.snapshot_datetime is not None: 6255 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6256 6257 req.filter = plumbing.quote_filter_args(filter, *args) 6258 6259 def generator(svc, req): 6260 tries = 0 6261 while True: 6262 t = None if deadline is None else deadline - time.time() 6263 try: 6264 plumbing_response = svc.stub.List( 6265 req, 6266 metadata=svc.parent.get_metadata( 6267 'RemoteIdentityGroupsHistory.List', req), 6268 timeout=t) 6269 except Exception as e: 6270 if self.parent.shouldRetry(tries, e, deadline): 6271 tries += 1 6272 time.sleep( 6273 self.parent.exponentialBackoff(tries, deadline)) 6274 continue 6275 raise plumbing.convert_error_to_porcelain(e) from e 6276 tries = 0 6277 for plumbing_item in plumbing_response.history: 6278 yield plumbing.convert_remote_identity_group_history_to_porcelain( 6279 plumbing_item) 6280 if plumbing_response.meta.next_cursor == '': 6281 break 6282 req.meta.cursor = plumbing_response.meta.next_cursor 6283 6284 return generator(self, req)
List gets a list of RemoteIdentityGroupHistory records matching a given set of criteria.
class
Replays:
6287class Replays: 6288 ''' 6289 A Replay captures the data transferred over a long-running SSH, RDP, or Kubernetes interactive session 6290 (otherwise referred to as a query). The Replays service is read-only. 6291 See `strongdm.models.ReplayChunk`. 6292 ''' 6293 def __init__(self, channel, client): 6294 self.parent = client 6295 self.stub = ReplaysStub(channel) 6296 6297 def list(self, filter, *args, timeout=None): 6298 ''' 6299 List gets a list of ReplayChunks for the Query ID specified by the filter criteria. 6300 ''' 6301 deadline = None if timeout is None else time.time() + timeout 6302 req = ReplayListRequest() 6303 req.meta.CopyFrom(ListRequestMetadata()) 6304 if self.parent.page_limit > 0: 6305 req.meta.limit = self.parent.page_limit 6306 if self.parent.snapshot_datetime is not None: 6307 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6308 6309 req.filter = plumbing.quote_filter_args(filter, *args) 6310 6311 def generator(svc, req): 6312 tries = 0 6313 while True: 6314 t = None if deadline is None else deadline - time.time() 6315 try: 6316 plumbing_response = svc.stub.List( 6317 req, 6318 metadata=svc.parent.get_metadata('Replays.List', req), 6319 timeout=t) 6320 except Exception as e: 6321 if self.parent.shouldRetry(tries, e, deadline): 6322 tries += 1 6323 time.sleep( 6324 self.parent.exponentialBackoff(tries, deadline)) 6325 continue 6326 raise plumbing.convert_error_to_porcelain(e) from e 6327 tries = 0 6328 for plumbing_item in plumbing_response.chunks: 6329 yield plumbing.convert_replay_chunk_to_porcelain( 6330 plumbing_item) 6331 if plumbing_response.meta.next_cursor == '': 6332 break 6333 req.meta.cursor = plumbing_response.meta.next_cursor 6334 6335 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)
6297 def list(self, filter, *args, timeout=None): 6298 ''' 6299 List gets a list of ReplayChunks for the Query ID specified by the filter criteria. 6300 ''' 6301 deadline = None if timeout is None else time.time() + timeout 6302 req = ReplayListRequest() 6303 req.meta.CopyFrom(ListRequestMetadata()) 6304 if self.parent.page_limit > 0: 6305 req.meta.limit = self.parent.page_limit 6306 if self.parent.snapshot_datetime is not None: 6307 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6308 6309 req.filter = plumbing.quote_filter_args(filter, *args) 6310 6311 def generator(svc, req): 6312 tries = 0 6313 while True: 6314 t = None if deadline is None else deadline - time.time() 6315 try: 6316 plumbing_response = svc.stub.List( 6317 req, 6318 metadata=svc.parent.get_metadata('Replays.List', req), 6319 timeout=t) 6320 except Exception as e: 6321 if self.parent.shouldRetry(tries, e, deadline): 6322 tries += 1 6323 time.sleep( 6324 self.parent.exponentialBackoff(tries, deadline)) 6325 continue 6326 raise plumbing.convert_error_to_porcelain(e) from e 6327 tries = 0 6328 for plumbing_item in plumbing_response.chunks: 6329 yield plumbing.convert_replay_chunk_to_porcelain( 6330 plumbing_item) 6331 if plumbing_response.meta.next_cursor == '': 6332 break 6333 req.meta.cursor = plumbing_response.meta.next_cursor 6334 6335 return generator(self, req)
List gets a list of ReplayChunks for the Query ID specified by the filter criteria.
class
Resources:
6338class Resources: 6339 ''' 6340 Resources are databases, servers, clusters, websites, or clouds that strongDM 6341 delegates access to. 6342 See: 6343 `strongdm.models.Aerospike` 6344 `strongdm.models.AKS` 6345 `strongdm.models.AKSBasicAuth` 6346 `strongdm.models.AKSServiceAccount` 6347 `strongdm.models.AKSServiceAccountUserImpersonation` 6348 `strongdm.models.AKSUserImpersonation` 6349 `strongdm.models.AmazonEKS` 6350 `strongdm.models.AmazonEKSInstanceProfile` 6351 `strongdm.models.AmazonEKSInstanceProfileUserImpersonation` 6352 `strongdm.models.AmazonEKSUserImpersonation` 6353 `strongdm.models.AmazonES` 6354 `strongdm.models.AmazonESIAM` 6355 `strongdm.models.AmazonMQAMQP091` 6356 `strongdm.models.AMQP` 6357 `strongdm.models.Athena` 6358 `strongdm.models.AthenaIAM` 6359 `strongdm.models.AuroraMysql` 6360 `strongdm.models.AuroraMysqlIAM` 6361 `strongdm.models.AuroraPostgres` 6362 `strongdm.models.AuroraPostgresIAM` 6363 `strongdm.models.AWS` 6364 `strongdm.models.AWSConsole` 6365 `strongdm.models.AWSConsoleStaticKeyPair` 6366 `strongdm.models.AWSInstanceProfile` 6367 `strongdm.models.Azure` 6368 `strongdm.models.AzureCertificate` 6369 `strongdm.models.AzureMysql` 6370 `strongdm.models.AzureMysqlManagedIdentity` 6371 `strongdm.models.AzurePostgres` 6372 `strongdm.models.AzurePostgresManagedIdentity` 6373 `strongdm.models.BigQuery` 6374 `strongdm.models.Cassandra` 6375 `strongdm.models.Citus` 6376 `strongdm.models.ClickHouseHTTP` 6377 `strongdm.models.ClickHouseMySQL` 6378 `strongdm.models.ClickHouseTCP` 6379 `strongdm.models.Clustrix` 6380 `strongdm.models.Cockroach` 6381 `strongdm.models.CouchbaseDatabase` 6382 `strongdm.models.CouchbaseWebUI` 6383 `strongdm.models.DB2I` 6384 `strongdm.models.DB2LUW` 6385 `strongdm.models.DocumentDBHost` 6386 `strongdm.models.DocumentDBHostIAM` 6387 `strongdm.models.DocumentDBReplicaSet` 6388 `strongdm.models.DocumentDBReplicaSetIAM` 6389 `strongdm.models.Druid` 6390 `strongdm.models.DynamoDB` 6391 `strongdm.models.DynamoDBIAM` 6392 `strongdm.models.Elastic` 6393 `strongdm.models.ElasticacheRedis` 6394 `strongdm.models.ElasticacheRedisIAM` 6395 `strongdm.models.EntraID` 6396 `strongdm.models.GCP` 6397 `strongdm.models.GCPConsole` 6398 `strongdm.models.GCPWIF` 6399 `strongdm.models.GoogleGKE` 6400 `strongdm.models.GoogleGKEUserImpersonation` 6401 `strongdm.models.GoogleSpanner` 6402 `strongdm.models.Greenplum` 6403 `strongdm.models.HTTPAuth` 6404 `strongdm.models.HTTPBasicAuth` 6405 `strongdm.models.HTTPNoAuth` 6406 `strongdm.models.Kubernetes` 6407 `strongdm.models.KubernetesBasicAuth` 6408 `strongdm.models.KubernetesPodIdentity` 6409 `strongdm.models.KubernetesServiceAccount` 6410 `strongdm.models.KubernetesServiceAccountUserImpersonation` 6411 `strongdm.models.KubernetesUserImpersonation` 6412 `strongdm.models.Maria` 6413 `strongdm.models.MCP` 6414 `strongdm.models.Memcached` 6415 `strongdm.models.Memsql` 6416 `strongdm.models.MongoHost` 6417 `strongdm.models.MongoLegacyHost` 6418 `strongdm.models.MongoLegacyReplicaset` 6419 `strongdm.models.MongoReplicaSet` 6420 `strongdm.models.MongoShardedCluster` 6421 `strongdm.models.MTLSMysql` 6422 `strongdm.models.MTLSPostgres` 6423 `strongdm.models.Mysql` 6424 `strongdm.models.Neptune` 6425 `strongdm.models.NeptuneIAM` 6426 `strongdm.models.OktaGroups` 6427 `strongdm.models.Oracle` 6428 `strongdm.models.OracleNNE` 6429 `strongdm.models.Postgres` 6430 `strongdm.models.Presto` 6431 `strongdm.models.RabbitMQAMQP091` 6432 `strongdm.models.RawTCP` 6433 `strongdm.models.RDP` 6434 `strongdm.models.RDPCert` 6435 `strongdm.models.RDSPostgresIAM` 6436 `strongdm.models.Redis` 6437 `strongdm.models.RedisCluster` 6438 `strongdm.models.Redshift` 6439 `strongdm.models.RedshiftIAM` 6440 `strongdm.models.RedshiftServerlessIAM` 6441 `strongdm.models.SingleStore` 6442 `strongdm.models.Snowflake` 6443 `strongdm.models.Snowsight` 6444 `strongdm.models.SQLServer` 6445 `strongdm.models.SQLServerAzureAD` 6446 `strongdm.models.SQLServerKerberosAD` 6447 `strongdm.models.SSH` 6448 `strongdm.models.SSHCert` 6449 `strongdm.models.SSHCustomerKey` 6450 `strongdm.models.SSHPassword` 6451 `strongdm.models.Sybase` 6452 `strongdm.models.SybaseIQ` 6453 `strongdm.models.Teradata` 6454 `strongdm.models.Trino` 6455 `strongdm.models.Vertica` 6456 ''' 6457 def __init__(self, channel, client): 6458 self.parent = client 6459 self.stub = ResourcesStub(channel) 6460 6461 def enumerate_tags(self, filter, *args, timeout=None): 6462 ''' 6463 EnumerateTags gets a list of the filter matching tags. 6464 ''' 6465 deadline = None if timeout is None else time.time() + timeout 6466 req = EnumerateTagsRequest() 6467 req.meta.CopyFrom(ListRequestMetadata()) 6468 if self.parent.page_limit > 0: 6469 req.meta.limit = self.parent.page_limit 6470 if self.parent.snapshot_datetime is not None: 6471 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6472 6473 req.filter = plumbing.quote_filter_args(filter, *args) 6474 6475 def generator(svc, req): 6476 tries = 0 6477 while True: 6478 t = None if deadline is None else deadline - time.time() 6479 try: 6480 plumbing_response = svc.stub.EnumerateTags( 6481 req, 6482 metadata=svc.parent.get_metadata( 6483 'Resources.EnumerateTags', req), 6484 timeout=t) 6485 except Exception as e: 6486 if self.parent.shouldRetry(tries, e, deadline): 6487 tries += 1 6488 time.sleep( 6489 self.parent.exponentialBackoff(tries, deadline)) 6490 continue 6491 raise plumbing.convert_error_to_porcelain(e) from e 6492 tries = 0 6493 for plumbing_item in plumbing_response.matches: 6494 yield plumbing.convert_tag_to_porcelain(plumbing_item) 6495 if plumbing_response.meta.next_cursor == '': 6496 break 6497 req.meta.cursor = plumbing_response.meta.next_cursor 6498 6499 return generator(self, req) 6500 6501 def create(self, resource, timeout=None): 6502 ''' 6503 Create registers a new Resource. 6504 ''' 6505 deadline = None if timeout is None else time.time() + timeout 6506 req = ResourceCreateRequest() 6507 6508 if resource is not None: 6509 req.resource.CopyFrom( 6510 plumbing.convert_resource_to_plumbing(resource)) 6511 tries = 0 6512 plumbing_response = None 6513 while True: 6514 t = None if deadline is None else deadline - time.time() 6515 try: 6516 plumbing_response = self.stub.Create( 6517 req, 6518 metadata=self.parent.get_metadata('Resources.Create', req), 6519 timeout=t) 6520 except Exception as e: 6521 if self.parent.shouldRetry(tries, e, deadline): 6522 tries += 1 6523 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6524 continue 6525 raise plumbing.convert_error_to_porcelain(e) from e 6526 break 6527 6528 resp = models.ResourceCreateResponse() 6529 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 6530 plumbing_response.meta) 6531 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6532 plumbing_response.rate_limit) 6533 resp.resource = plumbing.convert_resource_to_porcelain( 6534 plumbing_response.resource) 6535 return resp 6536 6537 def get(self, id, timeout=None): 6538 ''' 6539 Get reads one Resource by ID. 6540 ''' 6541 deadline = None if timeout is None else time.time() + timeout 6542 req = ResourceGetRequest() 6543 if self.parent.snapshot_datetime is not None: 6544 req.meta.CopyFrom(GetRequestMetadata()) 6545 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6546 6547 req.id = (id) 6548 tries = 0 6549 plumbing_response = None 6550 while True: 6551 t = None if deadline is None else deadline - time.time() 6552 try: 6553 plumbing_response = self.stub.Get( 6554 req, 6555 metadata=self.parent.get_metadata('Resources.Get', req), 6556 timeout=t) 6557 except Exception as e: 6558 if self.parent.shouldRetry(tries, e, deadline): 6559 tries += 1 6560 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6561 continue 6562 raise plumbing.convert_error_to_porcelain(e) from e 6563 break 6564 6565 resp = models.ResourceGetResponse() 6566 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 6567 plumbing_response.meta) 6568 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6569 plumbing_response.rate_limit) 6570 resp.resource = plumbing.convert_resource_to_porcelain( 6571 plumbing_response.resource) 6572 return resp 6573 6574 def update(self, resource, timeout=None): 6575 ''' 6576 Update replaces all the fields of a Resource by ID. 6577 ''' 6578 deadline = None if timeout is None else time.time() + timeout 6579 req = ResourceUpdateRequest() 6580 6581 if resource is not None: 6582 req.resource.CopyFrom( 6583 plumbing.convert_resource_to_plumbing(resource)) 6584 tries = 0 6585 plumbing_response = None 6586 while True: 6587 t = None if deadline is None else deadline - time.time() 6588 try: 6589 plumbing_response = self.stub.Update( 6590 req, 6591 metadata=self.parent.get_metadata('Resources.Update', req), 6592 timeout=t) 6593 except Exception as e: 6594 if self.parent.shouldRetry(tries, e, deadline): 6595 tries += 1 6596 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6597 continue 6598 raise plumbing.convert_error_to_porcelain(e) from e 6599 break 6600 6601 resp = models.ResourceUpdateResponse() 6602 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 6603 plumbing_response.meta) 6604 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6605 plumbing_response.rate_limit) 6606 resp.resource = plumbing.convert_resource_to_porcelain( 6607 plumbing_response.resource) 6608 return resp 6609 6610 def delete(self, id, timeout=None): 6611 ''' 6612 Delete removes a Resource by ID. 6613 ''' 6614 deadline = None if timeout is None else time.time() + timeout 6615 req = ResourceDeleteRequest() 6616 6617 req.id = (id) 6618 tries = 0 6619 plumbing_response = None 6620 while True: 6621 t = None if deadline is None else deadline - time.time() 6622 try: 6623 plumbing_response = self.stub.Delete( 6624 req, 6625 metadata=self.parent.get_metadata('Resources.Delete', req), 6626 timeout=t) 6627 except Exception as e: 6628 if self.parent.shouldRetry(tries, e, deadline): 6629 tries += 1 6630 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6631 continue 6632 raise plumbing.convert_error_to_porcelain(e) from e 6633 break 6634 6635 resp = models.ResourceDeleteResponse() 6636 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 6637 plumbing_response.meta) 6638 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6639 plumbing_response.rate_limit) 6640 return resp 6641 6642 def list(self, filter, *args, timeout=None): 6643 ''' 6644 List gets a list of Resources matching a given set of criteria. 6645 ''' 6646 deadline = None if timeout is None else time.time() + timeout 6647 req = ResourceListRequest() 6648 req.meta.CopyFrom(ListRequestMetadata()) 6649 if self.parent.page_limit > 0: 6650 req.meta.limit = self.parent.page_limit 6651 if self.parent.snapshot_datetime is not None: 6652 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6653 6654 req.filter = plumbing.quote_filter_args(filter, *args) 6655 6656 def generator(svc, req): 6657 tries = 0 6658 while True: 6659 t = None if deadline is None else deadline - time.time() 6660 try: 6661 plumbing_response = svc.stub.List( 6662 req, 6663 metadata=svc.parent.get_metadata( 6664 'Resources.List', req), 6665 timeout=t) 6666 except Exception as e: 6667 if self.parent.shouldRetry(tries, e, deadline): 6668 tries += 1 6669 time.sleep( 6670 self.parent.exponentialBackoff(tries, deadline)) 6671 continue 6672 raise plumbing.convert_error_to_porcelain(e) from e 6673 tries = 0 6674 for plumbing_item in plumbing_response.resources: 6675 yield plumbing.convert_resource_to_porcelain(plumbing_item) 6676 if plumbing_response.meta.next_cursor == '': 6677 break 6678 req.meta.cursor = plumbing_response.meta.next_cursor 6679 6680 return generator(self, req) 6681 6682 def healthcheck(self, id, timeout=None): 6683 ''' 6684 Healthcheck triggers a remote healthcheck. It may take minutes to propagate across a 6685 large network of Nodes. The call will return immediately, and the updated health of the 6686 Resource can be retrieved via Get or List. 6687 ''' 6688 deadline = None if timeout is None else time.time() + timeout 6689 req = ResourceHealthcheckRequest() 6690 6691 req.id = (id) 6692 tries = 0 6693 plumbing_response = None 6694 while True: 6695 t = None if deadline is None else deadline - time.time() 6696 try: 6697 plumbing_response = self.stub.Healthcheck( 6698 req, 6699 metadata=self.parent.get_metadata('Resources.Healthcheck', 6700 req), 6701 timeout=t) 6702 except Exception as e: 6703 if self.parent.shouldRetry(tries, e, deadline): 6704 tries += 1 6705 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6706 continue 6707 raise plumbing.convert_error_to_porcelain(e) from e 6708 break 6709 6710 resp = models.ResourceHealthcheckResponse() 6711 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 6712 plumbing_response.meta) 6713 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6714 plumbing_response.rate_limit) 6715 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.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.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)
6501 def create(self, resource, timeout=None): 6502 ''' 6503 Create registers a new Resource. 6504 ''' 6505 deadline = None if timeout is None else time.time() + timeout 6506 req = ResourceCreateRequest() 6507 6508 if resource is not None: 6509 req.resource.CopyFrom( 6510 plumbing.convert_resource_to_plumbing(resource)) 6511 tries = 0 6512 plumbing_response = None 6513 while True: 6514 t = None if deadline is None else deadline - time.time() 6515 try: 6516 plumbing_response = self.stub.Create( 6517 req, 6518 metadata=self.parent.get_metadata('Resources.Create', req), 6519 timeout=t) 6520 except Exception as e: 6521 if self.parent.shouldRetry(tries, e, deadline): 6522 tries += 1 6523 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6524 continue 6525 raise plumbing.convert_error_to_porcelain(e) from e 6526 break 6527 6528 resp = models.ResourceCreateResponse() 6529 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 6530 plumbing_response.meta) 6531 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6532 plumbing_response.rate_limit) 6533 resp.resource = plumbing.convert_resource_to_porcelain( 6534 plumbing_response.resource) 6535 return resp
Create registers a new Resource.
def
get(self, id, timeout=None)
6537 def get(self, id, timeout=None): 6538 ''' 6539 Get reads one Resource by ID. 6540 ''' 6541 deadline = None if timeout is None else time.time() + timeout 6542 req = ResourceGetRequest() 6543 if self.parent.snapshot_datetime is not None: 6544 req.meta.CopyFrom(GetRequestMetadata()) 6545 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6546 6547 req.id = (id) 6548 tries = 0 6549 plumbing_response = None 6550 while True: 6551 t = None if deadline is None else deadline - time.time() 6552 try: 6553 plumbing_response = self.stub.Get( 6554 req, 6555 metadata=self.parent.get_metadata('Resources.Get', req), 6556 timeout=t) 6557 except Exception as e: 6558 if self.parent.shouldRetry(tries, e, deadline): 6559 tries += 1 6560 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6561 continue 6562 raise plumbing.convert_error_to_porcelain(e) from e 6563 break 6564 6565 resp = models.ResourceGetResponse() 6566 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 6567 plumbing_response.meta) 6568 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6569 plumbing_response.rate_limit) 6570 resp.resource = plumbing.convert_resource_to_porcelain( 6571 plumbing_response.resource) 6572 return resp
Get reads one Resource by ID.
def
update(self, resource, timeout=None)
6574 def update(self, resource, timeout=None): 6575 ''' 6576 Update replaces all the fields of a Resource by ID. 6577 ''' 6578 deadline = None if timeout is None else time.time() + timeout 6579 req = ResourceUpdateRequest() 6580 6581 if resource is not None: 6582 req.resource.CopyFrom( 6583 plumbing.convert_resource_to_plumbing(resource)) 6584 tries = 0 6585 plumbing_response = None 6586 while True: 6587 t = None if deadline is None else deadline - time.time() 6588 try: 6589 plumbing_response = self.stub.Update( 6590 req, 6591 metadata=self.parent.get_metadata('Resources.Update', req), 6592 timeout=t) 6593 except Exception as e: 6594 if self.parent.shouldRetry(tries, e, deadline): 6595 tries += 1 6596 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6597 continue 6598 raise plumbing.convert_error_to_porcelain(e) from e 6599 break 6600 6601 resp = models.ResourceUpdateResponse() 6602 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 6603 plumbing_response.meta) 6604 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6605 plumbing_response.rate_limit) 6606 resp.resource = plumbing.convert_resource_to_porcelain( 6607 plumbing_response.resource) 6608 return resp
Update replaces all the fields of a Resource by ID.
def
delete(self, id, timeout=None)
6610 def delete(self, id, timeout=None): 6611 ''' 6612 Delete removes a Resource by ID. 6613 ''' 6614 deadline = None if timeout is None else time.time() + timeout 6615 req = ResourceDeleteRequest() 6616 6617 req.id = (id) 6618 tries = 0 6619 plumbing_response = None 6620 while True: 6621 t = None if deadline is None else deadline - time.time() 6622 try: 6623 plumbing_response = self.stub.Delete( 6624 req, 6625 metadata=self.parent.get_metadata('Resources.Delete', req), 6626 timeout=t) 6627 except Exception as e: 6628 if self.parent.shouldRetry(tries, e, deadline): 6629 tries += 1 6630 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6631 continue 6632 raise plumbing.convert_error_to_porcelain(e) from e 6633 break 6634 6635 resp = models.ResourceDeleteResponse() 6636 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 6637 plumbing_response.meta) 6638 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6639 plumbing_response.rate_limit) 6640 return resp
Delete removes a Resource by ID.
def
list(self, filter, *args, timeout=None)
6642 def list(self, filter, *args, timeout=None): 6643 ''' 6644 List gets a list of Resources matching a given set of criteria. 6645 ''' 6646 deadline = None if timeout is None else time.time() + timeout 6647 req = ResourceListRequest() 6648 req.meta.CopyFrom(ListRequestMetadata()) 6649 if self.parent.page_limit > 0: 6650 req.meta.limit = self.parent.page_limit 6651 if self.parent.snapshot_datetime is not None: 6652 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6653 6654 req.filter = plumbing.quote_filter_args(filter, *args) 6655 6656 def generator(svc, req): 6657 tries = 0 6658 while True: 6659 t = None if deadline is None else deadline - time.time() 6660 try: 6661 plumbing_response = svc.stub.List( 6662 req, 6663 metadata=svc.parent.get_metadata( 6664 'Resources.List', req), 6665 timeout=t) 6666 except Exception as e: 6667 if self.parent.shouldRetry(tries, e, deadline): 6668 tries += 1 6669 time.sleep( 6670 self.parent.exponentialBackoff(tries, deadline)) 6671 continue 6672 raise plumbing.convert_error_to_porcelain(e) from e 6673 tries = 0 6674 for plumbing_item in plumbing_response.resources: 6675 yield plumbing.convert_resource_to_porcelain(plumbing_item) 6676 if plumbing_response.meta.next_cursor == '': 6677 break 6678 req.meta.cursor = plumbing_response.meta.next_cursor 6679 6680 return generator(self, req)
List gets a list of Resources matching a given set of criteria.
def
healthcheck(self, id, timeout=None)
6682 def healthcheck(self, id, timeout=None): 6683 ''' 6684 Healthcheck triggers a remote healthcheck. It may take minutes to propagate across a 6685 large network of Nodes. The call will return immediately, and the updated health of the 6686 Resource can be retrieved via Get or List. 6687 ''' 6688 deadline = None if timeout is None else time.time() + timeout 6689 req = ResourceHealthcheckRequest() 6690 6691 req.id = (id) 6692 tries = 0 6693 plumbing_response = None 6694 while True: 6695 t = None if deadline is None else deadline - time.time() 6696 try: 6697 plumbing_response = self.stub.Healthcheck( 6698 req, 6699 metadata=self.parent.get_metadata('Resources.Healthcheck', 6700 req), 6701 timeout=t) 6702 except Exception as e: 6703 if self.parent.shouldRetry(tries, e, deadline): 6704 tries += 1 6705 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6706 continue 6707 raise plumbing.convert_error_to_porcelain(e) from e 6708 break 6709 6710 resp = models.ResourceHealthcheckResponse() 6711 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 6712 plumbing_response.meta) 6713 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6714 plumbing_response.rate_limit) 6715 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:
6718class SnapshotResources: 6719 ''' 6720 SnapshotResources exposes the read only methods of the Resources 6721 service for historical queries. 6722 ''' 6723 def __init__(self, resources): 6724 self.resources = resources 6725 6726 def get(self, id, timeout=None): 6727 ''' 6728 Get reads one Resource by ID. 6729 ''' 6730 return self.resources.get(id, timeout=timeout) 6731 6732 def list(self, filter, *args, timeout=None): 6733 ''' 6734 List gets a list of Resources matching a given set of criteria. 6735 ''' 6736 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)
6726 def get(self, id, timeout=None): 6727 ''' 6728 Get reads one Resource by ID. 6729 ''' 6730 return self.resources.get(id, timeout=timeout)
Get reads one Resource by ID.
def
list(self, filter, *args, timeout=None)
6732 def list(self, filter, *args, timeout=None): 6733 ''' 6734 List gets a list of Resources matching a given set of criteria. 6735 ''' 6736 return self.resources.list(filter, *args, timeout=timeout)
List gets a list of Resources matching a given set of criteria.
class
ResourcesHistory:
6739class ResourcesHistory: 6740 ''' 6741 ResourcesHistory records all changes to the state of a Resource. 6742 See `strongdm.models.ResourceHistory`. 6743 ''' 6744 def __init__(self, channel, client): 6745 self.parent = client 6746 self.stub = ResourcesHistoryStub(channel) 6747 6748 def list(self, filter, *args, timeout=None): 6749 ''' 6750 List gets a list of ResourceHistory records matching a given set of criteria. 6751 ''' 6752 deadline = None if timeout is None else time.time() + timeout 6753 req = ResourceHistoryListRequest() 6754 req.meta.CopyFrom(ListRequestMetadata()) 6755 if self.parent.page_limit > 0: 6756 req.meta.limit = self.parent.page_limit 6757 if self.parent.snapshot_datetime is not None: 6758 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6759 6760 req.filter = plumbing.quote_filter_args(filter, *args) 6761 6762 def generator(svc, req): 6763 tries = 0 6764 while True: 6765 t = None if deadline is None else deadline - time.time() 6766 try: 6767 plumbing_response = svc.stub.List( 6768 req, 6769 metadata=svc.parent.get_metadata( 6770 'ResourcesHistory.List', req), 6771 timeout=t) 6772 except Exception as e: 6773 if self.parent.shouldRetry(tries, e, deadline): 6774 tries += 1 6775 time.sleep( 6776 self.parent.exponentialBackoff(tries, deadline)) 6777 continue 6778 raise plumbing.convert_error_to_porcelain(e) from e 6779 tries = 0 6780 for plumbing_item in plumbing_response.history: 6781 yield plumbing.convert_resource_history_to_porcelain( 6782 plumbing_item) 6783 if plumbing_response.meta.next_cursor == '': 6784 break 6785 req.meta.cursor = plumbing_response.meta.next_cursor 6786 6787 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)
6748 def list(self, filter, *args, timeout=None): 6749 ''' 6750 List gets a list of ResourceHistory records matching a given set of criteria. 6751 ''' 6752 deadline = None if timeout is None else time.time() + timeout 6753 req = ResourceHistoryListRequest() 6754 req.meta.CopyFrom(ListRequestMetadata()) 6755 if self.parent.page_limit > 0: 6756 req.meta.limit = self.parent.page_limit 6757 if self.parent.snapshot_datetime is not None: 6758 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6759 6760 req.filter = plumbing.quote_filter_args(filter, *args) 6761 6762 def generator(svc, req): 6763 tries = 0 6764 while True: 6765 t = None if deadline is None else deadline - time.time() 6766 try: 6767 plumbing_response = svc.stub.List( 6768 req, 6769 metadata=svc.parent.get_metadata( 6770 'ResourcesHistory.List', req), 6771 timeout=t) 6772 except Exception as e: 6773 if self.parent.shouldRetry(tries, e, deadline): 6774 tries += 1 6775 time.sleep( 6776 self.parent.exponentialBackoff(tries, deadline)) 6777 continue 6778 raise plumbing.convert_error_to_porcelain(e) from e 6779 tries = 0 6780 for plumbing_item in plumbing_response.history: 6781 yield plumbing.convert_resource_history_to_porcelain( 6782 plumbing_item) 6783 if plumbing_response.meta.next_cursor == '': 6784 break 6785 req.meta.cursor = plumbing_response.meta.next_cursor 6786 6787 return generator(self, req)
List gets a list of ResourceHistory records matching a given set of criteria.
class
RoleResources:
6790class RoleResources: 6791 ''' 6792 RoleResources enumerates the resources to which roles have access. 6793 The RoleResources service is read-only. 6794 See `strongdm.models.RoleResource`. 6795 ''' 6796 def __init__(self, channel, client): 6797 self.parent = client 6798 self.stub = RoleResourcesStub(channel) 6799 6800 def list(self, filter, *args, timeout=None): 6801 ''' 6802 List gets a list of RoleResource records matching a given set of criteria. 6803 ''' 6804 deadline = None if timeout is None else time.time() + timeout 6805 req = RoleResourceListRequest() 6806 req.meta.CopyFrom(ListRequestMetadata()) 6807 if self.parent.page_limit > 0: 6808 req.meta.limit = self.parent.page_limit 6809 if self.parent.snapshot_datetime is not None: 6810 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6811 6812 req.filter = plumbing.quote_filter_args(filter, *args) 6813 6814 def generator(svc, req): 6815 tries = 0 6816 while True: 6817 t = None if deadline is None else deadline - time.time() 6818 try: 6819 plumbing_response = svc.stub.List( 6820 req, 6821 metadata=svc.parent.get_metadata( 6822 'RoleResources.List', req), 6823 timeout=t) 6824 except Exception as e: 6825 if self.parent.shouldRetry(tries, e, deadline): 6826 tries += 1 6827 time.sleep( 6828 self.parent.exponentialBackoff(tries, deadline)) 6829 continue 6830 raise plumbing.convert_error_to_porcelain(e) from e 6831 tries = 0 6832 for plumbing_item in plumbing_response.role_resources: 6833 yield plumbing.convert_role_resource_to_porcelain( 6834 plumbing_item) 6835 if plumbing_response.meta.next_cursor == '': 6836 break 6837 req.meta.cursor = plumbing_response.meta.next_cursor 6838 6839 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)
6800 def list(self, filter, *args, timeout=None): 6801 ''' 6802 List gets a list of RoleResource records matching a given set of criteria. 6803 ''' 6804 deadline = None if timeout is None else time.time() + timeout 6805 req = RoleResourceListRequest() 6806 req.meta.CopyFrom(ListRequestMetadata()) 6807 if self.parent.page_limit > 0: 6808 req.meta.limit = self.parent.page_limit 6809 if self.parent.snapshot_datetime is not None: 6810 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6811 6812 req.filter = plumbing.quote_filter_args(filter, *args) 6813 6814 def generator(svc, req): 6815 tries = 0 6816 while True: 6817 t = None if deadline is None else deadline - time.time() 6818 try: 6819 plumbing_response = svc.stub.List( 6820 req, 6821 metadata=svc.parent.get_metadata( 6822 'RoleResources.List', req), 6823 timeout=t) 6824 except Exception as e: 6825 if self.parent.shouldRetry(tries, e, deadline): 6826 tries += 1 6827 time.sleep( 6828 self.parent.exponentialBackoff(tries, deadline)) 6829 continue 6830 raise plumbing.convert_error_to_porcelain(e) from e 6831 tries = 0 6832 for plumbing_item in plumbing_response.role_resources: 6833 yield plumbing.convert_role_resource_to_porcelain( 6834 plumbing_item) 6835 if plumbing_response.meta.next_cursor == '': 6836 break 6837 req.meta.cursor = plumbing_response.meta.next_cursor 6838 6839 return generator(self, req)
List gets a list of RoleResource records matching a given set of criteria.
class
SnapshotRoleResources:
6842class SnapshotRoleResources: 6843 ''' 6844 SnapshotRoleResources exposes the read only methods of the RoleResources 6845 service for historical queries. 6846 ''' 6847 def __init__(self, role_resources): 6848 self.role_resources = role_resources 6849 6850 def list(self, filter, *args, timeout=None): 6851 ''' 6852 List gets a list of RoleResource records matching a given set of criteria. 6853 ''' 6854 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)
6850 def list(self, filter, *args, timeout=None): 6851 ''' 6852 List gets a list of RoleResource records matching a given set of criteria. 6853 ''' 6854 return self.role_resources.list(filter, *args, timeout=timeout)
List gets a list of RoleResource records matching a given set of criteria.
class
RoleResourcesHistory:
6857class RoleResourcesHistory: 6858 ''' 6859 RoleResourcesHistory records all changes to the state of a RoleResource. 6860 See `strongdm.models.RoleResourceHistory`. 6861 ''' 6862 def __init__(self, channel, client): 6863 self.parent = client 6864 self.stub = RoleResourcesHistoryStub(channel) 6865 6866 def list(self, filter, *args, timeout=None): 6867 ''' 6868 List gets a list of RoleResourceHistory records matching a given set of criteria. 6869 ''' 6870 deadline = None if timeout is None else time.time() + timeout 6871 req = RoleResourceHistoryListRequest() 6872 req.meta.CopyFrom(ListRequestMetadata()) 6873 if self.parent.page_limit > 0: 6874 req.meta.limit = self.parent.page_limit 6875 if self.parent.snapshot_datetime is not None: 6876 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6877 6878 req.filter = plumbing.quote_filter_args(filter, *args) 6879 6880 def generator(svc, req): 6881 tries = 0 6882 while True: 6883 t = None if deadline is None else deadline - time.time() 6884 try: 6885 plumbing_response = svc.stub.List( 6886 req, 6887 metadata=svc.parent.get_metadata( 6888 'RoleResourcesHistory.List', req), 6889 timeout=t) 6890 except Exception as e: 6891 if self.parent.shouldRetry(tries, e, deadline): 6892 tries += 1 6893 time.sleep( 6894 self.parent.exponentialBackoff(tries, deadline)) 6895 continue 6896 raise plumbing.convert_error_to_porcelain(e) from e 6897 tries = 0 6898 for plumbing_item in plumbing_response.history: 6899 yield plumbing.convert_role_resource_history_to_porcelain( 6900 plumbing_item) 6901 if plumbing_response.meta.next_cursor == '': 6902 break 6903 req.meta.cursor = plumbing_response.meta.next_cursor 6904 6905 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)
6866 def list(self, filter, *args, timeout=None): 6867 ''' 6868 List gets a list of RoleResourceHistory records matching a given set of criteria. 6869 ''' 6870 deadline = None if timeout is None else time.time() + timeout 6871 req = RoleResourceHistoryListRequest() 6872 req.meta.CopyFrom(ListRequestMetadata()) 6873 if self.parent.page_limit > 0: 6874 req.meta.limit = self.parent.page_limit 6875 if self.parent.snapshot_datetime is not None: 6876 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6877 6878 req.filter = plumbing.quote_filter_args(filter, *args) 6879 6880 def generator(svc, req): 6881 tries = 0 6882 while True: 6883 t = None if deadline is None else deadline - time.time() 6884 try: 6885 plumbing_response = svc.stub.List( 6886 req, 6887 metadata=svc.parent.get_metadata( 6888 'RoleResourcesHistory.List', req), 6889 timeout=t) 6890 except Exception as e: 6891 if self.parent.shouldRetry(tries, e, deadline): 6892 tries += 1 6893 time.sleep( 6894 self.parent.exponentialBackoff(tries, deadline)) 6895 continue 6896 raise plumbing.convert_error_to_porcelain(e) from e 6897 tries = 0 6898 for plumbing_item in plumbing_response.history: 6899 yield plumbing.convert_role_resource_history_to_porcelain( 6900 plumbing_item) 6901 if plumbing_response.meta.next_cursor == '': 6902 break 6903 req.meta.cursor = plumbing_response.meta.next_cursor 6904 6905 return generator(self, req)
List gets a list of RoleResourceHistory records matching a given set of criteria.
class
RolesHistory:
6908class RolesHistory: 6909 ''' 6910 RolesHistory records all changes to the state of a Role. 6911 See `strongdm.models.RoleHistory`. 6912 ''' 6913 def __init__(self, channel, client): 6914 self.parent = client 6915 self.stub = RolesHistoryStub(channel) 6916 6917 def list(self, filter, *args, timeout=None): 6918 ''' 6919 List gets a list of RoleHistory records matching a given set of criteria. 6920 ''' 6921 deadline = None if timeout is None else time.time() + timeout 6922 req = RoleHistoryListRequest() 6923 req.meta.CopyFrom(ListRequestMetadata()) 6924 if self.parent.page_limit > 0: 6925 req.meta.limit = self.parent.page_limit 6926 if self.parent.snapshot_datetime is not None: 6927 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6928 6929 req.filter = plumbing.quote_filter_args(filter, *args) 6930 6931 def generator(svc, req): 6932 tries = 0 6933 while True: 6934 t = None if deadline is None else deadline - time.time() 6935 try: 6936 plumbing_response = svc.stub.List( 6937 req, 6938 metadata=svc.parent.get_metadata( 6939 'RolesHistory.List', req), 6940 timeout=t) 6941 except Exception as e: 6942 if self.parent.shouldRetry(tries, e, deadline): 6943 tries += 1 6944 time.sleep( 6945 self.parent.exponentialBackoff(tries, deadline)) 6946 continue 6947 raise plumbing.convert_error_to_porcelain(e) from e 6948 tries = 0 6949 for plumbing_item in plumbing_response.history: 6950 yield plumbing.convert_role_history_to_porcelain( 6951 plumbing_item) 6952 if plumbing_response.meta.next_cursor == '': 6953 break 6954 req.meta.cursor = plumbing_response.meta.next_cursor 6955 6956 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)
6917 def list(self, filter, *args, timeout=None): 6918 ''' 6919 List gets a list of RoleHistory records matching a given set of criteria. 6920 ''' 6921 deadline = None if timeout is None else time.time() + timeout 6922 req = RoleHistoryListRequest() 6923 req.meta.CopyFrom(ListRequestMetadata()) 6924 if self.parent.page_limit > 0: 6925 req.meta.limit = self.parent.page_limit 6926 if self.parent.snapshot_datetime is not None: 6927 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6928 6929 req.filter = plumbing.quote_filter_args(filter, *args) 6930 6931 def generator(svc, req): 6932 tries = 0 6933 while True: 6934 t = None if deadline is None else deadline - time.time() 6935 try: 6936 plumbing_response = svc.stub.List( 6937 req, 6938 metadata=svc.parent.get_metadata( 6939 'RolesHistory.List', req), 6940 timeout=t) 6941 except Exception as e: 6942 if self.parent.shouldRetry(tries, e, deadline): 6943 tries += 1 6944 time.sleep( 6945 self.parent.exponentialBackoff(tries, deadline)) 6946 continue 6947 raise plumbing.convert_error_to_porcelain(e) from e 6948 tries = 0 6949 for plumbing_item in plumbing_response.history: 6950 yield plumbing.convert_role_history_to_porcelain( 6951 plumbing_item) 6952 if plumbing_response.meta.next_cursor == '': 6953 break 6954 req.meta.cursor = plumbing_response.meta.next_cursor 6955 6956 return generator(self, req)
List gets a list of RoleHistory records matching a given set of criteria.
class
SecretStores:
6959class SecretStores: 6960 ''' 6961 SecretStores are servers where resource secrets (passwords, keys) are stored. 6962 See: 6963 `strongdm.models.ActiveDirectoryStore` 6964 `strongdm.models.AWSStore` 6965 `strongdm.models.AWSCertX509Store` 6966 `strongdm.models.AzureStore` 6967 `strongdm.models.CyberarkConjurStore` 6968 `strongdm.models.CyberarkPAMStore` 6969 `strongdm.models.CyberarkPAMExperimentalStore` 6970 `strongdm.models.DelineaStore` 6971 `strongdm.models.GCPStore` 6972 `strongdm.models.GCPCertX509Store` 6973 `strongdm.models.KeyfactorSSHStore` 6974 `strongdm.models.KeyfactorX509Store` 6975 `strongdm.models.StrongVaultStore` 6976 `strongdm.models.VaultAppRoleStore` 6977 `strongdm.models.VaultAppRoleCertSSHStore` 6978 `strongdm.models.VaultAppRoleCertX509Store` 6979 `strongdm.models.VaultAWSEC2Store` 6980 `strongdm.models.VaultAWSEC2CertSSHStore` 6981 `strongdm.models.VaultAWSEC2CertX509Store` 6982 `strongdm.models.VaultAWSIAMStore` 6983 `strongdm.models.VaultAWSIAMCertSSHStore` 6984 `strongdm.models.VaultAWSIAMCertX509Store` 6985 `strongdm.models.VaultTLSStore` 6986 `strongdm.models.VaultTLSCertSSHStore` 6987 `strongdm.models.VaultTLSCertX509Store` 6988 `strongdm.models.VaultTokenStore` 6989 `strongdm.models.VaultTokenCertSSHStore` 6990 `strongdm.models.VaultTokenCertX509Store` 6991 ''' 6992 def __init__(self, channel, client): 6993 self.parent = client 6994 self.stub = SecretStoresStub(channel) 6995 6996 def create(self, secret_store, timeout=None): 6997 deadline = None if timeout is None else time.time() + timeout 6998 req = SecretStoreCreateRequest() 6999 7000 if secret_store is not None: 7001 req.secret_store.CopyFrom( 7002 plumbing.convert_secret_store_to_plumbing(secret_store)) 7003 tries = 0 7004 plumbing_response = None 7005 while True: 7006 t = None if deadline is None else deadline - time.time() 7007 try: 7008 plumbing_response = self.stub.Create( 7009 req, 7010 metadata=self.parent.get_metadata('SecretStores.Create', 7011 req), 7012 timeout=t) 7013 except Exception as e: 7014 if self.parent.shouldRetry(tries, e, deadline): 7015 tries += 1 7016 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7017 continue 7018 raise plumbing.convert_error_to_porcelain(e) from e 7019 break 7020 7021 resp = models.SecretStoreCreateResponse() 7022 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 7023 plumbing_response.meta) 7024 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7025 plumbing_response.rate_limit) 7026 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 7027 plumbing_response.secret_store) 7028 return resp 7029 7030 def get(self, id, timeout=None): 7031 ''' 7032 Get reads one SecretStore by ID. 7033 ''' 7034 deadline = None if timeout is None else time.time() + timeout 7035 req = SecretStoreGetRequest() 7036 if self.parent.snapshot_datetime is not None: 7037 req.meta.CopyFrom(GetRequestMetadata()) 7038 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7039 7040 req.id = (id) 7041 tries = 0 7042 plumbing_response = None 7043 while True: 7044 t = None if deadline is None else deadline - time.time() 7045 try: 7046 plumbing_response = self.stub.Get( 7047 req, 7048 metadata=self.parent.get_metadata('SecretStores.Get', req), 7049 timeout=t) 7050 except Exception as e: 7051 if self.parent.shouldRetry(tries, e, deadline): 7052 tries += 1 7053 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7054 continue 7055 raise plumbing.convert_error_to_porcelain(e) from e 7056 break 7057 7058 resp = models.SecretStoreGetResponse() 7059 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 7060 plumbing_response.meta) 7061 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7062 plumbing_response.rate_limit) 7063 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 7064 plumbing_response.secret_store) 7065 return resp 7066 7067 def update(self, secret_store, timeout=None): 7068 ''' 7069 Update replaces all the fields of a SecretStore by ID. 7070 ''' 7071 deadline = None if timeout is None else time.time() + timeout 7072 req = SecretStoreUpdateRequest() 7073 7074 if secret_store is not None: 7075 req.secret_store.CopyFrom( 7076 plumbing.convert_secret_store_to_plumbing(secret_store)) 7077 tries = 0 7078 plumbing_response = None 7079 while True: 7080 t = None if deadline is None else deadline - time.time() 7081 try: 7082 plumbing_response = self.stub.Update( 7083 req, 7084 metadata=self.parent.get_metadata('SecretStores.Update', 7085 req), 7086 timeout=t) 7087 except Exception as e: 7088 if self.parent.shouldRetry(tries, e, deadline): 7089 tries += 1 7090 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7091 continue 7092 raise plumbing.convert_error_to_porcelain(e) from e 7093 break 7094 7095 resp = models.SecretStoreUpdateResponse() 7096 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 7097 plumbing_response.meta) 7098 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7099 plumbing_response.rate_limit) 7100 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 7101 plumbing_response.secret_store) 7102 return resp 7103 7104 def delete(self, id, timeout=None): 7105 ''' 7106 Delete removes a SecretStore by ID. 7107 ''' 7108 deadline = None if timeout is None else time.time() + timeout 7109 req = SecretStoreDeleteRequest() 7110 7111 req.id = (id) 7112 tries = 0 7113 plumbing_response = None 7114 while True: 7115 t = None if deadline is None else deadline - time.time() 7116 try: 7117 plumbing_response = self.stub.Delete( 7118 req, 7119 metadata=self.parent.get_metadata('SecretStores.Delete', 7120 req), 7121 timeout=t) 7122 except Exception as e: 7123 if self.parent.shouldRetry(tries, e, deadline): 7124 tries += 1 7125 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7126 continue 7127 raise plumbing.convert_error_to_porcelain(e) from e 7128 break 7129 7130 resp = models.SecretStoreDeleteResponse() 7131 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 7132 plumbing_response.meta) 7133 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7134 plumbing_response.rate_limit) 7135 return resp 7136 7137 def list(self, filter, *args, timeout=None): 7138 ''' 7139 List gets a list of SecretStores matching a given set of criteria. 7140 ''' 7141 deadline = None if timeout is None else time.time() + timeout 7142 req = SecretStoreListRequest() 7143 req.meta.CopyFrom(ListRequestMetadata()) 7144 if self.parent.page_limit > 0: 7145 req.meta.limit = self.parent.page_limit 7146 if self.parent.snapshot_datetime is not None: 7147 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7148 7149 req.filter = plumbing.quote_filter_args(filter, *args) 7150 7151 def generator(svc, req): 7152 tries = 0 7153 while True: 7154 t = None if deadline is None else deadline - time.time() 7155 try: 7156 plumbing_response = svc.stub.List( 7157 req, 7158 metadata=svc.parent.get_metadata( 7159 'SecretStores.List', req), 7160 timeout=t) 7161 except Exception as e: 7162 if self.parent.shouldRetry(tries, e, deadline): 7163 tries += 1 7164 time.sleep( 7165 self.parent.exponentialBackoff(tries, deadline)) 7166 continue 7167 raise plumbing.convert_error_to_porcelain(e) from e 7168 tries = 0 7169 for plumbing_item in plumbing_response.secret_stores: 7170 yield plumbing.convert_secret_store_to_porcelain( 7171 plumbing_item) 7172 if plumbing_response.meta.next_cursor == '': 7173 break 7174 req.meta.cursor = plumbing_response.meta.next_cursor 7175 7176 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)
6996 def create(self, secret_store, timeout=None): 6997 deadline = None if timeout is None else time.time() + timeout 6998 req = SecretStoreCreateRequest() 6999 7000 if secret_store is not None: 7001 req.secret_store.CopyFrom( 7002 plumbing.convert_secret_store_to_plumbing(secret_store)) 7003 tries = 0 7004 plumbing_response = None 7005 while True: 7006 t = None if deadline is None else deadline - time.time() 7007 try: 7008 plumbing_response = self.stub.Create( 7009 req, 7010 metadata=self.parent.get_metadata('SecretStores.Create', 7011 req), 7012 timeout=t) 7013 except Exception as e: 7014 if self.parent.shouldRetry(tries, e, deadline): 7015 tries += 1 7016 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7017 continue 7018 raise plumbing.convert_error_to_porcelain(e) from e 7019 break 7020 7021 resp = models.SecretStoreCreateResponse() 7022 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 7023 plumbing_response.meta) 7024 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7025 plumbing_response.rate_limit) 7026 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 7027 plumbing_response.secret_store) 7028 return resp
def
get(self, id, timeout=None)
7030 def get(self, id, timeout=None): 7031 ''' 7032 Get reads one SecretStore by ID. 7033 ''' 7034 deadline = None if timeout is None else time.time() + timeout 7035 req = SecretStoreGetRequest() 7036 if self.parent.snapshot_datetime is not None: 7037 req.meta.CopyFrom(GetRequestMetadata()) 7038 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7039 7040 req.id = (id) 7041 tries = 0 7042 plumbing_response = None 7043 while True: 7044 t = None if deadline is None else deadline - time.time() 7045 try: 7046 plumbing_response = self.stub.Get( 7047 req, 7048 metadata=self.parent.get_metadata('SecretStores.Get', req), 7049 timeout=t) 7050 except Exception as e: 7051 if self.parent.shouldRetry(tries, e, deadline): 7052 tries += 1 7053 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7054 continue 7055 raise plumbing.convert_error_to_porcelain(e) from e 7056 break 7057 7058 resp = models.SecretStoreGetResponse() 7059 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 7060 plumbing_response.meta) 7061 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7062 plumbing_response.rate_limit) 7063 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 7064 plumbing_response.secret_store) 7065 return resp
Get reads one SecretStore by ID.
def
update(self, secret_store, timeout=None)
7067 def update(self, secret_store, timeout=None): 7068 ''' 7069 Update replaces all the fields of a SecretStore by ID. 7070 ''' 7071 deadline = None if timeout is None else time.time() + timeout 7072 req = SecretStoreUpdateRequest() 7073 7074 if secret_store is not None: 7075 req.secret_store.CopyFrom( 7076 plumbing.convert_secret_store_to_plumbing(secret_store)) 7077 tries = 0 7078 plumbing_response = None 7079 while True: 7080 t = None if deadline is None else deadline - time.time() 7081 try: 7082 plumbing_response = self.stub.Update( 7083 req, 7084 metadata=self.parent.get_metadata('SecretStores.Update', 7085 req), 7086 timeout=t) 7087 except Exception as e: 7088 if self.parent.shouldRetry(tries, e, deadline): 7089 tries += 1 7090 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7091 continue 7092 raise plumbing.convert_error_to_porcelain(e) from e 7093 break 7094 7095 resp = models.SecretStoreUpdateResponse() 7096 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 7097 plumbing_response.meta) 7098 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7099 plumbing_response.rate_limit) 7100 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 7101 plumbing_response.secret_store) 7102 return resp
Update replaces all the fields of a SecretStore by ID.
def
delete(self, id, timeout=None)
7104 def delete(self, id, timeout=None): 7105 ''' 7106 Delete removes a SecretStore by ID. 7107 ''' 7108 deadline = None if timeout is None else time.time() + timeout 7109 req = SecretStoreDeleteRequest() 7110 7111 req.id = (id) 7112 tries = 0 7113 plumbing_response = None 7114 while True: 7115 t = None if deadline is None else deadline - time.time() 7116 try: 7117 plumbing_response = self.stub.Delete( 7118 req, 7119 metadata=self.parent.get_metadata('SecretStores.Delete', 7120 req), 7121 timeout=t) 7122 except Exception as e: 7123 if self.parent.shouldRetry(tries, e, deadline): 7124 tries += 1 7125 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7126 continue 7127 raise plumbing.convert_error_to_porcelain(e) from e 7128 break 7129 7130 resp = models.SecretStoreDeleteResponse() 7131 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 7132 plumbing_response.meta) 7133 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7134 plumbing_response.rate_limit) 7135 return resp
Delete removes a SecretStore by ID.
def
list(self, filter, *args, timeout=None)
7137 def list(self, filter, *args, timeout=None): 7138 ''' 7139 List gets a list of SecretStores matching a given set of criteria. 7140 ''' 7141 deadline = None if timeout is None else time.time() + timeout 7142 req = SecretStoreListRequest() 7143 req.meta.CopyFrom(ListRequestMetadata()) 7144 if self.parent.page_limit > 0: 7145 req.meta.limit = self.parent.page_limit 7146 if self.parent.snapshot_datetime is not None: 7147 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7148 7149 req.filter = plumbing.quote_filter_args(filter, *args) 7150 7151 def generator(svc, req): 7152 tries = 0 7153 while True: 7154 t = None if deadline is None else deadline - time.time() 7155 try: 7156 plumbing_response = svc.stub.List( 7157 req, 7158 metadata=svc.parent.get_metadata( 7159 'SecretStores.List', req), 7160 timeout=t) 7161 except Exception as e: 7162 if self.parent.shouldRetry(tries, e, deadline): 7163 tries += 1 7164 time.sleep( 7165 self.parent.exponentialBackoff(tries, deadline)) 7166 continue 7167 raise plumbing.convert_error_to_porcelain(e) from e 7168 tries = 0 7169 for plumbing_item in plumbing_response.secret_stores: 7170 yield plumbing.convert_secret_store_to_porcelain( 7171 plumbing_item) 7172 if plumbing_response.meta.next_cursor == '': 7173 break 7174 req.meta.cursor = plumbing_response.meta.next_cursor 7175 7176 return generator(self, req)
List gets a list of SecretStores matching a given set of criteria.
class
SnapshotSecretStores:
7179class SnapshotSecretStores: 7180 ''' 7181 SnapshotSecretStores exposes the read only methods of the SecretStores 7182 service for historical queries. 7183 ''' 7184 def __init__(self, secret_stores): 7185 self.secret_stores = secret_stores 7186 7187 def get(self, id, timeout=None): 7188 ''' 7189 Get reads one SecretStore by ID. 7190 ''' 7191 return self.secret_stores.get(id, timeout=timeout) 7192 7193 def list(self, filter, *args, timeout=None): 7194 ''' 7195 List gets a list of SecretStores matching a given set of criteria. 7196 ''' 7197 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)
7187 def get(self, id, timeout=None): 7188 ''' 7189 Get reads one SecretStore by ID. 7190 ''' 7191 return self.secret_stores.get(id, timeout=timeout)
Get reads one SecretStore by ID.
def
list(self, filter, *args, timeout=None)
7193 def list(self, filter, *args, timeout=None): 7194 ''' 7195 List gets a list of SecretStores matching a given set of criteria. 7196 ''' 7197 return self.secret_stores.list(filter, *args, timeout=timeout)
List gets a list of SecretStores matching a given set of criteria.
class
SecretEngines:
7200class SecretEngines: 7201 ''' 7202 7203 See: 7204 `strongdm.models.ActiveDirectoryEngine` 7205 `strongdm.models.KeyValueEngine` 7206 `strongdm.models.MysqlEngine` 7207 `strongdm.models.PostgresEngine` 7208 `strongdm.models.SqlserverEngine` 7209 ''' 7210 def __init__(self, channel, client): 7211 self.parent = client 7212 self.stub = SecretEnginesStub(channel) 7213 7214 def list(self, filter, *args, timeout=None): 7215 ''' 7216 List returns a list of Secret Engines 7217 ''' 7218 deadline = None if timeout is None else time.time() + timeout 7219 req = SecretEngineListRequest() 7220 req.meta.CopyFrom(ListRequestMetadata()) 7221 if self.parent.page_limit > 0: 7222 req.meta.limit = self.parent.page_limit 7223 if self.parent.snapshot_datetime is not None: 7224 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7225 7226 req.filter = plumbing.quote_filter_args(filter, *args) 7227 7228 def generator(svc, req): 7229 tries = 0 7230 while True: 7231 t = None if deadline is None else deadline - time.time() 7232 try: 7233 plumbing_response = svc.stub.List( 7234 req, 7235 metadata=svc.parent.get_metadata( 7236 'SecretEngines.List', req), 7237 timeout=t) 7238 except Exception as e: 7239 if self.parent.shouldRetry(tries, e, deadline): 7240 tries += 1 7241 time.sleep( 7242 self.parent.exponentialBackoff(tries, deadline)) 7243 continue 7244 raise plumbing.convert_error_to_porcelain(e) from e 7245 tries = 0 7246 for plumbing_item in plumbing_response.secret_engines: 7247 yield plumbing.convert_secret_engine_to_porcelain( 7248 plumbing_item) 7249 if plumbing_response.meta.next_cursor == '': 7250 break 7251 req.meta.cursor = plumbing_response.meta.next_cursor 7252 7253 return generator(self, req) 7254 7255 def get(self, id, timeout=None): 7256 ''' 7257 Get returns a secret engine details 7258 ''' 7259 deadline = None if timeout is None else time.time() + timeout 7260 req = SecretEngineGetRequest() 7261 if self.parent.snapshot_datetime is not None: 7262 req.meta.CopyFrom(GetRequestMetadata()) 7263 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7264 7265 req.id = (id) 7266 tries = 0 7267 plumbing_response = None 7268 while True: 7269 t = None if deadline is None else deadline - time.time() 7270 try: 7271 plumbing_response = self.stub.Get( 7272 req, 7273 metadata=self.parent.get_metadata('SecretEngines.Get', 7274 req), 7275 timeout=t) 7276 except Exception as e: 7277 if self.parent.shouldRetry(tries, e, deadline): 7278 tries += 1 7279 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7280 continue 7281 raise plumbing.convert_error_to_porcelain(e) from e 7282 break 7283 7284 resp = models.SecretEngineGetResponse() 7285 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 7286 plumbing_response.meta) 7287 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7288 plumbing_response.rate_limit) 7289 resp.secret_engine = plumbing.convert_secret_engine_to_porcelain( 7290 plumbing_response.secret_engine) 7291 return resp 7292 7293 def create(self, secret_engine, timeout=None): 7294 ''' 7295 Create creates a secret engine 7296 ''' 7297 deadline = None if timeout is None else time.time() + timeout 7298 req = SecretEngineCreateRequest() 7299 7300 if secret_engine is not None: 7301 req.secret_engine.CopyFrom( 7302 plumbing.convert_secret_engine_to_plumbing(secret_engine)) 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.Create( 7309 req, 7310 metadata=self.parent.get_metadata('SecretEngines.Create', 7311 req), 7312 timeout=t) 7313 except Exception as e: 7314 if self.parent.shouldRetry(tries, e, deadline): 7315 tries += 1 7316 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7317 continue 7318 raise plumbing.convert_error_to_porcelain(e) from e 7319 break 7320 7321 resp = models.SecretEngineCreateResponse() 7322 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 7323 plumbing_response.meta) 7324 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7325 plumbing_response.rate_limit) 7326 resp.secret_engine = plumbing.convert_secret_engine_to_porcelain( 7327 plumbing_response.secret_engine) 7328 return resp 7329 7330 def update(self, secret_engine, timeout=None): 7331 ''' 7332 Update updates a secret engine 7333 ''' 7334 deadline = None if timeout is None else time.time() + timeout 7335 req = SecretEngineUpdateRequest() 7336 7337 if secret_engine is not None: 7338 req.secret_engine.CopyFrom( 7339 plumbing.convert_secret_engine_to_plumbing(secret_engine)) 7340 tries = 0 7341 plumbing_response = None 7342 while True: 7343 t = None if deadline is None else deadline - time.time() 7344 try: 7345 plumbing_response = self.stub.Update( 7346 req, 7347 metadata=self.parent.get_metadata('SecretEngines.Update', 7348 req), 7349 timeout=t) 7350 except Exception as e: 7351 if self.parent.shouldRetry(tries, e, deadline): 7352 tries += 1 7353 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7354 continue 7355 raise plumbing.convert_error_to_porcelain(e) from e 7356 break 7357 7358 resp = models.SecretEngineUpdateResponse() 7359 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 7360 plumbing_response.meta) 7361 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7362 plumbing_response.rate_limit) 7363 resp.secret_engine = plumbing.convert_secret_engine_to_porcelain( 7364 plumbing_response.secret_engine) 7365 return resp 7366 7367 def delete(self, id, timeout=None): 7368 ''' 7369 Delete deletes a secret engine 7370 ''' 7371 deadline = None if timeout is None else time.time() + timeout 7372 req = SecretEngineDeleteRequest() 7373 7374 req.id = (id) 7375 tries = 0 7376 plumbing_response = None 7377 while True: 7378 t = None if deadline is None else deadline - time.time() 7379 try: 7380 plumbing_response = self.stub.Delete( 7381 req, 7382 metadata=self.parent.get_metadata('SecretEngines.Delete', 7383 req), 7384 timeout=t) 7385 except Exception as e: 7386 if self.parent.shouldRetry(tries, e, deadline): 7387 tries += 1 7388 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7389 continue 7390 raise plumbing.convert_error_to_porcelain(e) from e 7391 break 7392 7393 resp = models.SecretEngineDeleteResponse() 7394 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7395 plumbing_response.rate_limit) 7396 return resp 7397 7398 def list_secret_stores(self, filter, *args, timeout=None): 7399 ''' 7400 ListSecretStores returns a list of Secret Stores that can be used as a backing store 7401 for Secret Engine 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.ListSecretStores( 7419 req, 7420 metadata=svc.parent.get_metadata( 7421 'SecretEngines.ListSecretStores', 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) 7439 7440 def generate_keys(self, secret_engine_id, timeout=None): 7441 ''' 7442 GenerateKeys generates a private key, stores it in a secret store and stores a public key in a secret engine 7443 ''' 7444 deadline = None if timeout is None else time.time() + timeout 7445 req = GenerateKeysRequest() 7446 7447 req.secret_engine_id = (secret_engine_id) 7448 tries = 0 7449 plumbing_response = None 7450 while True: 7451 t = None if deadline is None else deadline - time.time() 7452 try: 7453 plumbing_response = self.stub.GenerateKeys( 7454 req, 7455 metadata=self.parent.get_metadata( 7456 'SecretEngines.GenerateKeys', req), 7457 timeout=t) 7458 except Exception as e: 7459 if self.parent.shouldRetry(tries, e, deadline): 7460 tries += 1 7461 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7462 continue 7463 raise plumbing.convert_error_to_porcelain(e) from e 7464 break 7465 7466 resp = models.GenerateKeysResponse() 7467 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7468 plumbing_response.rate_limit) 7469 return resp 7470 7471 def healthcheck(self, secret_engine_id, timeout=None): 7472 ''' 7473 Healthcheck triggers a healthcheck for all nodes serving a secret engine 7474 ''' 7475 deadline = None if timeout is None else time.time() + timeout 7476 req = HealthcheckRequest() 7477 7478 req.secret_engine_id = (secret_engine_id) 7479 tries = 0 7480 plumbing_response = None 7481 while True: 7482 t = None if deadline is None else deadline - time.time() 7483 try: 7484 plumbing_response = self.stub.Healthcheck( 7485 req, 7486 metadata=self.parent.get_metadata( 7487 'SecretEngines.Healthcheck', req), 7488 timeout=t) 7489 except Exception as e: 7490 if self.parent.shouldRetry(tries, e, deadline): 7491 tries += 1 7492 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7493 continue 7494 raise plumbing.convert_error_to_porcelain(e) from e 7495 break 7496 7497 resp = models.HealthcheckResponse() 7498 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7499 plumbing_response.rate_limit) 7500 resp.status = plumbing.convert_repeated_healthcheck_status_to_porcelain( 7501 plumbing_response.status) 7502 return resp 7503 7504 def rotate(self, id, password_policy, timeout=None): 7505 ''' 7506 Rotate rotates secret engine's credentials 7507 ''' 7508 deadline = None if timeout is None else time.time() + timeout 7509 req = SecretEngineRotateRequest() 7510 7511 req.id = (id) 7512 if password_policy is not None: 7513 req.password_policy.CopyFrom( 7514 plumbing.convert_secret_engine_password_policy_to_plumbing( 7515 password_policy)) 7516 tries = 0 7517 plumbing_response = None 7518 while True: 7519 t = None if deadline is None else deadline - time.time() 7520 try: 7521 plumbing_response = self.stub.Rotate( 7522 req, 7523 metadata=self.parent.get_metadata('SecretEngines.Rotate', 7524 req), 7525 timeout=t) 7526 except Exception as e: 7527 if self.parent.shouldRetry(tries, e, deadline): 7528 tries += 1 7529 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7530 continue 7531 raise plumbing.convert_error_to_porcelain(e) from e 7532 break 7533 7534 resp = models.SecretEngineRotateResponse() 7535 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7536 plumbing_response.rate_limit) 7537 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)
7214 def list(self, filter, *args, timeout=None): 7215 ''' 7216 List returns a list of Secret Engines 7217 ''' 7218 deadline = None if timeout is None else time.time() + timeout 7219 req = SecretEngineListRequest() 7220 req.meta.CopyFrom(ListRequestMetadata()) 7221 if self.parent.page_limit > 0: 7222 req.meta.limit = self.parent.page_limit 7223 if self.parent.snapshot_datetime is not None: 7224 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7225 7226 req.filter = plumbing.quote_filter_args(filter, *args) 7227 7228 def generator(svc, req): 7229 tries = 0 7230 while True: 7231 t = None if deadline is None else deadline - time.time() 7232 try: 7233 plumbing_response = svc.stub.List( 7234 req, 7235 metadata=svc.parent.get_metadata( 7236 'SecretEngines.List', req), 7237 timeout=t) 7238 except Exception as e: 7239 if self.parent.shouldRetry(tries, e, deadline): 7240 tries += 1 7241 time.sleep( 7242 self.parent.exponentialBackoff(tries, deadline)) 7243 continue 7244 raise plumbing.convert_error_to_porcelain(e) from e 7245 tries = 0 7246 for plumbing_item in plumbing_response.secret_engines: 7247 yield plumbing.convert_secret_engine_to_porcelain( 7248 plumbing_item) 7249 if plumbing_response.meta.next_cursor == '': 7250 break 7251 req.meta.cursor = plumbing_response.meta.next_cursor 7252 7253 return generator(self, req)
List returns a list of Secret Engines
def
get(self, id, timeout=None)
7255 def get(self, id, timeout=None): 7256 ''' 7257 Get returns a secret engine details 7258 ''' 7259 deadline = None if timeout is None else time.time() + timeout 7260 req = SecretEngineGetRequest() 7261 if self.parent.snapshot_datetime is not None: 7262 req.meta.CopyFrom(GetRequestMetadata()) 7263 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7264 7265 req.id = (id) 7266 tries = 0 7267 plumbing_response = None 7268 while True: 7269 t = None if deadline is None else deadline - time.time() 7270 try: 7271 plumbing_response = self.stub.Get( 7272 req, 7273 metadata=self.parent.get_metadata('SecretEngines.Get', 7274 req), 7275 timeout=t) 7276 except Exception as e: 7277 if self.parent.shouldRetry(tries, e, deadline): 7278 tries += 1 7279 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7280 continue 7281 raise plumbing.convert_error_to_porcelain(e) from e 7282 break 7283 7284 resp = models.SecretEngineGetResponse() 7285 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 7286 plumbing_response.meta) 7287 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7288 plumbing_response.rate_limit) 7289 resp.secret_engine = plumbing.convert_secret_engine_to_porcelain( 7290 plumbing_response.secret_engine) 7291 return resp
Get returns a secret engine details
def
create(self, secret_engine, timeout=None)
7293 def create(self, secret_engine, timeout=None): 7294 ''' 7295 Create creates a secret engine 7296 ''' 7297 deadline = None if timeout is None else time.time() + timeout 7298 req = SecretEngineCreateRequest() 7299 7300 if secret_engine is not None: 7301 req.secret_engine.CopyFrom( 7302 plumbing.convert_secret_engine_to_plumbing(secret_engine)) 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.Create( 7309 req, 7310 metadata=self.parent.get_metadata('SecretEngines.Create', 7311 req), 7312 timeout=t) 7313 except Exception as e: 7314 if self.parent.shouldRetry(tries, e, deadline): 7315 tries += 1 7316 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7317 continue 7318 raise plumbing.convert_error_to_porcelain(e) from e 7319 break 7320 7321 resp = models.SecretEngineCreateResponse() 7322 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 7323 plumbing_response.meta) 7324 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7325 plumbing_response.rate_limit) 7326 resp.secret_engine = plumbing.convert_secret_engine_to_porcelain( 7327 plumbing_response.secret_engine) 7328 return resp
Create creates a secret engine
def
update(self, secret_engine, timeout=None)
7330 def update(self, secret_engine, timeout=None): 7331 ''' 7332 Update updates a secret engine 7333 ''' 7334 deadline = None if timeout is None else time.time() + timeout 7335 req = SecretEngineUpdateRequest() 7336 7337 if secret_engine is not None: 7338 req.secret_engine.CopyFrom( 7339 plumbing.convert_secret_engine_to_plumbing(secret_engine)) 7340 tries = 0 7341 plumbing_response = None 7342 while True: 7343 t = None if deadline is None else deadline - time.time() 7344 try: 7345 plumbing_response = self.stub.Update( 7346 req, 7347 metadata=self.parent.get_metadata('SecretEngines.Update', 7348 req), 7349 timeout=t) 7350 except Exception as e: 7351 if self.parent.shouldRetry(tries, e, deadline): 7352 tries += 1 7353 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7354 continue 7355 raise plumbing.convert_error_to_porcelain(e) from e 7356 break 7357 7358 resp = models.SecretEngineUpdateResponse() 7359 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 7360 plumbing_response.meta) 7361 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7362 plumbing_response.rate_limit) 7363 resp.secret_engine = plumbing.convert_secret_engine_to_porcelain( 7364 plumbing_response.secret_engine) 7365 return resp
Update updates a secret engine
def
delete(self, id, timeout=None)
7367 def delete(self, id, timeout=None): 7368 ''' 7369 Delete deletes a secret engine 7370 ''' 7371 deadline = None if timeout is None else time.time() + timeout 7372 req = SecretEngineDeleteRequest() 7373 7374 req.id = (id) 7375 tries = 0 7376 plumbing_response = None 7377 while True: 7378 t = None if deadline is None else deadline - time.time() 7379 try: 7380 plumbing_response = self.stub.Delete( 7381 req, 7382 metadata=self.parent.get_metadata('SecretEngines.Delete', 7383 req), 7384 timeout=t) 7385 except Exception as e: 7386 if self.parent.shouldRetry(tries, e, deadline): 7387 tries += 1 7388 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7389 continue 7390 raise plumbing.convert_error_to_porcelain(e) from e 7391 break 7392 7393 resp = models.SecretEngineDeleteResponse() 7394 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7395 plumbing_response.rate_limit) 7396 return resp
Delete deletes a secret engine
def
list_secret_stores(self, filter, *args, timeout=None)
7398 def list_secret_stores(self, filter, *args, timeout=None): 7399 ''' 7400 ListSecretStores returns a list of Secret Stores that can be used as a backing store 7401 for Secret Engine 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.ListSecretStores( 7419 req, 7420 metadata=svc.parent.get_metadata( 7421 'SecretEngines.ListSecretStores', 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)
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)
7440 def generate_keys(self, secret_engine_id, timeout=None): 7441 ''' 7442 GenerateKeys generates a private key, stores it in a secret store and stores a public key in a secret engine 7443 ''' 7444 deadline = None if timeout is None else time.time() + timeout 7445 req = GenerateKeysRequest() 7446 7447 req.secret_engine_id = (secret_engine_id) 7448 tries = 0 7449 plumbing_response = None 7450 while True: 7451 t = None if deadline is None else deadline - time.time() 7452 try: 7453 plumbing_response = self.stub.GenerateKeys( 7454 req, 7455 metadata=self.parent.get_metadata( 7456 'SecretEngines.GenerateKeys', req), 7457 timeout=t) 7458 except Exception as e: 7459 if self.parent.shouldRetry(tries, e, deadline): 7460 tries += 1 7461 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7462 continue 7463 raise plumbing.convert_error_to_porcelain(e) from e 7464 break 7465 7466 resp = models.GenerateKeysResponse() 7467 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7468 plumbing_response.rate_limit) 7469 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)
7471 def healthcheck(self, secret_engine_id, timeout=None): 7472 ''' 7473 Healthcheck triggers a healthcheck for all nodes serving a secret engine 7474 ''' 7475 deadline = None if timeout is None else time.time() + timeout 7476 req = HealthcheckRequest() 7477 7478 req.secret_engine_id = (secret_engine_id) 7479 tries = 0 7480 plumbing_response = None 7481 while True: 7482 t = None if deadline is None else deadline - time.time() 7483 try: 7484 plumbing_response = self.stub.Healthcheck( 7485 req, 7486 metadata=self.parent.get_metadata( 7487 'SecretEngines.Healthcheck', req), 7488 timeout=t) 7489 except Exception as e: 7490 if self.parent.shouldRetry(tries, e, deadline): 7491 tries += 1 7492 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7493 continue 7494 raise plumbing.convert_error_to_porcelain(e) from e 7495 break 7496 7497 resp = models.HealthcheckResponse() 7498 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7499 plumbing_response.rate_limit) 7500 resp.status = plumbing.convert_repeated_healthcheck_status_to_porcelain( 7501 plumbing_response.status) 7502 return resp
Healthcheck triggers a healthcheck for all nodes serving a secret engine
def
rotate(self, id, password_policy, timeout=None)
7504 def rotate(self, id, password_policy, timeout=None): 7505 ''' 7506 Rotate rotates secret engine's credentials 7507 ''' 7508 deadline = None if timeout is None else time.time() + timeout 7509 req = SecretEngineRotateRequest() 7510 7511 req.id = (id) 7512 if password_policy is not None: 7513 req.password_policy.CopyFrom( 7514 plumbing.convert_secret_engine_password_policy_to_plumbing( 7515 password_policy)) 7516 tries = 0 7517 plumbing_response = None 7518 while True: 7519 t = None if deadline is None else deadline - time.time() 7520 try: 7521 plumbing_response = self.stub.Rotate( 7522 req, 7523 metadata=self.parent.get_metadata('SecretEngines.Rotate', 7524 req), 7525 timeout=t) 7526 except Exception as e: 7527 if self.parent.shouldRetry(tries, e, deadline): 7528 tries += 1 7529 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7530 continue 7531 raise plumbing.convert_error_to_porcelain(e) from e 7532 break 7533 7534 resp = models.SecretEngineRotateResponse() 7535 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7536 plumbing_response.rate_limit) 7537 return resp
Rotate rotates secret engine's credentials
class
SecretStoreHealths:
7540class SecretStoreHealths: 7541 ''' 7542 SecretStoreHealths exposes health states for secret stores. 7543 See `strongdm.models.SecretStoreHealth`. 7544 ''' 7545 def __init__(self, channel, client): 7546 self.parent = client 7547 self.stub = SecretStoreHealthsStub(channel) 7548 7549 def list(self, filter, *args, timeout=None): 7550 ''' 7551 List reports the health status of node to secret store pairs. 7552 ''' 7553 deadline = None if timeout is None else time.time() + timeout 7554 req = SecretStoreHealthListRequest() 7555 req.meta.CopyFrom(ListRequestMetadata()) 7556 if self.parent.page_limit > 0: 7557 req.meta.limit = self.parent.page_limit 7558 if self.parent.snapshot_datetime is not None: 7559 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7560 7561 req.filter = plumbing.quote_filter_args(filter, *args) 7562 7563 def generator(svc, req): 7564 tries = 0 7565 while True: 7566 t = None if deadline is None else deadline - time.time() 7567 try: 7568 plumbing_response = svc.stub.List( 7569 req, 7570 metadata=svc.parent.get_metadata( 7571 'SecretStoreHealths.List', req), 7572 timeout=t) 7573 except Exception as e: 7574 if self.parent.shouldRetry(tries, e, deadline): 7575 tries += 1 7576 time.sleep( 7577 self.parent.exponentialBackoff(tries, deadline)) 7578 continue 7579 raise plumbing.convert_error_to_porcelain(e) from e 7580 tries = 0 7581 for plumbing_item in plumbing_response.secret_store_healths: 7582 yield plumbing.convert_secret_store_health_to_porcelain( 7583 plumbing_item) 7584 if plumbing_response.meta.next_cursor == '': 7585 break 7586 req.meta.cursor = plumbing_response.meta.next_cursor 7587 7588 return generator(self, req) 7589 7590 def healthcheck(self, secret_store_id, timeout=None): 7591 ''' 7592 Healthcheck triggers a remote healthcheck request for a secret store. It may take minutes 7593 to propagate across a large network of Nodes. The call will return immediately, and the 7594 updated health of the Secret Store can be retrieved via List. 7595 ''' 7596 deadline = None if timeout is None else time.time() + timeout 7597 req = SecretStoreHealthcheckRequest() 7598 7599 req.secret_store_id = (secret_store_id) 7600 tries = 0 7601 plumbing_response = None 7602 while True: 7603 t = None if deadline is None else deadline - time.time() 7604 try: 7605 plumbing_response = self.stub.Healthcheck( 7606 req, 7607 metadata=self.parent.get_metadata( 7608 'SecretStoreHealths.Healthcheck', req), 7609 timeout=t) 7610 except Exception as e: 7611 if self.parent.shouldRetry(tries, e, deadline): 7612 tries += 1 7613 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7614 continue 7615 raise plumbing.convert_error_to_porcelain(e) from e 7616 break 7617 7618 resp = models.SecretStoreHealthcheckResponse() 7619 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7620 plumbing_response.rate_limit) 7621 return resp
SecretStoreHealths exposes health states for secret stores.
See strongdm.models.SecretStoreHealth.
def
list(self, filter, *args, timeout=None)
7549 def list(self, filter, *args, timeout=None): 7550 ''' 7551 List reports the health status of node to secret store pairs. 7552 ''' 7553 deadline = None if timeout is None else time.time() + timeout 7554 req = SecretStoreHealthListRequest() 7555 req.meta.CopyFrom(ListRequestMetadata()) 7556 if self.parent.page_limit > 0: 7557 req.meta.limit = self.parent.page_limit 7558 if self.parent.snapshot_datetime is not None: 7559 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7560 7561 req.filter = plumbing.quote_filter_args(filter, *args) 7562 7563 def generator(svc, req): 7564 tries = 0 7565 while True: 7566 t = None if deadline is None else deadline - time.time() 7567 try: 7568 plumbing_response = svc.stub.List( 7569 req, 7570 metadata=svc.parent.get_metadata( 7571 'SecretStoreHealths.List', req), 7572 timeout=t) 7573 except Exception as e: 7574 if self.parent.shouldRetry(tries, e, deadline): 7575 tries += 1 7576 time.sleep( 7577 self.parent.exponentialBackoff(tries, deadline)) 7578 continue 7579 raise plumbing.convert_error_to_porcelain(e) from e 7580 tries = 0 7581 for plumbing_item in plumbing_response.secret_store_healths: 7582 yield plumbing.convert_secret_store_health_to_porcelain( 7583 plumbing_item) 7584 if plumbing_response.meta.next_cursor == '': 7585 break 7586 req.meta.cursor = plumbing_response.meta.next_cursor 7587 7588 return generator(self, req)
List reports the health status of node to secret store pairs.
def
healthcheck(self, secret_store_id, timeout=None)
7590 def healthcheck(self, secret_store_id, timeout=None): 7591 ''' 7592 Healthcheck triggers a remote healthcheck request for a secret store. It may take minutes 7593 to propagate across a large network of Nodes. The call will return immediately, and the 7594 updated health of the Secret Store can be retrieved via List. 7595 ''' 7596 deadline = None if timeout is None else time.time() + timeout 7597 req = SecretStoreHealthcheckRequest() 7598 7599 req.secret_store_id = (secret_store_id) 7600 tries = 0 7601 plumbing_response = None 7602 while True: 7603 t = None if deadline is None else deadline - time.time() 7604 try: 7605 plumbing_response = self.stub.Healthcheck( 7606 req, 7607 metadata=self.parent.get_metadata( 7608 'SecretStoreHealths.Healthcheck', req), 7609 timeout=t) 7610 except Exception as e: 7611 if self.parent.shouldRetry(tries, e, deadline): 7612 tries += 1 7613 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7614 continue 7615 raise plumbing.convert_error_to_porcelain(e) from e 7616 break 7617 7618 resp = models.SecretStoreHealthcheckResponse() 7619 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7620 plumbing_response.rate_limit) 7621 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:
7624class SecretStoresHistory: 7625 ''' 7626 SecretStoresHistory records all changes to the state of a SecretStore. 7627 See `strongdm.models.SecretStoreHistory`. 7628 ''' 7629 def __init__(self, channel, client): 7630 self.parent = client 7631 self.stub = SecretStoresHistoryStub(channel) 7632 7633 def list(self, filter, *args, timeout=None): 7634 ''' 7635 List gets a list of SecretStoreHistory records matching a given set of criteria. 7636 ''' 7637 deadline = None if timeout is None else time.time() + timeout 7638 req = SecretStoreHistoryListRequest() 7639 req.meta.CopyFrom(ListRequestMetadata()) 7640 if self.parent.page_limit > 0: 7641 req.meta.limit = self.parent.page_limit 7642 if self.parent.snapshot_datetime is not None: 7643 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7644 7645 req.filter = plumbing.quote_filter_args(filter, *args) 7646 7647 def generator(svc, req): 7648 tries = 0 7649 while True: 7650 t = None if deadline is None else deadline - time.time() 7651 try: 7652 plumbing_response = svc.stub.List( 7653 req, 7654 metadata=svc.parent.get_metadata( 7655 'SecretStoresHistory.List', req), 7656 timeout=t) 7657 except Exception as e: 7658 if self.parent.shouldRetry(tries, e, deadline): 7659 tries += 1 7660 time.sleep( 7661 self.parent.exponentialBackoff(tries, deadline)) 7662 continue 7663 raise plumbing.convert_error_to_porcelain(e) from e 7664 tries = 0 7665 for plumbing_item in plumbing_response.history: 7666 yield plumbing.convert_secret_store_history_to_porcelain( 7667 plumbing_item) 7668 if plumbing_response.meta.next_cursor == '': 7669 break 7670 req.meta.cursor = plumbing_response.meta.next_cursor 7671 7672 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)
7633 def list(self, filter, *args, timeout=None): 7634 ''' 7635 List gets a list of SecretStoreHistory records matching a given set of criteria. 7636 ''' 7637 deadline = None if timeout is None else time.time() + timeout 7638 req = SecretStoreHistoryListRequest() 7639 req.meta.CopyFrom(ListRequestMetadata()) 7640 if self.parent.page_limit > 0: 7641 req.meta.limit = self.parent.page_limit 7642 if self.parent.snapshot_datetime is not None: 7643 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7644 7645 req.filter = plumbing.quote_filter_args(filter, *args) 7646 7647 def generator(svc, req): 7648 tries = 0 7649 while True: 7650 t = None if deadline is None else deadline - time.time() 7651 try: 7652 plumbing_response = svc.stub.List( 7653 req, 7654 metadata=svc.parent.get_metadata( 7655 'SecretStoresHistory.List', req), 7656 timeout=t) 7657 except Exception as e: 7658 if self.parent.shouldRetry(tries, e, deadline): 7659 tries += 1 7660 time.sleep( 7661 self.parent.exponentialBackoff(tries, deadline)) 7662 continue 7663 raise plumbing.convert_error_to_porcelain(e) from e 7664 tries = 0 7665 for plumbing_item in plumbing_response.history: 7666 yield plumbing.convert_secret_store_history_to_porcelain( 7667 plumbing_item) 7668 if plumbing_response.meta.next_cursor == '': 7669 break 7670 req.meta.cursor = plumbing_response.meta.next_cursor 7671 7672 return generator(self, req)
List gets a list of SecretStoreHistory records matching a given set of criteria.
class
WorkflowApprovers:
7675class WorkflowApprovers: 7676 ''' 7677 WorkflowApprovers is an account or a role with the ability to approve requests bound to a workflow. 7678 See `strongdm.models.WorkflowApprover`. 7679 ''' 7680 def __init__(self, channel, client): 7681 self.parent = client 7682 self.stub = WorkflowApproversStub(channel) 7683 7684 def create(self, workflow_approver, timeout=None): 7685 ''' 7686 Create creates a new workflow approver 7687 ''' 7688 deadline = None if timeout is None else time.time() + timeout 7689 req = WorkflowApproversCreateRequest() 7690 7691 if workflow_approver is not None: 7692 req.workflow_approver.CopyFrom( 7693 plumbing.convert_workflow_approver_to_plumbing( 7694 workflow_approver)) 7695 tries = 0 7696 plumbing_response = None 7697 while True: 7698 t = None if deadline is None else deadline - time.time() 7699 try: 7700 plumbing_response = self.stub.Create( 7701 req, 7702 metadata=self.parent.get_metadata( 7703 'WorkflowApprovers.Create', req), 7704 timeout=t) 7705 except Exception as e: 7706 if self.parent.shouldRetry(tries, e, deadline): 7707 tries += 1 7708 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7709 continue 7710 raise plumbing.convert_error_to_porcelain(e) from e 7711 break 7712 7713 resp = models.WorkflowApproversCreateResponse() 7714 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7715 plumbing_response.rate_limit) 7716 resp.workflow_approver = plumbing.convert_workflow_approver_to_porcelain( 7717 plumbing_response.workflow_approver) 7718 return resp 7719 7720 def get(self, id, timeout=None): 7721 ''' 7722 Get reads one workflow approver by ID. 7723 ''' 7724 deadline = None if timeout is None else time.time() + timeout 7725 req = WorkflowApproverGetRequest() 7726 if self.parent.snapshot_datetime is not None: 7727 req.meta.CopyFrom(GetRequestMetadata()) 7728 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7729 7730 req.id = (id) 7731 tries = 0 7732 plumbing_response = None 7733 while True: 7734 t = None if deadline is None else deadline - time.time() 7735 try: 7736 plumbing_response = self.stub.Get( 7737 req, 7738 metadata=self.parent.get_metadata('WorkflowApprovers.Get', 7739 req), 7740 timeout=t) 7741 except Exception as e: 7742 if self.parent.shouldRetry(tries, e, deadline): 7743 tries += 1 7744 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7745 continue 7746 raise plumbing.convert_error_to_porcelain(e) from e 7747 break 7748 7749 resp = models.WorkflowApproverGetResponse() 7750 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 7751 plumbing_response.meta) 7752 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7753 plumbing_response.rate_limit) 7754 resp.workflow_approver = plumbing.convert_workflow_approver_to_porcelain( 7755 plumbing_response.workflow_approver) 7756 return resp 7757 7758 def delete(self, id, timeout=None): 7759 ''' 7760 Delete deletes a workflow approver 7761 ''' 7762 deadline = None if timeout is None else time.time() + timeout 7763 req = WorkflowApproversDeleteRequest() 7764 7765 req.id = (id) 7766 tries = 0 7767 plumbing_response = None 7768 while True: 7769 t = None if deadline is None else deadline - time.time() 7770 try: 7771 plumbing_response = self.stub.Delete( 7772 req, 7773 metadata=self.parent.get_metadata( 7774 'WorkflowApprovers.Delete', req), 7775 timeout=t) 7776 except Exception as e: 7777 if self.parent.shouldRetry(tries, e, deadline): 7778 tries += 1 7779 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7780 continue 7781 raise plumbing.convert_error_to_porcelain(e) from e 7782 break 7783 7784 resp = models.WorkflowApproversDeleteResponse() 7785 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7786 plumbing_response.rate_limit) 7787 return resp 7788 7789 def list(self, filter, *args, timeout=None): 7790 ''' 7791 Lists existing workflow approvers. 7792 ''' 7793 deadline = None if timeout is None else time.time() + timeout 7794 req = WorkflowApproversListRequest() 7795 req.meta.CopyFrom(ListRequestMetadata()) 7796 if self.parent.page_limit > 0: 7797 req.meta.limit = self.parent.page_limit 7798 if self.parent.snapshot_datetime is not None: 7799 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7800 7801 req.filter = plumbing.quote_filter_args(filter, *args) 7802 7803 def generator(svc, req): 7804 tries = 0 7805 while True: 7806 t = None if deadline is None else deadline - time.time() 7807 try: 7808 plumbing_response = svc.stub.List( 7809 req, 7810 metadata=svc.parent.get_metadata( 7811 'WorkflowApprovers.List', req), 7812 timeout=t) 7813 except Exception as e: 7814 if self.parent.shouldRetry(tries, e, deadline): 7815 tries += 1 7816 time.sleep( 7817 self.parent.exponentialBackoff(tries, deadline)) 7818 continue 7819 raise plumbing.convert_error_to_porcelain(e) from e 7820 tries = 0 7821 for plumbing_item in plumbing_response.workflow_approvers: 7822 yield plumbing.convert_workflow_approver_to_porcelain( 7823 plumbing_item) 7824 if plumbing_response.meta.next_cursor == '': 7825 break 7826 req.meta.cursor = plumbing_response.meta.next_cursor 7827 7828 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)
7684 def create(self, workflow_approver, timeout=None): 7685 ''' 7686 Create creates a new workflow approver 7687 ''' 7688 deadline = None if timeout is None else time.time() + timeout 7689 req = WorkflowApproversCreateRequest() 7690 7691 if workflow_approver is not None: 7692 req.workflow_approver.CopyFrom( 7693 plumbing.convert_workflow_approver_to_plumbing( 7694 workflow_approver)) 7695 tries = 0 7696 plumbing_response = None 7697 while True: 7698 t = None if deadline is None else deadline - time.time() 7699 try: 7700 plumbing_response = self.stub.Create( 7701 req, 7702 metadata=self.parent.get_metadata( 7703 'WorkflowApprovers.Create', req), 7704 timeout=t) 7705 except Exception as e: 7706 if self.parent.shouldRetry(tries, e, deadline): 7707 tries += 1 7708 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7709 continue 7710 raise plumbing.convert_error_to_porcelain(e) from e 7711 break 7712 7713 resp = models.WorkflowApproversCreateResponse() 7714 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7715 plumbing_response.rate_limit) 7716 resp.workflow_approver = plumbing.convert_workflow_approver_to_porcelain( 7717 plumbing_response.workflow_approver) 7718 return resp
Create creates a new workflow approver
def
get(self, id, timeout=None)
7720 def get(self, id, timeout=None): 7721 ''' 7722 Get reads one workflow approver by ID. 7723 ''' 7724 deadline = None if timeout is None else time.time() + timeout 7725 req = WorkflowApproverGetRequest() 7726 if self.parent.snapshot_datetime is not None: 7727 req.meta.CopyFrom(GetRequestMetadata()) 7728 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7729 7730 req.id = (id) 7731 tries = 0 7732 plumbing_response = None 7733 while True: 7734 t = None if deadline is None else deadline - time.time() 7735 try: 7736 plumbing_response = self.stub.Get( 7737 req, 7738 metadata=self.parent.get_metadata('WorkflowApprovers.Get', 7739 req), 7740 timeout=t) 7741 except Exception as e: 7742 if self.parent.shouldRetry(tries, e, deadline): 7743 tries += 1 7744 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7745 continue 7746 raise plumbing.convert_error_to_porcelain(e) from e 7747 break 7748 7749 resp = models.WorkflowApproverGetResponse() 7750 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 7751 plumbing_response.meta) 7752 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7753 plumbing_response.rate_limit) 7754 resp.workflow_approver = plumbing.convert_workflow_approver_to_porcelain( 7755 plumbing_response.workflow_approver) 7756 return resp
Get reads one workflow approver by ID.
def
delete(self, id, timeout=None)
7758 def delete(self, id, timeout=None): 7759 ''' 7760 Delete deletes a workflow approver 7761 ''' 7762 deadline = None if timeout is None else time.time() + timeout 7763 req = WorkflowApproversDeleteRequest() 7764 7765 req.id = (id) 7766 tries = 0 7767 plumbing_response = None 7768 while True: 7769 t = None if deadline is None else deadline - time.time() 7770 try: 7771 plumbing_response = self.stub.Delete( 7772 req, 7773 metadata=self.parent.get_metadata( 7774 'WorkflowApprovers.Delete', req), 7775 timeout=t) 7776 except Exception as e: 7777 if self.parent.shouldRetry(tries, e, deadline): 7778 tries += 1 7779 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7780 continue 7781 raise plumbing.convert_error_to_porcelain(e) from e 7782 break 7783 7784 resp = models.WorkflowApproversDeleteResponse() 7785 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7786 plumbing_response.rate_limit) 7787 return resp
Delete deletes a workflow approver
def
list(self, filter, *args, timeout=None)
7789 def list(self, filter, *args, timeout=None): 7790 ''' 7791 Lists existing workflow approvers. 7792 ''' 7793 deadline = None if timeout is None else time.time() + timeout 7794 req = WorkflowApproversListRequest() 7795 req.meta.CopyFrom(ListRequestMetadata()) 7796 if self.parent.page_limit > 0: 7797 req.meta.limit = self.parent.page_limit 7798 if self.parent.snapshot_datetime is not None: 7799 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7800 7801 req.filter = plumbing.quote_filter_args(filter, *args) 7802 7803 def generator(svc, req): 7804 tries = 0 7805 while True: 7806 t = None if deadline is None else deadline - time.time() 7807 try: 7808 plumbing_response = svc.stub.List( 7809 req, 7810 metadata=svc.parent.get_metadata( 7811 'WorkflowApprovers.List', req), 7812 timeout=t) 7813 except Exception as e: 7814 if self.parent.shouldRetry(tries, e, deadline): 7815 tries += 1 7816 time.sleep( 7817 self.parent.exponentialBackoff(tries, deadline)) 7818 continue 7819 raise plumbing.convert_error_to_porcelain(e) from e 7820 tries = 0 7821 for plumbing_item in plumbing_response.workflow_approvers: 7822 yield plumbing.convert_workflow_approver_to_porcelain( 7823 plumbing_item) 7824 if plumbing_response.meta.next_cursor == '': 7825 break 7826 req.meta.cursor = plumbing_response.meta.next_cursor 7827 7828 return generator(self, req)
Lists existing workflow approvers.
class
SnapshotWorkflowApprovers:
7831class SnapshotWorkflowApprovers: 7832 ''' 7833 SnapshotWorkflowApprovers exposes the read only methods of the WorkflowApprovers 7834 service for historical queries. 7835 ''' 7836 def __init__(self, workflow_approvers): 7837 self.workflow_approvers = workflow_approvers 7838 7839 def get(self, id, timeout=None): 7840 ''' 7841 Get reads one workflow approver by ID. 7842 ''' 7843 return self.workflow_approvers.get(id, timeout=timeout) 7844 7845 def list(self, filter, *args, timeout=None): 7846 ''' 7847 Lists existing workflow approvers. 7848 ''' 7849 return self.workflow_approvers.list(filter, *args, timeout=timeout)
SnapshotWorkflowApprovers exposes the read only methods of the WorkflowApprovers service for historical queries.
class
WorkflowApproversHistory:
7852class WorkflowApproversHistory: 7853 ''' 7854 WorkflowApproversHistory provides records of all changes to the state of a WorkflowApprover. 7855 See `strongdm.models.WorkflowApproverHistory`. 7856 ''' 7857 def __init__(self, channel, client): 7858 self.parent = client 7859 self.stub = WorkflowApproversHistoryStub(channel) 7860 7861 def list(self, filter, *args, timeout=None): 7862 ''' 7863 List gets a list of WorkflowApproversHistory records matching a given set of criteria. 7864 ''' 7865 deadline = None if timeout is None else time.time() + timeout 7866 req = WorkflowApproversHistoryListRequest() 7867 req.meta.CopyFrom(ListRequestMetadata()) 7868 if self.parent.page_limit > 0: 7869 req.meta.limit = self.parent.page_limit 7870 if self.parent.snapshot_datetime is not None: 7871 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7872 7873 req.filter = plumbing.quote_filter_args(filter, *args) 7874 7875 def generator(svc, req): 7876 tries = 0 7877 while True: 7878 t = None if deadline is None else deadline - time.time() 7879 try: 7880 plumbing_response = svc.stub.List( 7881 req, 7882 metadata=svc.parent.get_metadata( 7883 'WorkflowApproversHistory.List', req), 7884 timeout=t) 7885 except Exception as e: 7886 if self.parent.shouldRetry(tries, e, deadline): 7887 tries += 1 7888 time.sleep( 7889 self.parent.exponentialBackoff(tries, deadline)) 7890 continue 7891 raise plumbing.convert_error_to_porcelain(e) from e 7892 tries = 0 7893 for plumbing_item in plumbing_response.history: 7894 yield plumbing.convert_workflow_approver_history_to_porcelain( 7895 plumbing_item) 7896 if plumbing_response.meta.next_cursor == '': 7897 break 7898 req.meta.cursor = plumbing_response.meta.next_cursor 7899 7900 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)
7861 def list(self, filter, *args, timeout=None): 7862 ''' 7863 List gets a list of WorkflowApproversHistory records matching a given set of criteria. 7864 ''' 7865 deadline = None if timeout is None else time.time() + timeout 7866 req = WorkflowApproversHistoryListRequest() 7867 req.meta.CopyFrom(ListRequestMetadata()) 7868 if self.parent.page_limit > 0: 7869 req.meta.limit = self.parent.page_limit 7870 if self.parent.snapshot_datetime is not None: 7871 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7872 7873 req.filter = plumbing.quote_filter_args(filter, *args) 7874 7875 def generator(svc, req): 7876 tries = 0 7877 while True: 7878 t = None if deadline is None else deadline - time.time() 7879 try: 7880 plumbing_response = svc.stub.List( 7881 req, 7882 metadata=svc.parent.get_metadata( 7883 'WorkflowApproversHistory.List', req), 7884 timeout=t) 7885 except Exception as e: 7886 if self.parent.shouldRetry(tries, e, deadline): 7887 tries += 1 7888 time.sleep( 7889 self.parent.exponentialBackoff(tries, deadline)) 7890 continue 7891 raise plumbing.convert_error_to_porcelain(e) from e 7892 tries = 0 7893 for plumbing_item in plumbing_response.history: 7894 yield plumbing.convert_workflow_approver_history_to_porcelain( 7895 plumbing_item) 7896 if plumbing_response.meta.next_cursor == '': 7897 break 7898 req.meta.cursor = plumbing_response.meta.next_cursor 7899 7900 return generator(self, req)
List gets a list of WorkflowApproversHistory records matching a given set of criteria.
class
WorkflowRoles:
7903class WorkflowRoles: 7904 ''' 7905 WorkflowRole links a role to a workflow. The linked roles indicate which roles a user must be a part of 7906 to request access to a resource via the workflow. 7907 See `strongdm.models.WorkflowRole`. 7908 ''' 7909 def __init__(self, channel, client): 7910 self.parent = client 7911 self.stub = WorkflowRolesStub(channel) 7912 7913 def create(self, workflow_role, timeout=None): 7914 ''' 7915 Create creates a new workflow role 7916 ''' 7917 deadline = None if timeout is None else time.time() + timeout 7918 req = WorkflowRolesCreateRequest() 7919 7920 if workflow_role is not None: 7921 req.workflow_role.CopyFrom( 7922 plumbing.convert_workflow_role_to_plumbing(workflow_role)) 7923 tries = 0 7924 plumbing_response = None 7925 while True: 7926 t = None if deadline is None else deadline - time.time() 7927 try: 7928 plumbing_response = self.stub.Create( 7929 req, 7930 metadata=self.parent.get_metadata('WorkflowRoles.Create', 7931 req), 7932 timeout=t) 7933 except Exception as e: 7934 if self.parent.shouldRetry(tries, e, deadline): 7935 tries += 1 7936 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7937 continue 7938 raise plumbing.convert_error_to_porcelain(e) from e 7939 break 7940 7941 resp = models.WorkflowRolesCreateResponse() 7942 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7943 plumbing_response.rate_limit) 7944 resp.workflow_role = plumbing.convert_workflow_role_to_porcelain( 7945 plumbing_response.workflow_role) 7946 return resp 7947 7948 def get(self, id, timeout=None): 7949 ''' 7950 Get reads one workflow role by ID. 7951 ''' 7952 deadline = None if timeout is None else time.time() + timeout 7953 req = WorkflowRoleGetRequest() 7954 if self.parent.snapshot_datetime is not None: 7955 req.meta.CopyFrom(GetRequestMetadata()) 7956 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7957 7958 req.id = (id) 7959 tries = 0 7960 plumbing_response = None 7961 while True: 7962 t = None if deadline is None else deadline - time.time() 7963 try: 7964 plumbing_response = self.stub.Get( 7965 req, 7966 metadata=self.parent.get_metadata('WorkflowRoles.Get', 7967 req), 7968 timeout=t) 7969 except Exception as e: 7970 if self.parent.shouldRetry(tries, e, deadline): 7971 tries += 1 7972 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7973 continue 7974 raise plumbing.convert_error_to_porcelain(e) from e 7975 break 7976 7977 resp = models.WorkflowRoleGetResponse() 7978 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 7979 plumbing_response.meta) 7980 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7981 plumbing_response.rate_limit) 7982 resp.workflow_role = plumbing.convert_workflow_role_to_porcelain( 7983 plumbing_response.workflow_role) 7984 return resp 7985 7986 def delete(self, id, timeout=None): 7987 ''' 7988 Delete deletes a workflow role 7989 ''' 7990 deadline = None if timeout is None else time.time() + timeout 7991 req = WorkflowRolesDeleteRequest() 7992 7993 req.id = (id) 7994 tries = 0 7995 plumbing_response = None 7996 while True: 7997 t = None if deadline is None else deadline - time.time() 7998 try: 7999 plumbing_response = self.stub.Delete( 8000 req, 8001 metadata=self.parent.get_metadata('WorkflowRoles.Delete', 8002 req), 8003 timeout=t) 8004 except Exception as e: 8005 if self.parent.shouldRetry(tries, e, deadline): 8006 tries += 1 8007 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8008 continue 8009 raise plumbing.convert_error_to_porcelain(e) from e 8010 break 8011 8012 resp = models.WorkflowRolesDeleteResponse() 8013 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8014 plumbing_response.rate_limit) 8015 return resp 8016 8017 def list(self, filter, *args, timeout=None): 8018 ''' 8019 Lists existing workflow roles. 8020 ''' 8021 deadline = None if timeout is None else time.time() + timeout 8022 req = WorkflowRolesListRequest() 8023 req.meta.CopyFrom(ListRequestMetadata()) 8024 if self.parent.page_limit > 0: 8025 req.meta.limit = self.parent.page_limit 8026 if self.parent.snapshot_datetime is not None: 8027 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8028 8029 req.filter = plumbing.quote_filter_args(filter, *args) 8030 8031 def generator(svc, req): 8032 tries = 0 8033 while True: 8034 t = None if deadline is None else deadline - time.time() 8035 try: 8036 plumbing_response = svc.stub.List( 8037 req, 8038 metadata=svc.parent.get_metadata( 8039 'WorkflowRoles.List', req), 8040 timeout=t) 8041 except Exception as e: 8042 if self.parent.shouldRetry(tries, e, deadline): 8043 tries += 1 8044 time.sleep( 8045 self.parent.exponentialBackoff(tries, deadline)) 8046 continue 8047 raise plumbing.convert_error_to_porcelain(e) from e 8048 tries = 0 8049 for plumbing_item in plumbing_response.workflow_role: 8050 yield plumbing.convert_workflow_role_to_porcelain( 8051 plumbing_item) 8052 if plumbing_response.meta.next_cursor == '': 8053 break 8054 req.meta.cursor = plumbing_response.meta.next_cursor 8055 8056 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)
7913 def create(self, workflow_role, timeout=None): 7914 ''' 7915 Create creates a new workflow role 7916 ''' 7917 deadline = None if timeout is None else time.time() + timeout 7918 req = WorkflowRolesCreateRequest() 7919 7920 if workflow_role is not None: 7921 req.workflow_role.CopyFrom( 7922 plumbing.convert_workflow_role_to_plumbing(workflow_role)) 7923 tries = 0 7924 plumbing_response = None 7925 while True: 7926 t = None if deadline is None else deadline - time.time() 7927 try: 7928 plumbing_response = self.stub.Create( 7929 req, 7930 metadata=self.parent.get_metadata('WorkflowRoles.Create', 7931 req), 7932 timeout=t) 7933 except Exception as e: 7934 if self.parent.shouldRetry(tries, e, deadline): 7935 tries += 1 7936 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7937 continue 7938 raise plumbing.convert_error_to_porcelain(e) from e 7939 break 7940 7941 resp = models.WorkflowRolesCreateResponse() 7942 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7943 plumbing_response.rate_limit) 7944 resp.workflow_role = plumbing.convert_workflow_role_to_porcelain( 7945 plumbing_response.workflow_role) 7946 return resp
Create creates a new workflow role
def
get(self, id, timeout=None)
7948 def get(self, id, timeout=None): 7949 ''' 7950 Get reads one workflow role by ID. 7951 ''' 7952 deadline = None if timeout is None else time.time() + timeout 7953 req = WorkflowRoleGetRequest() 7954 if self.parent.snapshot_datetime is not None: 7955 req.meta.CopyFrom(GetRequestMetadata()) 7956 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7957 7958 req.id = (id) 7959 tries = 0 7960 plumbing_response = None 7961 while True: 7962 t = None if deadline is None else deadline - time.time() 7963 try: 7964 plumbing_response = self.stub.Get( 7965 req, 7966 metadata=self.parent.get_metadata('WorkflowRoles.Get', 7967 req), 7968 timeout=t) 7969 except Exception as e: 7970 if self.parent.shouldRetry(tries, e, deadline): 7971 tries += 1 7972 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7973 continue 7974 raise plumbing.convert_error_to_porcelain(e) from e 7975 break 7976 7977 resp = models.WorkflowRoleGetResponse() 7978 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 7979 plumbing_response.meta) 7980 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7981 plumbing_response.rate_limit) 7982 resp.workflow_role = plumbing.convert_workflow_role_to_porcelain( 7983 plumbing_response.workflow_role) 7984 return resp
Get reads one workflow role by ID.
def
delete(self, id, timeout=None)
7986 def delete(self, id, timeout=None): 7987 ''' 7988 Delete deletes a workflow role 7989 ''' 7990 deadline = None if timeout is None else time.time() + timeout 7991 req = WorkflowRolesDeleteRequest() 7992 7993 req.id = (id) 7994 tries = 0 7995 plumbing_response = None 7996 while True: 7997 t = None if deadline is None else deadline - time.time() 7998 try: 7999 plumbing_response = self.stub.Delete( 8000 req, 8001 metadata=self.parent.get_metadata('WorkflowRoles.Delete', 8002 req), 8003 timeout=t) 8004 except Exception as e: 8005 if self.parent.shouldRetry(tries, e, deadline): 8006 tries += 1 8007 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8008 continue 8009 raise plumbing.convert_error_to_porcelain(e) from e 8010 break 8011 8012 resp = models.WorkflowRolesDeleteResponse() 8013 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8014 plumbing_response.rate_limit) 8015 return resp
Delete deletes a workflow role
def
list(self, filter, *args, timeout=None)
8017 def list(self, filter, *args, timeout=None): 8018 ''' 8019 Lists existing workflow roles. 8020 ''' 8021 deadline = None if timeout is None else time.time() + timeout 8022 req = WorkflowRolesListRequest() 8023 req.meta.CopyFrom(ListRequestMetadata()) 8024 if self.parent.page_limit > 0: 8025 req.meta.limit = self.parent.page_limit 8026 if self.parent.snapshot_datetime is not None: 8027 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8028 8029 req.filter = plumbing.quote_filter_args(filter, *args) 8030 8031 def generator(svc, req): 8032 tries = 0 8033 while True: 8034 t = None if deadline is None else deadline - time.time() 8035 try: 8036 plumbing_response = svc.stub.List( 8037 req, 8038 metadata=svc.parent.get_metadata( 8039 'WorkflowRoles.List', req), 8040 timeout=t) 8041 except Exception as e: 8042 if self.parent.shouldRetry(tries, e, deadline): 8043 tries += 1 8044 time.sleep( 8045 self.parent.exponentialBackoff(tries, deadline)) 8046 continue 8047 raise plumbing.convert_error_to_porcelain(e) from e 8048 tries = 0 8049 for plumbing_item in plumbing_response.workflow_role: 8050 yield plumbing.convert_workflow_role_to_porcelain( 8051 plumbing_item) 8052 if plumbing_response.meta.next_cursor == '': 8053 break 8054 req.meta.cursor = plumbing_response.meta.next_cursor 8055 8056 return generator(self, req)
Lists existing workflow roles.
class
SnapshotWorkflowRoles:
8059class SnapshotWorkflowRoles: 8060 ''' 8061 SnapshotWorkflowRoles exposes the read only methods of the WorkflowRoles 8062 service for historical queries. 8063 ''' 8064 def __init__(self, workflow_roles): 8065 self.workflow_roles = workflow_roles 8066 8067 def get(self, id, timeout=None): 8068 ''' 8069 Get reads one workflow role by ID. 8070 ''' 8071 return self.workflow_roles.get(id, timeout=timeout) 8072 8073 def list(self, filter, *args, timeout=None): 8074 ''' 8075 Lists existing workflow roles. 8076 ''' 8077 return self.workflow_roles.list(filter, *args, timeout=timeout)
SnapshotWorkflowRoles exposes the read only methods of the WorkflowRoles service for historical queries.
class
WorkflowRolesHistory:
8080class WorkflowRolesHistory: 8081 ''' 8082 WorkflowRolesHistory provides records of all changes to the state of a WorkflowRole 8083 See `strongdm.models.WorkflowRoleHistory`. 8084 ''' 8085 def __init__(self, channel, client): 8086 self.parent = client 8087 self.stub = WorkflowRolesHistoryStub(channel) 8088 8089 def list(self, filter, *args, timeout=None): 8090 ''' 8091 List gets a list of WorkflowRolesHistory records matching a given set of criteria. 8092 ''' 8093 deadline = None if timeout is None else time.time() + timeout 8094 req = WorkflowRolesHistoryListRequest() 8095 req.meta.CopyFrom(ListRequestMetadata()) 8096 if self.parent.page_limit > 0: 8097 req.meta.limit = self.parent.page_limit 8098 if self.parent.snapshot_datetime is not None: 8099 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8100 8101 req.filter = plumbing.quote_filter_args(filter, *args) 8102 8103 def generator(svc, req): 8104 tries = 0 8105 while True: 8106 t = None if deadline is None else deadline - time.time() 8107 try: 8108 plumbing_response = svc.stub.List( 8109 req, 8110 metadata=svc.parent.get_metadata( 8111 'WorkflowRolesHistory.List', req), 8112 timeout=t) 8113 except Exception as e: 8114 if self.parent.shouldRetry(tries, e, deadline): 8115 tries += 1 8116 time.sleep( 8117 self.parent.exponentialBackoff(tries, deadline)) 8118 continue 8119 raise plumbing.convert_error_to_porcelain(e) from e 8120 tries = 0 8121 for plumbing_item in plumbing_response.history: 8122 yield plumbing.convert_workflow_role_history_to_porcelain( 8123 plumbing_item) 8124 if plumbing_response.meta.next_cursor == '': 8125 break 8126 req.meta.cursor = plumbing_response.meta.next_cursor 8127 8128 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)
8089 def list(self, filter, *args, timeout=None): 8090 ''' 8091 List gets a list of WorkflowRolesHistory records matching a given set of criteria. 8092 ''' 8093 deadline = None if timeout is None else time.time() + timeout 8094 req = WorkflowRolesHistoryListRequest() 8095 req.meta.CopyFrom(ListRequestMetadata()) 8096 if self.parent.page_limit > 0: 8097 req.meta.limit = self.parent.page_limit 8098 if self.parent.snapshot_datetime is not None: 8099 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8100 8101 req.filter = plumbing.quote_filter_args(filter, *args) 8102 8103 def generator(svc, req): 8104 tries = 0 8105 while True: 8106 t = None if deadline is None else deadline - time.time() 8107 try: 8108 plumbing_response = svc.stub.List( 8109 req, 8110 metadata=svc.parent.get_metadata( 8111 'WorkflowRolesHistory.List', req), 8112 timeout=t) 8113 except Exception as e: 8114 if self.parent.shouldRetry(tries, e, deadline): 8115 tries += 1 8116 time.sleep( 8117 self.parent.exponentialBackoff(tries, deadline)) 8118 continue 8119 raise plumbing.convert_error_to_porcelain(e) from e 8120 tries = 0 8121 for plumbing_item in plumbing_response.history: 8122 yield plumbing.convert_workflow_role_history_to_porcelain( 8123 plumbing_item) 8124 if plumbing_response.meta.next_cursor == '': 8125 break 8126 req.meta.cursor = plumbing_response.meta.next_cursor 8127 8128 return generator(self, req)
List gets a list of WorkflowRolesHistory records matching a given set of criteria.
class
Workflows:
8131class Workflows: 8132 ''' 8133 Workflows are the collection of rules that define the resources to which access can be requested, 8134 the users that can request that access, and the mechanism for approving those requests which can either 8135 be automatic approval or a set of users authorized to approve the requests. 8136 See `strongdm.models.Workflow`. 8137 ''' 8138 def __init__(self, channel, client): 8139 self.parent = client 8140 self.stub = WorkflowsStub(channel) 8141 8142 def create(self, workflow, timeout=None): 8143 ''' 8144 Create creates a new workflow and requires a name for the workflow. 8145 ''' 8146 deadline = None if timeout is None else time.time() + timeout 8147 req = WorkflowCreateRequest() 8148 8149 if workflow is not None: 8150 req.workflow.CopyFrom( 8151 plumbing.convert_workflow_to_plumbing(workflow)) 8152 tries = 0 8153 plumbing_response = None 8154 while True: 8155 t = None if deadline is None else deadline - time.time() 8156 try: 8157 plumbing_response = self.stub.Create( 8158 req, 8159 metadata=self.parent.get_metadata('Workflows.Create', req), 8160 timeout=t) 8161 except Exception as e: 8162 if self.parent.shouldRetry(tries, e, deadline): 8163 tries += 1 8164 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8165 continue 8166 raise plumbing.convert_error_to_porcelain(e) from e 8167 break 8168 8169 resp = models.WorkflowCreateResponse() 8170 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8171 plumbing_response.rate_limit) 8172 resp.workflow = plumbing.convert_workflow_to_porcelain( 8173 plumbing_response.workflow) 8174 return resp 8175 8176 def get(self, id, timeout=None): 8177 ''' 8178 Get reads one workflow by ID. 8179 ''' 8180 deadline = None if timeout is None else time.time() + timeout 8181 req = WorkflowGetRequest() 8182 if self.parent.snapshot_datetime is not None: 8183 req.meta.CopyFrom(GetRequestMetadata()) 8184 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8185 8186 req.id = (id) 8187 tries = 0 8188 plumbing_response = None 8189 while True: 8190 t = None if deadline is None else deadline - time.time() 8191 try: 8192 plumbing_response = self.stub.Get( 8193 req, 8194 metadata=self.parent.get_metadata('Workflows.Get', req), 8195 timeout=t) 8196 except Exception as e: 8197 if self.parent.shouldRetry(tries, e, deadline): 8198 tries += 1 8199 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8200 continue 8201 raise plumbing.convert_error_to_porcelain(e) from e 8202 break 8203 8204 resp = models.WorkflowGetResponse() 8205 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 8206 plumbing_response.meta) 8207 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8208 plumbing_response.rate_limit) 8209 resp.workflow = plumbing.convert_workflow_to_porcelain( 8210 plumbing_response.workflow) 8211 return resp 8212 8213 def delete(self, id, timeout=None): 8214 ''' 8215 Delete deletes an existing workflow. 8216 ''' 8217 deadline = None if timeout is None else time.time() + timeout 8218 req = WorkflowDeleteRequest() 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.Delete( 8227 req, 8228 metadata=self.parent.get_metadata('Workflows.Delete', 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.WorkflowDeleteResponse() 8239 resp.id = (plumbing_response.id) 8240 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8241 plumbing_response.rate_limit) 8242 return resp 8243 8244 def update(self, workflow, timeout=None): 8245 ''' 8246 Update updates an existing workflow. 8247 ''' 8248 deadline = None if timeout is None else time.time() + timeout 8249 req = WorkflowUpdateRequest() 8250 8251 if workflow is not None: 8252 req.workflow.CopyFrom( 8253 plumbing.convert_workflow_to_plumbing(workflow)) 8254 tries = 0 8255 plumbing_response = None 8256 while True: 8257 t = None if deadline is None else deadline - time.time() 8258 try: 8259 plumbing_response = self.stub.Update( 8260 req, 8261 metadata=self.parent.get_metadata('Workflows.Update', req), 8262 timeout=t) 8263 except Exception as e: 8264 if self.parent.shouldRetry(tries, e, deadline): 8265 tries += 1 8266 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8267 continue 8268 raise plumbing.convert_error_to_porcelain(e) from e 8269 break 8270 8271 resp = models.WorkflowUpdateResponse() 8272 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8273 plumbing_response.rate_limit) 8274 resp.workflow = plumbing.convert_workflow_to_porcelain( 8275 plumbing_response.workflow) 8276 return resp 8277 8278 def list(self, filter, *args, timeout=None): 8279 ''' 8280 Lists existing workflows. 8281 ''' 8282 deadline = None if timeout is None else time.time() + timeout 8283 req = WorkflowListRequest() 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 'Workflows.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.workflows: 8311 yield plumbing.convert_workflow_to_porcelain(plumbing_item) 8312 if plumbing_response.meta.next_cursor == '': 8313 break 8314 req.meta.cursor = plumbing_response.meta.next_cursor 8315 8316 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)
8142 def create(self, workflow, timeout=None): 8143 ''' 8144 Create creates a new workflow and requires a name for the workflow. 8145 ''' 8146 deadline = None if timeout is None else time.time() + timeout 8147 req = WorkflowCreateRequest() 8148 8149 if workflow is not None: 8150 req.workflow.CopyFrom( 8151 plumbing.convert_workflow_to_plumbing(workflow)) 8152 tries = 0 8153 plumbing_response = None 8154 while True: 8155 t = None if deadline is None else deadline - time.time() 8156 try: 8157 plumbing_response = self.stub.Create( 8158 req, 8159 metadata=self.parent.get_metadata('Workflows.Create', req), 8160 timeout=t) 8161 except Exception as e: 8162 if self.parent.shouldRetry(tries, e, deadline): 8163 tries += 1 8164 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8165 continue 8166 raise plumbing.convert_error_to_porcelain(e) from e 8167 break 8168 8169 resp = models.WorkflowCreateResponse() 8170 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8171 plumbing_response.rate_limit) 8172 resp.workflow = plumbing.convert_workflow_to_porcelain( 8173 plumbing_response.workflow) 8174 return resp
Create creates a new workflow and requires a name for the workflow.
def
get(self, id, timeout=None)
8176 def get(self, id, timeout=None): 8177 ''' 8178 Get reads one workflow by ID. 8179 ''' 8180 deadline = None if timeout is None else time.time() + timeout 8181 req = WorkflowGetRequest() 8182 if self.parent.snapshot_datetime is not None: 8183 req.meta.CopyFrom(GetRequestMetadata()) 8184 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8185 8186 req.id = (id) 8187 tries = 0 8188 plumbing_response = None 8189 while True: 8190 t = None if deadline is None else deadline - time.time() 8191 try: 8192 plumbing_response = self.stub.Get( 8193 req, 8194 metadata=self.parent.get_metadata('Workflows.Get', req), 8195 timeout=t) 8196 except Exception as e: 8197 if self.parent.shouldRetry(tries, e, deadline): 8198 tries += 1 8199 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8200 continue 8201 raise plumbing.convert_error_to_porcelain(e) from e 8202 break 8203 8204 resp = models.WorkflowGetResponse() 8205 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 8206 plumbing_response.meta) 8207 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8208 plumbing_response.rate_limit) 8209 resp.workflow = plumbing.convert_workflow_to_porcelain( 8210 plumbing_response.workflow) 8211 return resp
Get reads one workflow by ID.
def
delete(self, id, timeout=None)
8213 def delete(self, id, timeout=None): 8214 ''' 8215 Delete deletes an existing workflow. 8216 ''' 8217 deadline = None if timeout is None else time.time() + timeout 8218 req = WorkflowDeleteRequest() 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.Delete( 8227 req, 8228 metadata=self.parent.get_metadata('Workflows.Delete', 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.WorkflowDeleteResponse() 8239 resp.id = (plumbing_response.id) 8240 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8241 plumbing_response.rate_limit) 8242 return resp
Delete deletes an existing workflow.
def
update(self, workflow, timeout=None)
8244 def update(self, workflow, timeout=None): 8245 ''' 8246 Update updates an existing workflow. 8247 ''' 8248 deadline = None if timeout is None else time.time() + timeout 8249 req = WorkflowUpdateRequest() 8250 8251 if workflow is not None: 8252 req.workflow.CopyFrom( 8253 plumbing.convert_workflow_to_plumbing(workflow)) 8254 tries = 0 8255 plumbing_response = None 8256 while True: 8257 t = None if deadline is None else deadline - time.time() 8258 try: 8259 plumbing_response = self.stub.Update( 8260 req, 8261 metadata=self.parent.get_metadata('Workflows.Update', req), 8262 timeout=t) 8263 except Exception as e: 8264 if self.parent.shouldRetry(tries, e, deadline): 8265 tries += 1 8266 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8267 continue 8268 raise plumbing.convert_error_to_porcelain(e) from e 8269 break 8270 8271 resp = models.WorkflowUpdateResponse() 8272 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8273 plumbing_response.rate_limit) 8274 resp.workflow = plumbing.convert_workflow_to_porcelain( 8275 plumbing_response.workflow) 8276 return resp
Update updates an existing workflow.
def
list(self, filter, *args, timeout=None)
8278 def list(self, filter, *args, timeout=None): 8279 ''' 8280 Lists existing workflows. 8281 ''' 8282 deadline = None if timeout is None else time.time() + timeout 8283 req = WorkflowListRequest() 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 'Workflows.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.workflows: 8311 yield plumbing.convert_workflow_to_porcelain(plumbing_item) 8312 if plumbing_response.meta.next_cursor == '': 8313 break 8314 req.meta.cursor = plumbing_response.meta.next_cursor 8315 8316 return generator(self, req)
Lists existing workflows.
class
SnapshotWorkflows:
8319class SnapshotWorkflows: 8320 ''' 8321 SnapshotWorkflows exposes the read only methods of the Workflows 8322 service for historical queries. 8323 ''' 8324 def __init__(self, workflows): 8325 self.workflows = workflows 8326 8327 def get(self, id, timeout=None): 8328 ''' 8329 Get reads one workflow by ID. 8330 ''' 8331 return self.workflows.get(id, timeout=timeout) 8332 8333 def list(self, filter, *args, timeout=None): 8334 ''' 8335 Lists existing workflows. 8336 ''' 8337 return self.workflows.list(filter, *args, timeout=timeout)
SnapshotWorkflows exposes the read only methods of the Workflows service for historical queries.
class
WorkflowsHistory:
8340class WorkflowsHistory: 8341 ''' 8342 WorkflowsHistory provides records of all changes to the state of a Workflow. 8343 See `strongdm.models.WorkflowHistory`. 8344 ''' 8345 def __init__(self, channel, client): 8346 self.parent = client 8347 self.stub = WorkflowsHistoryStub(channel) 8348 8349 def list(self, filter, *args, timeout=None): 8350 ''' 8351 List gets a list of WorkflowHistory records matching a given set of criteria. 8352 ''' 8353 deadline = None if timeout is None else time.time() + timeout 8354 req = WorkflowHistoryListRequest() 8355 req.meta.CopyFrom(ListRequestMetadata()) 8356 if self.parent.page_limit > 0: 8357 req.meta.limit = self.parent.page_limit 8358 if self.parent.snapshot_datetime is not None: 8359 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8360 8361 req.filter = plumbing.quote_filter_args(filter, *args) 8362 8363 def generator(svc, req): 8364 tries = 0 8365 while True: 8366 t = None if deadline is None else deadline - time.time() 8367 try: 8368 plumbing_response = svc.stub.List( 8369 req, 8370 metadata=svc.parent.get_metadata( 8371 'WorkflowsHistory.List', req), 8372 timeout=t) 8373 except Exception as e: 8374 if self.parent.shouldRetry(tries, e, deadline): 8375 tries += 1 8376 time.sleep( 8377 self.parent.exponentialBackoff(tries, deadline)) 8378 continue 8379 raise plumbing.convert_error_to_porcelain(e) from e 8380 tries = 0 8381 for plumbing_item in plumbing_response.history: 8382 yield plumbing.convert_workflow_history_to_porcelain( 8383 plumbing_item) 8384 if plumbing_response.meta.next_cursor == '': 8385 break 8386 req.meta.cursor = plumbing_response.meta.next_cursor 8387 8388 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)
8349 def list(self, filter, *args, timeout=None): 8350 ''' 8351 List gets a list of WorkflowHistory records matching a given set of criteria. 8352 ''' 8353 deadline = None if timeout is None else time.time() + timeout 8354 req = WorkflowHistoryListRequest() 8355 req.meta.CopyFrom(ListRequestMetadata()) 8356 if self.parent.page_limit > 0: 8357 req.meta.limit = self.parent.page_limit 8358 if self.parent.snapshot_datetime is not None: 8359 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8360 8361 req.filter = plumbing.quote_filter_args(filter, *args) 8362 8363 def generator(svc, req): 8364 tries = 0 8365 while True: 8366 t = None if deadline is None else deadline - time.time() 8367 try: 8368 plumbing_response = svc.stub.List( 8369 req, 8370 metadata=svc.parent.get_metadata( 8371 'WorkflowsHistory.List', req), 8372 timeout=t) 8373 except Exception as e: 8374 if self.parent.shouldRetry(tries, e, deadline): 8375 tries += 1 8376 time.sleep( 8377 self.parent.exponentialBackoff(tries, deadline)) 8378 continue 8379 raise plumbing.convert_error_to_porcelain(e) from e 8380 tries = 0 8381 for plumbing_item in plumbing_response.history: 8382 yield plumbing.convert_workflow_history_to_porcelain( 8383 plumbing_item) 8384 if plumbing_response.meta.next_cursor == '': 8385 break 8386 req.meta.cursor = plumbing_response.meta.next_cursor 8387 8388 return generator(self, req)
List gets a list of WorkflowHistory records matching a given set of criteria.