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 .drivers_pb2 import * 34from .drivers_pb2_grpc import * 35from .account_attachments_pb2 import * 36from .account_attachments_pb2_grpc import * 37from .account_attachments_history_pb2 import * 38from .account_attachments_history_pb2_grpc import * 39from .account_grants_pb2 import * 40from .account_grants_pb2_grpc import * 41from .account_grants_history_pb2 import * 42from .account_grants_history_pb2_grpc import * 43from .account_permissions_pb2 import * 44from .account_permissions_pb2_grpc import * 45from .account_resources_pb2 import * 46from .account_resources_pb2_grpc import * 47from .account_resources_history_pb2 import * 48from .account_resources_history_pb2_grpc import * 49from .accounts_pb2 import * 50from .accounts_pb2_grpc import * 51from .accounts_groups_pb2 import * 52from .accounts_groups_pb2_grpc import * 53from .accounts_groups_history_pb2 import * 54from .accounts_groups_history_pb2_grpc import * 55from .accounts_history_pb2 import * 56from .accounts_history_pb2_grpc import * 57from .activities_pb2 import * 58from .activities_pb2_grpc import * 59from .approval_workflow_approvers_pb2 import * 60from .approval_workflow_approvers_pb2_grpc import * 61from .approval_workflow_approvers_history_pb2 import * 62from .approval_workflow_approvers_history_pb2_grpc import * 63from .approval_workflow_steps_pb2 import * 64from .approval_workflow_steps_pb2_grpc import * 65from .approval_workflow_steps_history_pb2 import * 66from .approval_workflow_steps_history_pb2_grpc import * 67from .approval_workflows_pb2 import * 68from .approval_workflows_pb2_grpc import * 69from .approval_workflows_history_pb2 import * 70from .approval_workflows_history_pb2_grpc import * 71from .control_panel_pb2 import * 72from .control_panel_pb2_grpc import * 73from .roles_pb2 import * 74from .roles_pb2_grpc import * 75from .groups_pb2 import * 76from .groups_pb2_grpc import * 77from .groups_history_pb2 import * 78from .groups_history_pb2_grpc import * 79from .groups_roles_pb2 import * 80from .groups_roles_pb2_grpc import * 81from .groups_roles_history_pb2 import * 82from .groups_roles_history_pb2_grpc import * 83from .health_checks_pb2 import * 84from .health_checks_pb2_grpc import * 85from .identity_aliases_pb2 import * 86from .identity_aliases_pb2_grpc import * 87from .identity_aliases_history_pb2 import * 88from .identity_aliases_history_pb2_grpc import * 89from .identity_sets_pb2 import * 90from .identity_sets_pb2_grpc import * 91from .identity_sets_history_pb2 import * 92from .identity_sets_history_pb2_grpc import * 93from .managed_secrets_pb2 import * 94from .managed_secrets_pb2_grpc import * 95from .nodes_pb2 import * 96from .nodes_pb2_grpc import * 97from .nodes_history_pb2 import * 98from .nodes_history_pb2_grpc import * 99from .organization_history_pb2 import * 100from .organization_history_pb2_grpc import * 101from .peering_group_nodes_pb2 import * 102from .peering_group_nodes_pb2_grpc import * 103from .peering_group_peers_pb2 import * 104from .peering_group_peers_pb2_grpc import * 105from .peering_group_resources_pb2 import * 106from .peering_group_resources_pb2_grpc import * 107from .peering_groups_pb2 import * 108from .peering_groups_pb2_grpc import * 109from .policies_pb2 import * 110from .policies_pb2_grpc import * 111from .policies_history_pb2 import * 112from .policies_history_pb2_grpc import * 113from .proxy_cluster_keys_pb2 import * 114from .proxy_cluster_keys_pb2_grpc import * 115from .queries_pb2 import * 116from .queries_pb2_grpc import * 117from .remote_identities_pb2 import * 118from .remote_identities_pb2_grpc import * 119from .remote_identities_history_pb2 import * 120from .remote_identities_history_pb2_grpc import * 121from .remote_identity_groups_pb2 import * 122from .remote_identity_groups_pb2_grpc import * 123from .remote_identity_groups_history_pb2 import * 124from .remote_identity_groups_history_pb2_grpc import * 125from .replays_pb2 import * 126from .replays_pb2_grpc import * 127from .resources_pb2 import * 128from .resources_pb2_grpc import * 129from .resources_history_pb2 import * 130from .resources_history_pb2_grpc import * 131from .role_resources_pb2 import * 132from .role_resources_pb2_grpc import * 133from .role_resources_history_pb2 import * 134from .role_resources_history_pb2_grpc import * 135from .roles_history_pb2 import * 136from .roles_history_pb2_grpc import * 137from .secret_engine_policy_pb2 import * 138from .secret_engine_policy_pb2_grpc import * 139from .secret_engine_types_pb2 import * 140from .secret_engine_types_pb2_grpc import * 141from .secret_store_types_pb2 import * 142from .secret_store_types_pb2_grpc import * 143from .secret_stores_pb2 import * 144from .secret_stores_pb2_grpc import * 145from .secret_engines_pb2 import * 146from .secret_engines_pb2_grpc import * 147from .secret_store_healths_pb2 import * 148from .secret_store_healths_pb2_grpc import * 149from .secret_stores_history_pb2 import * 150from .secret_stores_history_pb2_grpc import * 151from .workflow_approvers_pb2 import * 152from .workflow_approvers_pb2_grpc import * 153from .workflow_approvers_history_pb2 import * 154from .workflow_approvers_history_pb2_grpc import * 155from .workflow_roles_pb2 import * 156from .workflow_roles_pb2_grpc import * 157from .workflow_roles_history_pb2 import * 158from .workflow_roles_history_pb2_grpc import * 159from .workflows_pb2 import * 160from .workflows_pb2_grpc import * 161from .workflows_history_pb2 import * 162from .workflows_history_pb2_grpc import * 163import warnings 164import functools 165import time 166 167 168def deprecated(func): 169 """This is a decorator which can be used to mark functions 170 as deprecated. It will result in a warning being emitted 171 when the function is used.""" 172 @functools.wraps(func) 173 def new_func(*args, **kwargs): 174 warnings.warn("Call to deprecated function {}.".format(func.__name__), 175 category=DeprecationWarning, 176 stacklevel=2) 177 return func(*args, **kwargs) 178 179 return new_func 180 181 182class AccessRequests: 183 ''' 184 AccessRequests are requests for access to a resource that may match a Workflow. 185 See `strongdm.models.AccessRequest`. 186 ''' 187 def __init__(self, channel, client): 188 self.parent = client 189 self.stub = AccessRequestsStub(channel) 190 191 def list(self, filter, *args, timeout=None): 192 ''' 193 Lists existing access requests. 194 ''' 195 deadline = None if timeout is None else time.time() + timeout 196 req = AccessRequestListRequest() 197 req.meta.CopyFrom(ListRequestMetadata()) 198 if self.parent.page_limit > 0: 199 req.meta.limit = self.parent.page_limit 200 if self.parent.snapshot_datetime is not None: 201 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 202 203 req.filter = plumbing.quote_filter_args(filter, *args) 204 205 def generator(svc, req): 206 tries = 0 207 while True: 208 t = None if deadline is None else deadline - time.time() 209 try: 210 plumbing_response = svc.stub.List( 211 req, 212 metadata=svc.parent.get_metadata( 213 'AccessRequests.List', req), 214 timeout=t) 215 except Exception as e: 216 if self.parent.shouldRetry(tries, e, deadline): 217 tries += 1 218 time.sleep( 219 self.parent.exponentialBackoff(tries, deadline)) 220 continue 221 raise plumbing.convert_error_to_porcelain(e) from e 222 tries = 0 223 for plumbing_item in plumbing_response.access_requests: 224 yield plumbing.convert_access_request_to_porcelain( 225 plumbing_item) 226 if plumbing_response.meta.next_cursor == '': 227 break 228 req.meta.cursor = plumbing_response.meta.next_cursor 229 230 return generator(self, req) 231 232 233class SnapshotAccessRequests: 234 ''' 235 SnapshotAccessRequests exposes the read only methods of the AccessRequests 236 service for historical queries. 237 ''' 238 def __init__(self, access_requests): 239 self.access_requests = access_requests 240 241 def list(self, filter, *args, timeout=None): 242 ''' 243 Lists existing access requests. 244 ''' 245 return self.access_requests.list(filter, *args, timeout=timeout) 246 247 248class AccessRequestEventsHistory: 249 ''' 250 AccessRequestEventsHistory provides records of all changes to the state of an AccessRequest. 251 See `strongdm.models.AccessRequestEventHistory`. 252 ''' 253 def __init__(self, channel, client): 254 self.parent = client 255 self.stub = AccessRequestEventsHistoryStub(channel) 256 257 def list(self, filter, *args, timeout=None): 258 ''' 259 List gets a list of AccessRequestEventHistory records matching a given set of criteria. 260 ''' 261 deadline = None if timeout is None else time.time() + timeout 262 req = AccessRequestEventHistoryListRequest() 263 req.meta.CopyFrom(ListRequestMetadata()) 264 if self.parent.page_limit > 0: 265 req.meta.limit = self.parent.page_limit 266 if self.parent.snapshot_datetime is not None: 267 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 268 269 req.filter = plumbing.quote_filter_args(filter, *args) 270 271 def generator(svc, req): 272 tries = 0 273 while True: 274 t = None if deadline is None else deadline - time.time() 275 try: 276 plumbing_response = svc.stub.List( 277 req, 278 metadata=svc.parent.get_metadata( 279 'AccessRequestEventsHistory.List', req), 280 timeout=t) 281 except Exception as e: 282 if self.parent.shouldRetry(tries, e, deadline): 283 tries += 1 284 time.sleep( 285 self.parent.exponentialBackoff(tries, deadline)) 286 continue 287 raise plumbing.convert_error_to_porcelain(e) from e 288 tries = 0 289 for plumbing_item in plumbing_response.history: 290 yield plumbing.convert_access_request_event_history_to_porcelain( 291 plumbing_item) 292 if plumbing_response.meta.next_cursor == '': 293 break 294 req.meta.cursor = plumbing_response.meta.next_cursor 295 296 return generator(self, req) 297 298 299class AccessRequestsHistory: 300 ''' 301 AccessRequestsHistory provides records of all changes to the state of an AccessRequest. 302 See `strongdm.models.AccessRequestHistory`. 303 ''' 304 def __init__(self, channel, client): 305 self.parent = client 306 self.stub = AccessRequestsHistoryStub(channel) 307 308 def list(self, filter, *args, timeout=None): 309 ''' 310 List gets a list of AccessRequestHistory records matching a given set of criteria. 311 ''' 312 deadline = None if timeout is None else time.time() + timeout 313 req = AccessRequestHistoryListRequest() 314 req.meta.CopyFrom(ListRequestMetadata()) 315 if self.parent.page_limit > 0: 316 req.meta.limit = self.parent.page_limit 317 if self.parent.snapshot_datetime is not None: 318 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 319 320 req.filter = plumbing.quote_filter_args(filter, *args) 321 322 def generator(svc, req): 323 tries = 0 324 while True: 325 t = None if deadline is None else deadline - time.time() 326 try: 327 plumbing_response = svc.stub.List( 328 req, 329 metadata=svc.parent.get_metadata( 330 'AccessRequestsHistory.List', req), 331 timeout=t) 332 except Exception as e: 333 if self.parent.shouldRetry(tries, e, deadline): 334 tries += 1 335 time.sleep( 336 self.parent.exponentialBackoff(tries, deadline)) 337 continue 338 raise plumbing.convert_error_to_porcelain(e) from e 339 tries = 0 340 for plumbing_item in plumbing_response.history: 341 yield plumbing.convert_access_request_history_to_porcelain( 342 plumbing_item) 343 if plumbing_response.meta.next_cursor == '': 344 break 345 req.meta.cursor = plumbing_response.meta.next_cursor 346 347 return generator(self, req) 348 349 350class AccountAttachments: 351 ''' 352 AccountAttachments assign an account to a role. 353 See `strongdm.models.AccountAttachment`. 354 ''' 355 def __init__(self, channel, client): 356 self.parent = client 357 self.stub = AccountAttachmentsStub(channel) 358 359 def create(self, account_attachment, timeout=None): 360 ''' 361 Create registers a new AccountAttachment. 362 ''' 363 deadline = None if timeout is None else time.time() + timeout 364 req = AccountAttachmentCreateRequest() 365 366 if account_attachment is not None: 367 req.account_attachment.CopyFrom( 368 plumbing.convert_account_attachment_to_plumbing( 369 account_attachment)) 370 tries = 0 371 plumbing_response = None 372 while True: 373 t = None if deadline is None else deadline - time.time() 374 try: 375 plumbing_response = self.stub.Create( 376 req, 377 metadata=self.parent.get_metadata( 378 'AccountAttachments.Create', req), 379 timeout=t) 380 except Exception as e: 381 if self.parent.shouldRetry(tries, e, deadline): 382 tries += 1 383 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 384 continue 385 raise plumbing.convert_error_to_porcelain(e) from e 386 break 387 388 resp = models.AccountAttachmentCreateResponse() 389 resp.account_attachment = plumbing.convert_account_attachment_to_porcelain( 390 plumbing_response.account_attachment) 391 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 392 plumbing_response.meta) 393 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 394 plumbing_response.rate_limit) 395 return resp 396 397 def get(self, id, timeout=None): 398 ''' 399 Get reads one AccountAttachment by ID. 400 ''' 401 deadline = None if timeout is None else time.time() + timeout 402 req = AccountAttachmentGetRequest() 403 if self.parent.snapshot_datetime is not None: 404 req.meta.CopyFrom(GetRequestMetadata()) 405 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 406 407 req.id = (id) 408 tries = 0 409 plumbing_response = None 410 while True: 411 t = None if deadline is None else deadline - time.time() 412 try: 413 plumbing_response = self.stub.Get( 414 req, 415 metadata=self.parent.get_metadata('AccountAttachments.Get', 416 req), 417 timeout=t) 418 except Exception as e: 419 if self.parent.shouldRetry(tries, e, deadline): 420 tries += 1 421 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 422 continue 423 raise plumbing.convert_error_to_porcelain(e) from e 424 break 425 426 resp = models.AccountAttachmentGetResponse() 427 resp.account_attachment = plumbing.convert_account_attachment_to_porcelain( 428 plumbing_response.account_attachment) 429 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 430 plumbing_response.meta) 431 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 432 plumbing_response.rate_limit) 433 return resp 434 435 def delete(self, id, timeout=None): 436 ''' 437 Delete removes a AccountAttachment by ID. 438 ''' 439 deadline = None if timeout is None else time.time() + timeout 440 req = AccountAttachmentDeleteRequest() 441 442 req.id = (id) 443 tries = 0 444 plumbing_response = None 445 while True: 446 t = None if deadline is None else deadline - time.time() 447 try: 448 plumbing_response = self.stub.Delete( 449 req, 450 metadata=self.parent.get_metadata( 451 'AccountAttachments.Delete', req), 452 timeout=t) 453 except Exception as e: 454 if self.parent.shouldRetry(tries, e, deadline): 455 tries += 1 456 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 457 continue 458 raise plumbing.convert_error_to_porcelain(e) from e 459 break 460 461 resp = models.AccountAttachmentDeleteResponse() 462 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 463 plumbing_response.meta) 464 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 465 plumbing_response.rate_limit) 466 return resp 467 468 def list(self, filter, *args, timeout=None): 469 ''' 470 List gets a list of AccountAttachments matching a given set of criteria. 471 ''' 472 deadline = None if timeout is None else time.time() + timeout 473 req = AccountAttachmentListRequest() 474 req.meta.CopyFrom(ListRequestMetadata()) 475 if self.parent.page_limit > 0: 476 req.meta.limit = self.parent.page_limit 477 if self.parent.snapshot_datetime is not None: 478 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 479 480 req.filter = plumbing.quote_filter_args(filter, *args) 481 482 def generator(svc, req): 483 tries = 0 484 while True: 485 t = None if deadline is None else deadline - time.time() 486 try: 487 plumbing_response = svc.stub.List( 488 req, 489 metadata=svc.parent.get_metadata( 490 'AccountAttachments.List', req), 491 timeout=t) 492 except Exception as e: 493 if self.parent.shouldRetry(tries, e, deadline): 494 tries += 1 495 time.sleep( 496 self.parent.exponentialBackoff(tries, deadline)) 497 continue 498 raise plumbing.convert_error_to_porcelain(e) from e 499 tries = 0 500 for plumbing_item in plumbing_response.account_attachments: 501 yield plumbing.convert_account_attachment_to_porcelain( 502 plumbing_item) 503 if plumbing_response.meta.next_cursor == '': 504 break 505 req.meta.cursor = plumbing_response.meta.next_cursor 506 507 return generator(self, req) 508 509 510class SnapshotAccountAttachments: 511 ''' 512 SnapshotAccountAttachments exposes the read only methods of the AccountAttachments 513 service for historical queries. 514 ''' 515 def __init__(self, account_attachments): 516 self.account_attachments = account_attachments 517 518 def get(self, id, timeout=None): 519 ''' 520 Get reads one AccountAttachment by ID. 521 ''' 522 return self.account_attachments.get(id, timeout=timeout) 523 524 def list(self, filter, *args, timeout=None): 525 ''' 526 List gets a list of AccountAttachments matching a given set of criteria. 527 ''' 528 return self.account_attachments.list(filter, *args, timeout=timeout) 529 530 531class AccountAttachmentsHistory: 532 ''' 533 AccountAttachmentsHistory records all changes to the state of an AccountAttachment. 534 See `strongdm.models.AccountAttachmentHistory`. 535 ''' 536 def __init__(self, channel, client): 537 self.parent = client 538 self.stub = AccountAttachmentsHistoryStub(channel) 539 540 def list(self, filter, *args, timeout=None): 541 ''' 542 List gets a list of AccountAttachmentHistory records matching a given set of criteria. 543 ''' 544 deadline = None if timeout is None else time.time() + timeout 545 req = AccountAttachmentHistoryListRequest() 546 req.meta.CopyFrom(ListRequestMetadata()) 547 if self.parent.page_limit > 0: 548 req.meta.limit = self.parent.page_limit 549 if self.parent.snapshot_datetime is not None: 550 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 551 552 req.filter = plumbing.quote_filter_args(filter, *args) 553 554 def generator(svc, req): 555 tries = 0 556 while True: 557 t = None if deadline is None else deadline - time.time() 558 try: 559 plumbing_response = svc.stub.List( 560 req, 561 metadata=svc.parent.get_metadata( 562 'AccountAttachmentsHistory.List', req), 563 timeout=t) 564 except Exception as e: 565 if self.parent.shouldRetry(tries, e, deadline): 566 tries += 1 567 time.sleep( 568 self.parent.exponentialBackoff(tries, deadline)) 569 continue 570 raise plumbing.convert_error_to_porcelain(e) from e 571 tries = 0 572 for plumbing_item in plumbing_response.history: 573 yield plumbing.convert_account_attachment_history_to_porcelain( 574 plumbing_item) 575 if plumbing_response.meta.next_cursor == '': 576 break 577 req.meta.cursor = plumbing_response.meta.next_cursor 578 579 return generator(self, req) 580 581 582class AccountGrants: 583 ''' 584 AccountGrants assign a resource directly to an account, giving the account the permission to connect to that resource. 585 See `strongdm.models.AccountGrant`. 586 ''' 587 def __init__(self, channel, client): 588 self.parent = client 589 self.stub = AccountGrantsStub(channel) 590 591 def create(self, account_grant, timeout=None): 592 ''' 593 Create registers a new AccountGrant. 594 ''' 595 deadline = None if timeout is None else time.time() + timeout 596 req = AccountGrantCreateRequest() 597 598 if account_grant is not None: 599 req.account_grant.CopyFrom( 600 plumbing.convert_account_grant_to_plumbing(account_grant)) 601 tries = 0 602 plumbing_response = None 603 while True: 604 t = None if deadline is None else deadline - time.time() 605 try: 606 plumbing_response = self.stub.Create( 607 req, 608 metadata=self.parent.get_metadata('AccountGrants.Create', 609 req), 610 timeout=t) 611 except Exception as e: 612 if self.parent.shouldRetry(tries, e, deadline): 613 tries += 1 614 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 615 continue 616 raise plumbing.convert_error_to_porcelain(e) from e 617 break 618 619 resp = models.AccountGrantCreateResponse() 620 resp.account_grant = plumbing.convert_account_grant_to_porcelain( 621 plumbing_response.account_grant) 622 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 623 plumbing_response.meta) 624 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 625 plumbing_response.rate_limit) 626 return resp 627 628 def get(self, id, timeout=None): 629 ''' 630 Get reads one AccountGrant by ID. 631 ''' 632 deadline = None if timeout is None else time.time() + timeout 633 req = AccountGrantGetRequest() 634 if self.parent.snapshot_datetime is not None: 635 req.meta.CopyFrom(GetRequestMetadata()) 636 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 637 638 req.id = (id) 639 tries = 0 640 plumbing_response = None 641 while True: 642 t = None if deadline is None else deadline - time.time() 643 try: 644 plumbing_response = self.stub.Get( 645 req, 646 metadata=self.parent.get_metadata('AccountGrants.Get', 647 req), 648 timeout=t) 649 except Exception as e: 650 if self.parent.shouldRetry(tries, e, deadline): 651 tries += 1 652 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 653 continue 654 raise plumbing.convert_error_to_porcelain(e) from e 655 break 656 657 resp = models.AccountGrantGetResponse() 658 resp.account_grant = plumbing.convert_account_grant_to_porcelain( 659 plumbing_response.account_grant) 660 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 661 plumbing_response.meta) 662 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 663 plumbing_response.rate_limit) 664 return resp 665 666 def delete(self, id, timeout=None): 667 ''' 668 Delete removes a AccountGrant by ID. 669 ''' 670 deadline = None if timeout is None else time.time() + timeout 671 req = AccountGrantDeleteRequest() 672 673 req.id = (id) 674 tries = 0 675 plumbing_response = None 676 while True: 677 t = None if deadline is None else deadline - time.time() 678 try: 679 plumbing_response = self.stub.Delete( 680 req, 681 metadata=self.parent.get_metadata('AccountGrants.Delete', 682 req), 683 timeout=t) 684 except Exception as e: 685 if self.parent.shouldRetry(tries, e, deadline): 686 tries += 1 687 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 688 continue 689 raise plumbing.convert_error_to_porcelain(e) from e 690 break 691 692 resp = models.AccountGrantDeleteResponse() 693 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 694 plumbing_response.meta) 695 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 696 plumbing_response.rate_limit) 697 return resp 698 699 def list(self, filter, *args, timeout=None): 700 ''' 701 List gets a list of AccountGrants matching a given set of criteria. 702 ''' 703 deadline = None if timeout is None else time.time() + timeout 704 req = AccountGrantListRequest() 705 req.meta.CopyFrom(ListRequestMetadata()) 706 if self.parent.page_limit > 0: 707 req.meta.limit = self.parent.page_limit 708 if self.parent.snapshot_datetime is not None: 709 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 710 711 req.filter = plumbing.quote_filter_args(filter, *args) 712 713 def generator(svc, req): 714 tries = 0 715 while True: 716 t = None if deadline is None else deadline - time.time() 717 try: 718 plumbing_response = svc.stub.List( 719 req, 720 metadata=svc.parent.get_metadata( 721 'AccountGrants.List', req), 722 timeout=t) 723 except Exception as e: 724 if self.parent.shouldRetry(tries, e, deadline): 725 tries += 1 726 time.sleep( 727 self.parent.exponentialBackoff(tries, deadline)) 728 continue 729 raise plumbing.convert_error_to_porcelain(e) from e 730 tries = 0 731 for plumbing_item in plumbing_response.account_grants: 732 yield plumbing.convert_account_grant_to_porcelain( 733 plumbing_item) 734 if plumbing_response.meta.next_cursor == '': 735 break 736 req.meta.cursor = plumbing_response.meta.next_cursor 737 738 return generator(self, req) 739 740 741class SnapshotAccountGrants: 742 ''' 743 SnapshotAccountGrants exposes the read only methods of the AccountGrants 744 service for historical queries. 745 ''' 746 def __init__(self, account_grants): 747 self.account_grants = account_grants 748 749 def get(self, id, timeout=None): 750 ''' 751 Get reads one AccountGrant by ID. 752 ''' 753 return self.account_grants.get(id, timeout=timeout) 754 755 def list(self, filter, *args, timeout=None): 756 ''' 757 List gets a list of AccountGrants matching a given set of criteria. 758 ''' 759 return self.account_grants.list(filter, *args, timeout=timeout) 760 761 762class AccountGrantsHistory: 763 ''' 764 AccountGrantsHistory records all changes to the state of an AccountGrant. 765 See `strongdm.models.AccountGrantHistory`. 766 ''' 767 def __init__(self, channel, client): 768 self.parent = client 769 self.stub = AccountGrantsHistoryStub(channel) 770 771 def list(self, filter, *args, timeout=None): 772 ''' 773 List gets a list of AccountGrantHistory records matching a given set of criteria. 774 ''' 775 deadline = None if timeout is None else time.time() + timeout 776 req = AccountGrantHistoryListRequest() 777 req.meta.CopyFrom(ListRequestMetadata()) 778 if self.parent.page_limit > 0: 779 req.meta.limit = self.parent.page_limit 780 if self.parent.snapshot_datetime is not None: 781 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 782 783 req.filter = plumbing.quote_filter_args(filter, *args) 784 785 def generator(svc, req): 786 tries = 0 787 while True: 788 t = None if deadline is None else deadline - time.time() 789 try: 790 plumbing_response = svc.stub.List( 791 req, 792 metadata=svc.parent.get_metadata( 793 'AccountGrantsHistory.List', req), 794 timeout=t) 795 except Exception as e: 796 if self.parent.shouldRetry(tries, e, deadline): 797 tries += 1 798 time.sleep( 799 self.parent.exponentialBackoff(tries, deadline)) 800 continue 801 raise plumbing.convert_error_to_porcelain(e) from e 802 tries = 0 803 for plumbing_item in plumbing_response.history: 804 yield plumbing.convert_account_grant_history_to_porcelain( 805 plumbing_item) 806 if plumbing_response.meta.next_cursor == '': 807 break 808 req.meta.cursor = plumbing_response.meta.next_cursor 809 810 return generator(self, req) 811 812 813class AccountPermissions: 814 ''' 815 AccountPermissions records the granular permissions accounts have, allowing them to execute 816 relevant commands via StrongDM's APIs. 817 See `strongdm.models.AccountPermission`. 818 ''' 819 def __init__(self, channel, client): 820 self.parent = client 821 self.stub = AccountPermissionsStub(channel) 822 823 def list(self, filter, *args, timeout=None): 824 ''' 825 List gets a list of Permission records matching a given set of criteria. 826 ''' 827 deadline = None if timeout is None else time.time() + timeout 828 req = AccountPermissionListRequest() 829 req.meta.CopyFrom(ListRequestMetadata()) 830 if self.parent.page_limit > 0: 831 req.meta.limit = self.parent.page_limit 832 if self.parent.snapshot_datetime is not None: 833 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 834 835 req.filter = plumbing.quote_filter_args(filter, *args) 836 837 def generator(svc, req): 838 tries = 0 839 while True: 840 t = None if deadline is None else deadline - time.time() 841 try: 842 plumbing_response = svc.stub.List( 843 req, 844 metadata=svc.parent.get_metadata( 845 'AccountPermissions.List', req), 846 timeout=t) 847 except Exception as e: 848 if self.parent.shouldRetry(tries, e, deadline): 849 tries += 1 850 time.sleep( 851 self.parent.exponentialBackoff(tries, deadline)) 852 continue 853 raise plumbing.convert_error_to_porcelain(e) from e 854 tries = 0 855 for plumbing_item in plumbing_response.permissions: 856 yield plumbing.convert_account_permission_to_porcelain( 857 plumbing_item) 858 if plumbing_response.meta.next_cursor == '': 859 break 860 req.meta.cursor = plumbing_response.meta.next_cursor 861 862 return generator(self, req) 863 864 865class SnapshotAccountPermissions: 866 ''' 867 SnapshotAccountPermissions exposes the read only methods of the AccountPermissions 868 service for historical queries. 869 ''' 870 def __init__(self, account_permissions): 871 self.account_permissions = account_permissions 872 873 def list(self, filter, *args, timeout=None): 874 ''' 875 List gets a list of Permission records matching a given set of criteria. 876 ''' 877 return self.account_permissions.list(filter, *args, timeout=timeout) 878 879 880class AccountResources: 881 ''' 882 AccountResources enumerates the resources to which accounts have access. 883 The AccountResources service is read-only. 884 See `strongdm.models.AccountResource`. 885 ''' 886 def __init__(self, channel, client): 887 self.parent = client 888 self.stub = AccountResourcesStub(channel) 889 890 def list(self, filter, *args, timeout=None): 891 ''' 892 List gets a list of AccountResource records matching a given set of criteria. 893 ''' 894 deadline = None if timeout is None else time.time() + timeout 895 req = AccountResourceListRequest() 896 req.meta.CopyFrom(ListRequestMetadata()) 897 if self.parent.page_limit > 0: 898 req.meta.limit = self.parent.page_limit 899 if self.parent.snapshot_datetime is not None: 900 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 901 902 req.filter = plumbing.quote_filter_args(filter, *args) 903 904 def generator(svc, req): 905 tries = 0 906 while True: 907 t = None if deadline is None else deadline - time.time() 908 try: 909 plumbing_response = svc.stub.List( 910 req, 911 metadata=svc.parent.get_metadata( 912 'AccountResources.List', req), 913 timeout=t) 914 except Exception as e: 915 if self.parent.shouldRetry(tries, e, deadline): 916 tries += 1 917 time.sleep( 918 self.parent.exponentialBackoff(tries, deadline)) 919 continue 920 raise plumbing.convert_error_to_porcelain(e) from e 921 tries = 0 922 for plumbing_item in plumbing_response.account_resources: 923 yield plumbing.convert_account_resource_to_porcelain( 924 plumbing_item) 925 if plumbing_response.meta.next_cursor == '': 926 break 927 req.meta.cursor = plumbing_response.meta.next_cursor 928 929 return generator(self, req) 930 931 932class SnapshotAccountResources: 933 ''' 934 SnapshotAccountResources exposes the read only methods of the AccountResources 935 service for historical queries. 936 ''' 937 def __init__(self, account_resources): 938 self.account_resources = account_resources 939 940 def list(self, filter, *args, timeout=None): 941 ''' 942 List gets a list of AccountResource records matching a given set of criteria. 943 ''' 944 return self.account_resources.list(filter, *args, timeout=timeout) 945 946 947class AccountResourcesHistory: 948 ''' 949 AccountResourcesHistory records all changes to the state of a AccountResource. 950 See `strongdm.models.AccountResourceHistory`. 951 ''' 952 def __init__(self, channel, client): 953 self.parent = client 954 self.stub = AccountResourcesHistoryStub(channel) 955 956 def list(self, filter, *args, timeout=None): 957 ''' 958 List gets a list of AccountResourceHistory records matching a given set of criteria. 959 ''' 960 deadline = None if timeout is None else time.time() + timeout 961 req = AccountResourceHistoryListRequest() 962 req.meta.CopyFrom(ListRequestMetadata()) 963 if self.parent.page_limit > 0: 964 req.meta.limit = self.parent.page_limit 965 if self.parent.snapshot_datetime is not None: 966 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 967 968 req.filter = plumbing.quote_filter_args(filter, *args) 969 970 def generator(svc, req): 971 tries = 0 972 while True: 973 t = None if deadline is None else deadline - time.time() 974 try: 975 plumbing_response = svc.stub.List( 976 req, 977 metadata=svc.parent.get_metadata( 978 'AccountResourcesHistory.List', req), 979 timeout=t) 980 except Exception as e: 981 if self.parent.shouldRetry(tries, e, deadline): 982 tries += 1 983 time.sleep( 984 self.parent.exponentialBackoff(tries, deadline)) 985 continue 986 raise plumbing.convert_error_to_porcelain(e) from e 987 tries = 0 988 for plumbing_item in plumbing_response.history: 989 yield plumbing.convert_account_resource_history_to_porcelain( 990 plumbing_item) 991 if plumbing_response.meta.next_cursor == '': 992 break 993 req.meta.cursor = plumbing_response.meta.next_cursor 994 995 return generator(self, req) 996 997 998class Accounts: 999 ''' 1000 Accounts are users that have access to strongDM. There are two types of accounts: 1001 1. **Users:** humans who are authenticated through username and password or SSO. 1002 2. **Service Accounts:** machines that are authenticated using a service token. 1003 3. **Tokens** are access keys with permissions that can be used for authentication. 1004 See: 1005 `strongdm.models.Service` 1006 `strongdm.models.Token` 1007 `strongdm.models.User` 1008 ''' 1009 def __init__(self, channel, client): 1010 self.parent = client 1011 self.stub = AccountsStub(channel) 1012 1013 def create(self, account, timeout=None): 1014 ''' 1015 Create registers a new Account. 1016 ''' 1017 deadline = None if timeout is None else time.time() + timeout 1018 req = AccountCreateRequest() 1019 1020 if account is not None: 1021 req.account.CopyFrom(plumbing.convert_account_to_plumbing(account)) 1022 tries = 0 1023 plumbing_response = None 1024 while True: 1025 t = None if deadline is None else deadline - time.time() 1026 try: 1027 plumbing_response = self.stub.Create( 1028 req, 1029 metadata=self.parent.get_metadata('Accounts.Create', req), 1030 timeout=t) 1031 except Exception as e: 1032 if self.parent.shouldRetry(tries, e, deadline): 1033 tries += 1 1034 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1035 continue 1036 raise plumbing.convert_error_to_porcelain(e) from e 1037 break 1038 1039 resp = models.AccountCreateResponse() 1040 resp.access_key = (plumbing_response.access_key) 1041 resp.account = plumbing.convert_account_to_porcelain( 1042 plumbing_response.account) 1043 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 1044 plumbing_response.meta) 1045 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1046 plumbing_response.rate_limit) 1047 resp.secret_key = (plumbing_response.secret_key) 1048 resp.token = (plumbing_response.token) 1049 return resp 1050 1051 def get(self, id, timeout=None): 1052 ''' 1053 Get reads one Account by ID. 1054 ''' 1055 deadline = None if timeout is None else time.time() + timeout 1056 req = AccountGetRequest() 1057 if self.parent.snapshot_datetime is not None: 1058 req.meta.CopyFrom(GetRequestMetadata()) 1059 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1060 1061 req.id = (id) 1062 tries = 0 1063 plumbing_response = None 1064 while True: 1065 t = None if deadline is None else deadline - time.time() 1066 try: 1067 plumbing_response = self.stub.Get( 1068 req, 1069 metadata=self.parent.get_metadata('Accounts.Get', req), 1070 timeout=t) 1071 except Exception as e: 1072 if self.parent.shouldRetry(tries, e, deadline): 1073 tries += 1 1074 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1075 continue 1076 raise plumbing.convert_error_to_porcelain(e) from e 1077 break 1078 1079 resp = models.AccountGetResponse() 1080 resp.account = plumbing.convert_account_to_porcelain( 1081 plumbing_response.account) 1082 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1083 plumbing_response.meta) 1084 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1085 plumbing_response.rate_limit) 1086 return resp 1087 1088 def update(self, account, timeout=None): 1089 ''' 1090 Update replaces all the fields of an Account by ID. 1091 ''' 1092 deadline = None if timeout is None else time.time() + timeout 1093 req = AccountUpdateRequest() 1094 1095 if account is not None: 1096 req.account.CopyFrom(plumbing.convert_account_to_plumbing(account)) 1097 tries = 0 1098 plumbing_response = None 1099 while True: 1100 t = None if deadline is None else deadline - time.time() 1101 try: 1102 plumbing_response = self.stub.Update( 1103 req, 1104 metadata=self.parent.get_metadata('Accounts.Update', req), 1105 timeout=t) 1106 except Exception as e: 1107 if self.parent.shouldRetry(tries, e, deadline): 1108 tries += 1 1109 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1110 continue 1111 raise plumbing.convert_error_to_porcelain(e) from e 1112 break 1113 1114 resp = models.AccountUpdateResponse() 1115 resp.account = plumbing.convert_account_to_porcelain( 1116 plumbing_response.account) 1117 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 1118 plumbing_response.meta) 1119 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1120 plumbing_response.rate_limit) 1121 return resp 1122 1123 def delete(self, id, timeout=None): 1124 ''' 1125 Delete removes an Account by ID. 1126 ''' 1127 deadline = None if timeout is None else time.time() + timeout 1128 req = AccountDeleteRequest() 1129 1130 req.id = (id) 1131 tries = 0 1132 plumbing_response = None 1133 while True: 1134 t = None if deadline is None else deadline - time.time() 1135 try: 1136 plumbing_response = self.stub.Delete( 1137 req, 1138 metadata=self.parent.get_metadata('Accounts.Delete', req), 1139 timeout=t) 1140 except Exception as e: 1141 if self.parent.shouldRetry(tries, e, deadline): 1142 tries += 1 1143 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1144 continue 1145 raise plumbing.convert_error_to_porcelain(e) from e 1146 break 1147 1148 resp = models.AccountDeleteResponse() 1149 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 1150 plumbing_response.meta) 1151 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1152 plumbing_response.rate_limit) 1153 return resp 1154 1155 def list(self, filter, *args, timeout=None): 1156 ''' 1157 List gets a list of Accounts matching a given set of criteria. 1158 ''' 1159 deadline = None if timeout is None else time.time() + timeout 1160 req = AccountListRequest() 1161 req.meta.CopyFrom(ListRequestMetadata()) 1162 if self.parent.page_limit > 0: 1163 req.meta.limit = self.parent.page_limit 1164 if self.parent.snapshot_datetime is not None: 1165 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1166 1167 req.filter = plumbing.quote_filter_args(filter, *args) 1168 1169 def generator(svc, req): 1170 tries = 0 1171 while True: 1172 t = None if deadline is None else deadline - time.time() 1173 try: 1174 plumbing_response = svc.stub.List( 1175 req, 1176 metadata=svc.parent.get_metadata('Accounts.List', req), 1177 timeout=t) 1178 except Exception as e: 1179 if self.parent.shouldRetry(tries, e, deadline): 1180 tries += 1 1181 time.sleep( 1182 self.parent.exponentialBackoff(tries, deadline)) 1183 continue 1184 raise plumbing.convert_error_to_porcelain(e) from e 1185 tries = 0 1186 for plumbing_item in plumbing_response.accounts: 1187 yield plumbing.convert_account_to_porcelain(plumbing_item) 1188 if plumbing_response.meta.next_cursor == '': 1189 break 1190 req.meta.cursor = plumbing_response.meta.next_cursor 1191 1192 return generator(self, req) 1193 1194 1195class SnapshotAccounts: 1196 ''' 1197 SnapshotAccounts exposes the read only methods of the Accounts 1198 service for historical queries. 1199 ''' 1200 def __init__(self, accounts): 1201 self.accounts = accounts 1202 1203 def get(self, id, timeout=None): 1204 ''' 1205 Get reads one Account by ID. 1206 ''' 1207 return self.accounts.get(id, timeout=timeout) 1208 1209 def list(self, filter, *args, timeout=None): 1210 ''' 1211 List gets a list of Accounts matching a given set of criteria. 1212 ''' 1213 return self.accounts.list(filter, *args, timeout=timeout) 1214 1215 1216class AccountsGroups: 1217 ''' 1218 An AccountGroup links an account and a group. 1219 See `strongdm.models.AccountGroup`. 1220 ''' 1221 def __init__(self, channel, client): 1222 self.parent = client 1223 self.stub = AccountsGroupsStub(channel) 1224 1225 def create(self, account_group, timeout=None): 1226 ''' 1227 Create create a new AccountGroup. 1228 ''' 1229 deadline = None if timeout is None else time.time() + timeout 1230 req = AccountGroupCreateRequest() 1231 1232 if account_group is not None: 1233 req.account_group.CopyFrom( 1234 plumbing.convert_account_group_to_plumbing(account_group)) 1235 tries = 0 1236 plumbing_response = None 1237 while True: 1238 t = None if deadline is None else deadline - time.time() 1239 try: 1240 plumbing_response = self.stub.Create( 1241 req, 1242 metadata=self.parent.get_metadata('AccountsGroups.Create', 1243 req), 1244 timeout=t) 1245 except Exception as e: 1246 if self.parent.shouldRetry(tries, e, deadline): 1247 tries += 1 1248 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1249 continue 1250 raise plumbing.convert_error_to_porcelain(e) from e 1251 break 1252 1253 resp = models.AccountGroupCreateResponse() 1254 resp.account_group = plumbing.convert_account_group_to_porcelain( 1255 plumbing_response.account_group) 1256 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1257 plumbing_response.rate_limit) 1258 return resp 1259 1260 def get(self, id, timeout=None): 1261 ''' 1262 Get reads one AccountGroup by ID. 1263 ''' 1264 deadline = None if timeout is None else time.time() + timeout 1265 req = AccountGroupGetRequest() 1266 if self.parent.snapshot_datetime is not None: 1267 req.meta.CopyFrom(GetRequestMetadata()) 1268 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1269 1270 req.id = (id) 1271 tries = 0 1272 plumbing_response = None 1273 while True: 1274 t = None if deadline is None else deadline - time.time() 1275 try: 1276 plumbing_response = self.stub.Get( 1277 req, 1278 metadata=self.parent.get_metadata('AccountsGroups.Get', 1279 req), 1280 timeout=t) 1281 except Exception as e: 1282 if self.parent.shouldRetry(tries, e, deadline): 1283 tries += 1 1284 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1285 continue 1286 raise plumbing.convert_error_to_porcelain(e) from e 1287 break 1288 1289 resp = models.AccountGroupGetResponse() 1290 resp.account_group = plumbing.convert_account_group_to_porcelain( 1291 plumbing_response.account_group) 1292 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1293 plumbing_response.meta) 1294 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1295 plumbing_response.rate_limit) 1296 return resp 1297 1298 def delete(self, id, timeout=None): 1299 ''' 1300 Delete removes an AccountGroup by ID. 1301 ''' 1302 deadline = None if timeout is None else time.time() + timeout 1303 req = AccountGroupDeleteRequest() 1304 1305 req.id = (id) 1306 tries = 0 1307 plumbing_response = None 1308 while True: 1309 t = None if deadline is None else deadline - time.time() 1310 try: 1311 plumbing_response = self.stub.Delete( 1312 req, 1313 metadata=self.parent.get_metadata('AccountsGroups.Delete', 1314 req), 1315 timeout=t) 1316 except Exception as e: 1317 if self.parent.shouldRetry(tries, e, deadline): 1318 tries += 1 1319 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1320 continue 1321 raise plumbing.convert_error_to_porcelain(e) from e 1322 break 1323 1324 resp = models.AccountGroupDeleteResponse() 1325 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 1326 plumbing_response.meta) 1327 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1328 plumbing_response.rate_limit) 1329 return resp 1330 1331 def list(self, filter, *args, timeout=None): 1332 ''' 1333 List gets a list of AccountGroups matching a given set of criteria. 1334 ''' 1335 deadline = None if timeout is None else time.time() + timeout 1336 req = AccountGroupListRequest() 1337 req.meta.CopyFrom(ListRequestMetadata()) 1338 if self.parent.page_limit > 0: 1339 req.meta.limit = self.parent.page_limit 1340 if self.parent.snapshot_datetime is not None: 1341 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1342 1343 req.filter = plumbing.quote_filter_args(filter, *args) 1344 1345 def generator(svc, req): 1346 tries = 0 1347 while True: 1348 t = None if deadline is None else deadline - time.time() 1349 try: 1350 plumbing_response = svc.stub.List( 1351 req, 1352 metadata=svc.parent.get_metadata( 1353 'AccountsGroups.List', req), 1354 timeout=t) 1355 except Exception as e: 1356 if self.parent.shouldRetry(tries, e, deadline): 1357 tries += 1 1358 time.sleep( 1359 self.parent.exponentialBackoff(tries, deadline)) 1360 continue 1361 raise plumbing.convert_error_to_porcelain(e) from e 1362 tries = 0 1363 for plumbing_item in plumbing_response.account_groups: 1364 yield plumbing.convert_account_group_to_porcelain( 1365 plumbing_item) 1366 if plumbing_response.meta.next_cursor == '': 1367 break 1368 req.meta.cursor = plumbing_response.meta.next_cursor 1369 1370 return generator(self, req) 1371 1372 1373class SnapshotAccountsGroups: 1374 ''' 1375 SnapshotAccountsGroups exposes the read only methods of the AccountsGroups 1376 service for historical queries. 1377 ''' 1378 def __init__(self, accounts_groups): 1379 self.accounts_groups = accounts_groups 1380 1381 def get(self, id, timeout=None): 1382 ''' 1383 Get reads one AccountGroup by ID. 1384 ''' 1385 return self.accounts_groups.get(id, timeout=timeout) 1386 1387 def list(self, filter, *args, timeout=None): 1388 ''' 1389 List gets a list of AccountGroups matching a given set of criteria. 1390 ''' 1391 return self.accounts_groups.list(filter, *args, timeout=timeout) 1392 1393 1394class AccountsGroupsHistory: 1395 ''' 1396 AccountsGroupsHistory records all changes to the state of an AccountGroup. 1397 See `strongdm.models.AccountGroupHistory`. 1398 ''' 1399 def __init__(self, channel, client): 1400 self.parent = client 1401 self.stub = AccountsGroupsHistoryStub(channel) 1402 1403 def list(self, filter, *args, timeout=None): 1404 ''' 1405 List gets a list of AccountGroupHistory records matching a given set of criteria. 1406 ''' 1407 deadline = None if timeout is None else time.time() + timeout 1408 req = AccountGroupHistoryListRequest() 1409 req.meta.CopyFrom(ListRequestMetadata()) 1410 if self.parent.page_limit > 0: 1411 req.meta.limit = self.parent.page_limit 1412 if self.parent.snapshot_datetime is not None: 1413 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1414 1415 req.filter = plumbing.quote_filter_args(filter, *args) 1416 1417 def generator(svc, req): 1418 tries = 0 1419 while True: 1420 t = None if deadline is None else deadline - time.time() 1421 try: 1422 plumbing_response = svc.stub.List( 1423 req, 1424 metadata=svc.parent.get_metadata( 1425 'AccountsGroupsHistory.List', req), 1426 timeout=t) 1427 except Exception as e: 1428 if self.parent.shouldRetry(tries, e, deadline): 1429 tries += 1 1430 time.sleep( 1431 self.parent.exponentialBackoff(tries, deadline)) 1432 continue 1433 raise plumbing.convert_error_to_porcelain(e) from e 1434 tries = 0 1435 for plumbing_item in plumbing_response.history: 1436 yield plumbing.convert_account_group_history_to_porcelain( 1437 plumbing_item) 1438 if plumbing_response.meta.next_cursor == '': 1439 break 1440 req.meta.cursor = plumbing_response.meta.next_cursor 1441 1442 return generator(self, req) 1443 1444 1445class AccountsHistory: 1446 ''' 1447 AccountsHistory records all changes to the state of an Account. 1448 See `strongdm.models.AccountHistory`. 1449 ''' 1450 def __init__(self, channel, client): 1451 self.parent = client 1452 self.stub = AccountsHistoryStub(channel) 1453 1454 def list(self, filter, *args, timeout=None): 1455 ''' 1456 List gets a list of AccountHistory records matching a given set of criteria. 1457 ''' 1458 deadline = None if timeout is None else time.time() + timeout 1459 req = AccountHistoryListRequest() 1460 req.meta.CopyFrom(ListRequestMetadata()) 1461 if self.parent.page_limit > 0: 1462 req.meta.limit = self.parent.page_limit 1463 if self.parent.snapshot_datetime is not None: 1464 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1465 1466 req.filter = plumbing.quote_filter_args(filter, *args) 1467 1468 def generator(svc, req): 1469 tries = 0 1470 while True: 1471 t = None if deadline is None else deadline - time.time() 1472 try: 1473 plumbing_response = svc.stub.List( 1474 req, 1475 metadata=svc.parent.get_metadata( 1476 'AccountsHistory.List', req), 1477 timeout=t) 1478 except Exception as e: 1479 if self.parent.shouldRetry(tries, e, deadline): 1480 tries += 1 1481 time.sleep( 1482 self.parent.exponentialBackoff(tries, deadline)) 1483 continue 1484 raise plumbing.convert_error_to_porcelain(e) from e 1485 tries = 0 1486 for plumbing_item in plumbing_response.history: 1487 yield plumbing.convert_account_history_to_porcelain( 1488 plumbing_item) 1489 if plumbing_response.meta.next_cursor == '': 1490 break 1491 req.meta.cursor = plumbing_response.meta.next_cursor 1492 1493 return generator(self, req) 1494 1495 1496class Activities: 1497 ''' 1498 An Activity is a record of an action taken against a strongDM deployment, e.g. 1499 a user creation, resource deletion, sso configuration change, etc. The Activities 1500 service is read-only. 1501 See `strongdm.models.Activity`. 1502 ''' 1503 def __init__(self, channel, client): 1504 self.parent = client 1505 self.stub = ActivitiesStub(channel) 1506 1507 def get(self, id, timeout=None): 1508 ''' 1509 Get reads one Activity by ID. 1510 ''' 1511 deadline = None if timeout is None else time.time() + timeout 1512 req = ActivityGetRequest() 1513 if self.parent.snapshot_datetime is not None: 1514 req.meta.CopyFrom(GetRequestMetadata()) 1515 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1516 1517 req.id = (id) 1518 tries = 0 1519 plumbing_response = None 1520 while True: 1521 t = None if deadline is None else deadline - time.time() 1522 try: 1523 plumbing_response = self.stub.Get( 1524 req, 1525 metadata=self.parent.get_metadata('Activities.Get', req), 1526 timeout=t) 1527 except Exception as e: 1528 if self.parent.shouldRetry(tries, e, deadline): 1529 tries += 1 1530 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1531 continue 1532 raise plumbing.convert_error_to_porcelain(e) from e 1533 break 1534 1535 resp = models.ActivityGetResponse() 1536 resp.activity = plumbing.convert_activity_to_porcelain( 1537 plumbing_response.activity) 1538 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1539 plumbing_response.meta) 1540 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1541 plumbing_response.rate_limit) 1542 return resp 1543 1544 def list(self, filter, *args, timeout=None): 1545 ''' 1546 List gets a list of Activities matching a given set of criteria. 1547 The 'before' and 'after' filters can be used to control the time 1548 range of the output activities. If not provided, one week of back 1549 of activities will be returned. 1550 ''' 1551 deadline = None if timeout is None else time.time() + timeout 1552 req = ActivityListRequest() 1553 req.meta.CopyFrom(ListRequestMetadata()) 1554 if self.parent.page_limit > 0: 1555 req.meta.limit = self.parent.page_limit 1556 if self.parent.snapshot_datetime is not None: 1557 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1558 1559 req.filter = plumbing.quote_filter_args(filter, *args) 1560 1561 def generator(svc, req): 1562 tries = 0 1563 while True: 1564 t = None if deadline is None else deadline - time.time() 1565 try: 1566 plumbing_response = svc.stub.List( 1567 req, 1568 metadata=svc.parent.get_metadata( 1569 'Activities.List', req), 1570 timeout=t) 1571 except Exception as e: 1572 if self.parent.shouldRetry(tries, e, deadline): 1573 tries += 1 1574 time.sleep( 1575 self.parent.exponentialBackoff(tries, deadline)) 1576 continue 1577 raise plumbing.convert_error_to_porcelain(e) from e 1578 tries = 0 1579 for plumbing_item in plumbing_response.activities: 1580 yield plumbing.convert_activity_to_porcelain(plumbing_item) 1581 if plumbing_response.meta.next_cursor == '': 1582 break 1583 req.meta.cursor = plumbing_response.meta.next_cursor 1584 1585 return generator(self, req) 1586 1587 1588class ApprovalWorkflowApprovers: 1589 ''' 1590 ApprovalWorkflowApprovers link approval workflow approvers to an ApprovalWorkflowStep 1591 See `strongdm.models.ApprovalWorkflowApprover`. 1592 ''' 1593 def __init__(self, channel, client): 1594 self.parent = client 1595 self.stub = ApprovalWorkflowApproversStub(channel) 1596 1597 def create(self, approval_workflow_approver, timeout=None): 1598 ''' 1599 Deprecated: Create creates a new approval workflow approver. 1600 ''' 1601 deadline = None if timeout is None else time.time() + timeout 1602 req = ApprovalWorkflowApproverCreateRequest() 1603 1604 if approval_workflow_approver is not None: 1605 req.approval_workflow_approver.CopyFrom( 1606 plumbing.convert_approval_workflow_approver_to_plumbing( 1607 approval_workflow_approver)) 1608 tries = 0 1609 plumbing_response = None 1610 while True: 1611 t = None if deadline is None else deadline - time.time() 1612 try: 1613 plumbing_response = self.stub.Create( 1614 req, 1615 metadata=self.parent.get_metadata( 1616 'ApprovalWorkflowApprovers.Create', req), 1617 timeout=t) 1618 except Exception as e: 1619 if self.parent.shouldRetry(tries, e, deadline): 1620 tries += 1 1621 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1622 continue 1623 raise plumbing.convert_error_to_porcelain(e) from e 1624 break 1625 1626 resp = models.ApprovalWorkflowApproverCreateResponse() 1627 resp.approval_workflow_approver = plumbing.convert_approval_workflow_approver_to_porcelain( 1628 plumbing_response.approval_workflow_approver) 1629 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1630 plumbing_response.rate_limit) 1631 return resp 1632 1633 def get(self, id, timeout=None): 1634 ''' 1635 Deprecated: Get reads one approval workflow approver by ID. 1636 ''' 1637 deadline = None if timeout is None else time.time() + timeout 1638 req = ApprovalWorkflowApproverGetRequest() 1639 if self.parent.snapshot_datetime is not None: 1640 req.meta.CopyFrom(GetRequestMetadata()) 1641 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1642 1643 req.id = (id) 1644 tries = 0 1645 plumbing_response = None 1646 while True: 1647 t = None if deadline is None else deadline - time.time() 1648 try: 1649 plumbing_response = self.stub.Get( 1650 req, 1651 metadata=self.parent.get_metadata( 1652 'ApprovalWorkflowApprovers.Get', req), 1653 timeout=t) 1654 except Exception as e: 1655 if self.parent.shouldRetry(tries, e, deadline): 1656 tries += 1 1657 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1658 continue 1659 raise plumbing.convert_error_to_porcelain(e) from e 1660 break 1661 1662 resp = models.ApprovalWorkflowApproverGetResponse() 1663 resp.approval_workflow_approver = plumbing.convert_approval_workflow_approver_to_porcelain( 1664 plumbing_response.approval_workflow_approver) 1665 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1666 plumbing_response.meta) 1667 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1668 plumbing_response.rate_limit) 1669 return resp 1670 1671 def delete(self, id, timeout=None): 1672 ''' 1673 Deprecated: Delete deletes an existing approval workflow approver. 1674 ''' 1675 deadline = None if timeout is None else time.time() + timeout 1676 req = ApprovalWorkflowApproverDeleteRequest() 1677 1678 req.id = (id) 1679 tries = 0 1680 plumbing_response = None 1681 while True: 1682 t = None if deadline is None else deadline - time.time() 1683 try: 1684 plumbing_response = self.stub.Delete( 1685 req, 1686 metadata=self.parent.get_metadata( 1687 'ApprovalWorkflowApprovers.Delete', req), 1688 timeout=t) 1689 except Exception as e: 1690 if self.parent.shouldRetry(tries, e, deadline): 1691 tries += 1 1692 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1693 continue 1694 raise plumbing.convert_error_to_porcelain(e) from e 1695 break 1696 1697 resp = models.ApprovalWorkflowApproverDeleteResponse() 1698 resp.id = (plumbing_response.id) 1699 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1700 plumbing_response.rate_limit) 1701 return resp 1702 1703 def list(self, filter, *args, timeout=None): 1704 ''' 1705 Deprecated: Lists existing approval workflow approvers. 1706 ''' 1707 deadline = None if timeout is None else time.time() + timeout 1708 req = ApprovalWorkflowApproverListRequest() 1709 req.meta.CopyFrom(ListRequestMetadata()) 1710 if self.parent.page_limit > 0: 1711 req.meta.limit = self.parent.page_limit 1712 if self.parent.snapshot_datetime is not None: 1713 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1714 1715 req.filter = plumbing.quote_filter_args(filter, *args) 1716 1717 def generator(svc, req): 1718 tries = 0 1719 while True: 1720 t = None if deadline is None else deadline - time.time() 1721 try: 1722 plumbing_response = svc.stub.List( 1723 req, 1724 metadata=svc.parent.get_metadata( 1725 'ApprovalWorkflowApprovers.List', req), 1726 timeout=t) 1727 except Exception as e: 1728 if self.parent.shouldRetry(tries, e, deadline): 1729 tries += 1 1730 time.sleep( 1731 self.parent.exponentialBackoff(tries, deadline)) 1732 continue 1733 raise plumbing.convert_error_to_porcelain(e) from e 1734 tries = 0 1735 for plumbing_item in plumbing_response.approval_workflow_approvers: 1736 yield plumbing.convert_approval_workflow_approver_to_porcelain( 1737 plumbing_item) 1738 if plumbing_response.meta.next_cursor == '': 1739 break 1740 req.meta.cursor = plumbing_response.meta.next_cursor 1741 1742 return generator(self, req) 1743 1744 1745class SnapshotApprovalWorkflowApprovers: 1746 ''' 1747 SnapshotApprovalWorkflowApprovers exposes the read only methods of the ApprovalWorkflowApprovers 1748 service for historical queries. 1749 ''' 1750 def __init__(self, approval_workflow_approvers): 1751 self.approval_workflow_approvers = approval_workflow_approvers 1752 1753 def get(self, id, timeout=None): 1754 ''' 1755 Deprecated: Get reads one approval workflow approver by ID. 1756 ''' 1757 return self.approval_workflow_approvers.get(id, timeout=timeout) 1758 1759 def list(self, filter, *args, timeout=None): 1760 ''' 1761 Deprecated: Lists existing approval workflow approvers. 1762 ''' 1763 return self.approval_workflow_approvers.list(filter, 1764 *args, 1765 timeout=timeout) 1766 1767 1768class ApprovalWorkflowApproversHistory: 1769 ''' 1770 ApprovalWorkflowApproversHistory records all changes to the state of an ApprovalWorkflowApprover. 1771 See `strongdm.models.ApprovalWorkflowApproverHistory`. 1772 ''' 1773 def __init__(self, channel, client): 1774 self.parent = client 1775 self.stub = ApprovalWorkflowApproversHistoryStub(channel) 1776 1777 def list(self, filter, *args, timeout=None): 1778 ''' 1779 List gets a list of ApprovalWorkflowApproverHistory records matching a given set of criteria. 1780 ''' 1781 deadline = None if timeout is None else time.time() + timeout 1782 req = ApprovalWorkflowApproverHistoryListRequest() 1783 req.meta.CopyFrom(ListRequestMetadata()) 1784 if self.parent.page_limit > 0: 1785 req.meta.limit = self.parent.page_limit 1786 if self.parent.snapshot_datetime is not None: 1787 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1788 1789 req.filter = plumbing.quote_filter_args(filter, *args) 1790 1791 def generator(svc, req): 1792 tries = 0 1793 while True: 1794 t = None if deadline is None else deadline - time.time() 1795 try: 1796 plumbing_response = svc.stub.List( 1797 req, 1798 metadata=svc.parent.get_metadata( 1799 'ApprovalWorkflowApproversHistory.List', req), 1800 timeout=t) 1801 except Exception as e: 1802 if self.parent.shouldRetry(tries, e, deadline): 1803 tries += 1 1804 time.sleep( 1805 self.parent.exponentialBackoff(tries, deadline)) 1806 continue 1807 raise plumbing.convert_error_to_porcelain(e) from e 1808 tries = 0 1809 for plumbing_item in plumbing_response.history: 1810 yield plumbing.convert_approval_workflow_approver_history_to_porcelain( 1811 plumbing_item) 1812 if plumbing_response.meta.next_cursor == '': 1813 break 1814 req.meta.cursor = plumbing_response.meta.next_cursor 1815 1816 return generator(self, req) 1817 1818 1819class ApprovalWorkflowSteps: 1820 ''' 1821 ApprovalWorkflowSteps link approval workflow steps to an ApprovalWorkflow 1822 See `strongdm.models.ApprovalWorkflowStep`. 1823 ''' 1824 def __init__(self, channel, client): 1825 self.parent = client 1826 self.stub = ApprovalWorkflowStepsStub(channel) 1827 1828 def create(self, approval_workflow_step, timeout=None): 1829 ''' 1830 Deprecated: Create creates a new approval workflow step. 1831 ''' 1832 deadline = None if timeout is None else time.time() + timeout 1833 req = ApprovalWorkflowStepCreateRequest() 1834 1835 if approval_workflow_step is not None: 1836 req.approval_workflow_step.CopyFrom( 1837 plumbing.convert_approval_workflow_step_to_plumbing( 1838 approval_workflow_step)) 1839 tries = 0 1840 plumbing_response = None 1841 while True: 1842 t = None if deadline is None else deadline - time.time() 1843 try: 1844 plumbing_response = self.stub.Create( 1845 req, 1846 metadata=self.parent.get_metadata( 1847 'ApprovalWorkflowSteps.Create', req), 1848 timeout=t) 1849 except Exception as e: 1850 if self.parent.shouldRetry(tries, e, deadline): 1851 tries += 1 1852 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1853 continue 1854 raise plumbing.convert_error_to_porcelain(e) from e 1855 break 1856 1857 resp = models.ApprovalWorkflowStepCreateResponse() 1858 resp.approval_workflow_step = plumbing.convert_approval_workflow_step_to_porcelain( 1859 plumbing_response.approval_workflow_step) 1860 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1861 plumbing_response.rate_limit) 1862 return resp 1863 1864 def get(self, id, timeout=None): 1865 ''' 1866 Deprecated: Get reads one approval workflow step by ID. 1867 ''' 1868 deadline = None if timeout is None else time.time() + timeout 1869 req = ApprovalWorkflowStepGetRequest() 1870 if self.parent.snapshot_datetime is not None: 1871 req.meta.CopyFrom(GetRequestMetadata()) 1872 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1873 1874 req.id = (id) 1875 tries = 0 1876 plumbing_response = None 1877 while True: 1878 t = None if deadline is None else deadline - time.time() 1879 try: 1880 plumbing_response = self.stub.Get( 1881 req, 1882 metadata=self.parent.get_metadata( 1883 'ApprovalWorkflowSteps.Get', req), 1884 timeout=t) 1885 except Exception as e: 1886 if self.parent.shouldRetry(tries, e, deadline): 1887 tries += 1 1888 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1889 continue 1890 raise plumbing.convert_error_to_porcelain(e) from e 1891 break 1892 1893 resp = models.ApprovalWorkflowStepGetResponse() 1894 resp.approval_workflow_step = plumbing.convert_approval_workflow_step_to_porcelain( 1895 plumbing_response.approval_workflow_step) 1896 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1897 plumbing_response.meta) 1898 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1899 plumbing_response.rate_limit) 1900 return resp 1901 1902 def delete(self, id, timeout=None): 1903 ''' 1904 Deprecated: Delete deletes an existing approval workflow step. 1905 ''' 1906 deadline = None if timeout is None else time.time() + timeout 1907 req = ApprovalWorkflowStepDeleteRequest() 1908 1909 req.id = (id) 1910 tries = 0 1911 plumbing_response = None 1912 while True: 1913 t = None if deadline is None else deadline - time.time() 1914 try: 1915 plumbing_response = self.stub.Delete( 1916 req, 1917 metadata=self.parent.get_metadata( 1918 'ApprovalWorkflowSteps.Delete', req), 1919 timeout=t) 1920 except Exception as e: 1921 if self.parent.shouldRetry(tries, e, deadline): 1922 tries += 1 1923 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1924 continue 1925 raise plumbing.convert_error_to_porcelain(e) from e 1926 break 1927 1928 resp = models.ApprovalWorkflowStepDeleteResponse() 1929 resp.id = (plumbing_response.id) 1930 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1931 plumbing_response.rate_limit) 1932 return resp 1933 1934 def list(self, filter, *args, timeout=None): 1935 ''' 1936 Deprecated: Lists existing approval workflow steps. 1937 ''' 1938 deadline = None if timeout is None else time.time() + timeout 1939 req = ApprovalWorkflowStepListRequest() 1940 req.meta.CopyFrom(ListRequestMetadata()) 1941 if self.parent.page_limit > 0: 1942 req.meta.limit = self.parent.page_limit 1943 if self.parent.snapshot_datetime is not None: 1944 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1945 1946 req.filter = plumbing.quote_filter_args(filter, *args) 1947 1948 def generator(svc, req): 1949 tries = 0 1950 while True: 1951 t = None if deadline is None else deadline - time.time() 1952 try: 1953 plumbing_response = svc.stub.List( 1954 req, 1955 metadata=svc.parent.get_metadata( 1956 'ApprovalWorkflowSteps.List', req), 1957 timeout=t) 1958 except Exception as e: 1959 if self.parent.shouldRetry(tries, e, deadline): 1960 tries += 1 1961 time.sleep( 1962 self.parent.exponentialBackoff(tries, deadline)) 1963 continue 1964 raise plumbing.convert_error_to_porcelain(e) from e 1965 tries = 0 1966 for plumbing_item in plumbing_response.approval_workflow_steps: 1967 yield plumbing.convert_approval_workflow_step_to_porcelain( 1968 plumbing_item) 1969 if plumbing_response.meta.next_cursor == '': 1970 break 1971 req.meta.cursor = plumbing_response.meta.next_cursor 1972 1973 return generator(self, req) 1974 1975 1976class SnapshotApprovalWorkflowSteps: 1977 ''' 1978 SnapshotApprovalWorkflowSteps exposes the read only methods of the ApprovalWorkflowSteps 1979 service for historical queries. 1980 ''' 1981 def __init__(self, approval_workflow_steps): 1982 self.approval_workflow_steps = approval_workflow_steps 1983 1984 def get(self, id, timeout=None): 1985 ''' 1986 Deprecated: Get reads one approval workflow step by ID. 1987 ''' 1988 return self.approval_workflow_steps.get(id, timeout=timeout) 1989 1990 def list(self, filter, *args, timeout=None): 1991 ''' 1992 Deprecated: Lists existing approval workflow steps. 1993 ''' 1994 return self.approval_workflow_steps.list(filter, 1995 *args, 1996 timeout=timeout) 1997 1998 1999class ApprovalWorkflowStepsHistory: 2000 ''' 2001 ApprovalWorkflowStepsHistory records all changes to the state of an ApprovalWorkflowStep. 2002 See `strongdm.models.ApprovalWorkflowStepHistory`. 2003 ''' 2004 def __init__(self, channel, client): 2005 self.parent = client 2006 self.stub = ApprovalWorkflowStepsHistoryStub(channel) 2007 2008 def list(self, filter, *args, timeout=None): 2009 ''' 2010 List gets a list of ApprovalWorkflowStepHistory records matching a given set of criteria. 2011 ''' 2012 deadline = None if timeout is None else time.time() + timeout 2013 req = ApprovalWorkflowStepHistoryListRequest() 2014 req.meta.CopyFrom(ListRequestMetadata()) 2015 if self.parent.page_limit > 0: 2016 req.meta.limit = self.parent.page_limit 2017 if self.parent.snapshot_datetime is not None: 2018 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2019 2020 req.filter = plumbing.quote_filter_args(filter, *args) 2021 2022 def generator(svc, req): 2023 tries = 0 2024 while True: 2025 t = None if deadline is None else deadline - time.time() 2026 try: 2027 plumbing_response = svc.stub.List( 2028 req, 2029 metadata=svc.parent.get_metadata( 2030 'ApprovalWorkflowStepsHistory.List', req), 2031 timeout=t) 2032 except Exception as e: 2033 if self.parent.shouldRetry(tries, e, deadline): 2034 tries += 1 2035 time.sleep( 2036 self.parent.exponentialBackoff(tries, deadline)) 2037 continue 2038 raise plumbing.convert_error_to_porcelain(e) from e 2039 tries = 0 2040 for plumbing_item in plumbing_response.history: 2041 yield plumbing.convert_approval_workflow_step_history_to_porcelain( 2042 plumbing_item) 2043 if plumbing_response.meta.next_cursor == '': 2044 break 2045 req.meta.cursor = plumbing_response.meta.next_cursor 2046 2047 return generator(self, req) 2048 2049 2050class ApprovalWorkflows: 2051 ''' 2052 ApprovalWorkflows are the mechanism by which requests for access can be viewed by authorized 2053 approvers and be approved or denied. 2054 See `strongdm.models.ApprovalWorkflow`. 2055 ''' 2056 def __init__(self, channel, client): 2057 self.parent = client 2058 self.stub = ApprovalWorkflowsStub(channel) 2059 2060 def create(self, approval_workflow, timeout=None): 2061 ''' 2062 Create creates a new approval workflow and requires a name and approval mode for the approval workflow. 2063 ''' 2064 deadline = None if timeout is None else time.time() + timeout 2065 req = ApprovalWorkflowCreateRequest() 2066 2067 if approval_workflow is not None: 2068 req.approval_workflow.CopyFrom( 2069 plumbing.convert_approval_workflow_to_plumbing( 2070 approval_workflow)) 2071 tries = 0 2072 plumbing_response = None 2073 while True: 2074 t = None if deadline is None else deadline - time.time() 2075 try: 2076 plumbing_response = self.stub.Create( 2077 req, 2078 metadata=self.parent.get_metadata( 2079 'ApprovalWorkflows.Create', req), 2080 timeout=t) 2081 except Exception as e: 2082 if self.parent.shouldRetry(tries, e, deadline): 2083 tries += 1 2084 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2085 continue 2086 raise plumbing.convert_error_to_porcelain(e) from e 2087 break 2088 2089 resp = models.ApprovalWorkflowCreateResponse() 2090 resp.approval_workflow = plumbing.convert_approval_workflow_to_porcelain( 2091 plumbing_response.approval_workflow) 2092 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2093 plumbing_response.rate_limit) 2094 return resp 2095 2096 def get(self, id, timeout=None): 2097 ''' 2098 Get reads one approval workflow by ID. 2099 ''' 2100 deadline = None if timeout is None else time.time() + timeout 2101 req = ApprovalWorkflowGetRequest() 2102 if self.parent.snapshot_datetime is not None: 2103 req.meta.CopyFrom(GetRequestMetadata()) 2104 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2105 2106 req.id = (id) 2107 tries = 0 2108 plumbing_response = None 2109 while True: 2110 t = None if deadline is None else deadline - time.time() 2111 try: 2112 plumbing_response = self.stub.Get( 2113 req, 2114 metadata=self.parent.get_metadata('ApprovalWorkflows.Get', 2115 req), 2116 timeout=t) 2117 except Exception as e: 2118 if self.parent.shouldRetry(tries, e, deadline): 2119 tries += 1 2120 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2121 continue 2122 raise plumbing.convert_error_to_porcelain(e) from e 2123 break 2124 2125 resp = models.ApprovalWorkflowGetResponse() 2126 resp.approval_workflow = plumbing.convert_approval_workflow_to_porcelain( 2127 plumbing_response.approval_workflow) 2128 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2129 plumbing_response.meta) 2130 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2131 plumbing_response.rate_limit) 2132 return resp 2133 2134 def delete(self, id, timeout=None): 2135 ''' 2136 Delete deletes an existing approval workflow. 2137 ''' 2138 deadline = None if timeout is None else time.time() + timeout 2139 req = ApprovalWorkflowDeleteRequest() 2140 2141 req.id = (id) 2142 tries = 0 2143 plumbing_response = None 2144 while True: 2145 t = None if deadline is None else deadline - time.time() 2146 try: 2147 plumbing_response = self.stub.Delete( 2148 req, 2149 metadata=self.parent.get_metadata( 2150 'ApprovalWorkflows.Delete', req), 2151 timeout=t) 2152 except Exception as e: 2153 if self.parent.shouldRetry(tries, e, deadline): 2154 tries += 1 2155 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2156 continue 2157 raise plumbing.convert_error_to_porcelain(e) from e 2158 break 2159 2160 resp = models.ApprovalWorkflowDeleteResponse() 2161 resp.id = (plumbing_response.id) 2162 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2163 plumbing_response.rate_limit) 2164 return resp 2165 2166 def update(self, approval_workflow, timeout=None): 2167 ''' 2168 Update updates an existing approval workflow. 2169 ''' 2170 deadline = None if timeout is None else time.time() + timeout 2171 req = ApprovalWorkflowUpdateRequest() 2172 2173 if approval_workflow is not None: 2174 req.approval_workflow.CopyFrom( 2175 plumbing.convert_approval_workflow_to_plumbing( 2176 approval_workflow)) 2177 tries = 0 2178 plumbing_response = None 2179 while True: 2180 t = None if deadline is None else deadline - time.time() 2181 try: 2182 plumbing_response = self.stub.Update( 2183 req, 2184 metadata=self.parent.get_metadata( 2185 'ApprovalWorkflows.Update', req), 2186 timeout=t) 2187 except Exception as e: 2188 if self.parent.shouldRetry(tries, e, deadline): 2189 tries += 1 2190 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2191 continue 2192 raise plumbing.convert_error_to_porcelain(e) from e 2193 break 2194 2195 resp = models.ApprovalWorkflowUpdateResponse() 2196 resp.approval_workflow = plumbing.convert_approval_workflow_to_porcelain( 2197 plumbing_response.approval_workflow) 2198 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2199 plumbing_response.rate_limit) 2200 return resp 2201 2202 def list(self, filter, *args, timeout=None): 2203 ''' 2204 Lists existing approval workflows. 2205 ''' 2206 deadline = None if timeout is None else time.time() + timeout 2207 req = ApprovalWorkflowListRequest() 2208 req.meta.CopyFrom(ListRequestMetadata()) 2209 if self.parent.page_limit > 0: 2210 req.meta.limit = self.parent.page_limit 2211 if self.parent.snapshot_datetime is not None: 2212 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2213 2214 req.filter = plumbing.quote_filter_args(filter, *args) 2215 2216 def generator(svc, req): 2217 tries = 0 2218 while True: 2219 t = None if deadline is None else deadline - time.time() 2220 try: 2221 plumbing_response = svc.stub.List( 2222 req, 2223 metadata=svc.parent.get_metadata( 2224 'ApprovalWorkflows.List', req), 2225 timeout=t) 2226 except Exception as e: 2227 if self.parent.shouldRetry(tries, e, deadline): 2228 tries += 1 2229 time.sleep( 2230 self.parent.exponentialBackoff(tries, deadline)) 2231 continue 2232 raise plumbing.convert_error_to_porcelain(e) from e 2233 tries = 0 2234 for plumbing_item in plumbing_response.approval_workflows: 2235 yield plumbing.convert_approval_workflow_to_porcelain( 2236 plumbing_item) 2237 if plumbing_response.meta.next_cursor == '': 2238 break 2239 req.meta.cursor = plumbing_response.meta.next_cursor 2240 2241 return generator(self, req) 2242 2243 2244class SnapshotApprovalWorkflows: 2245 ''' 2246 SnapshotApprovalWorkflows exposes the read only methods of the ApprovalWorkflows 2247 service for historical queries. 2248 ''' 2249 def __init__(self, approval_workflows): 2250 self.approval_workflows = approval_workflows 2251 2252 def get(self, id, timeout=None): 2253 ''' 2254 Get reads one approval workflow by ID. 2255 ''' 2256 return self.approval_workflows.get(id, timeout=timeout) 2257 2258 def list(self, filter, *args, timeout=None): 2259 ''' 2260 Lists existing approval workflows. 2261 ''' 2262 return self.approval_workflows.list(filter, *args, timeout=timeout) 2263 2264 2265class ApprovalWorkflowsHistory: 2266 ''' 2267 ApprovalWorkflowsHistory records all changes to the state of an ApprovalWorkflow. 2268 See `strongdm.models.ApprovalWorkflowHistory`. 2269 ''' 2270 def __init__(self, channel, client): 2271 self.parent = client 2272 self.stub = ApprovalWorkflowsHistoryStub(channel) 2273 2274 def list(self, filter, *args, timeout=None): 2275 ''' 2276 List gets a list of ApprovalWorkflowHistory records matching a given set of criteria. 2277 ''' 2278 deadline = None if timeout is None else time.time() + timeout 2279 req = ApprovalWorkflowHistoryListRequest() 2280 req.meta.CopyFrom(ListRequestMetadata()) 2281 if self.parent.page_limit > 0: 2282 req.meta.limit = self.parent.page_limit 2283 if self.parent.snapshot_datetime is not None: 2284 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2285 2286 req.filter = plumbing.quote_filter_args(filter, *args) 2287 2288 def generator(svc, req): 2289 tries = 0 2290 while True: 2291 t = None if deadline is None else deadline - time.time() 2292 try: 2293 plumbing_response = svc.stub.List( 2294 req, 2295 metadata=svc.parent.get_metadata( 2296 'ApprovalWorkflowsHistory.List', req), 2297 timeout=t) 2298 except Exception as e: 2299 if self.parent.shouldRetry(tries, e, deadline): 2300 tries += 1 2301 time.sleep( 2302 self.parent.exponentialBackoff(tries, deadline)) 2303 continue 2304 raise plumbing.convert_error_to_porcelain(e) from e 2305 tries = 0 2306 for plumbing_item in plumbing_response.history: 2307 yield plumbing.convert_approval_workflow_history_to_porcelain( 2308 plumbing_item) 2309 if plumbing_response.meta.next_cursor == '': 2310 break 2311 req.meta.cursor = plumbing_response.meta.next_cursor 2312 2313 return generator(self, req) 2314 2315 2316class ControlPanel: 2317 ''' 2318 ControlPanel contains all administrative controls. 2319 ''' 2320 def __init__(self, channel, client): 2321 self.parent = client 2322 self.stub = ControlPanelStub(channel) 2323 2324 def get_sshca_public_key(self, timeout=None): 2325 ''' 2326 GetSSHCAPublicKey retrieves the SSH CA public key. 2327 ''' 2328 deadline = None if timeout is None else time.time() + timeout 2329 req = ControlPanelGetSSHCAPublicKeyRequest() 2330 2331 tries = 0 2332 plumbing_response = None 2333 while True: 2334 t = None if deadline is None else deadline - time.time() 2335 try: 2336 plumbing_response = self.stub.GetSSHCAPublicKey( 2337 req, 2338 metadata=self.parent.get_metadata( 2339 'ControlPanel.GetSSHCAPublicKey', req), 2340 timeout=t) 2341 except Exception as e: 2342 if self.parent.shouldRetry(tries, e, deadline): 2343 tries += 1 2344 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2345 continue 2346 raise plumbing.convert_error_to_porcelain(e) from e 2347 break 2348 2349 resp = models.ControlPanelGetSSHCAPublicKeyResponse() 2350 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2351 plumbing_response.meta) 2352 resp.public_key = (plumbing_response.public_key) 2353 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2354 plumbing_response.rate_limit) 2355 return resp 2356 2357 def get_rdpca_public_key(self, timeout=None): 2358 ''' 2359 GetRDPCAPublicKey retrieves the RDP CA public key. 2360 ''' 2361 deadline = None if timeout is None else time.time() + timeout 2362 req = ControlPanelGetRDPCAPublicKeyRequest() 2363 2364 tries = 0 2365 plumbing_response = None 2366 while True: 2367 t = None if deadline is None else deadline - time.time() 2368 try: 2369 plumbing_response = self.stub.GetRDPCAPublicKey( 2370 req, 2371 metadata=self.parent.get_metadata( 2372 'ControlPanel.GetRDPCAPublicKey', req), 2373 timeout=t) 2374 except Exception as e: 2375 if self.parent.shouldRetry(tries, e, deadline): 2376 tries += 1 2377 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2378 continue 2379 raise plumbing.convert_error_to_porcelain(e) from e 2380 break 2381 2382 resp = models.ControlPanelGetRDPCAPublicKeyResponse() 2383 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2384 plumbing_response.meta) 2385 resp.public_key = (plumbing_response.public_key) 2386 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2387 plumbing_response.rate_limit) 2388 return resp 2389 2390 def verify_jwt(self, token, timeout=None): 2391 ''' 2392 VerifyJWT reports whether the given JWT token (x-sdm-token) is valid. 2393 ''' 2394 deadline = None if timeout is None else time.time() + timeout 2395 req = ControlPanelVerifyJWTRequest() 2396 2397 req.token = (token) 2398 tries = 0 2399 plumbing_response = None 2400 while True: 2401 t = None if deadline is None else deadline - time.time() 2402 try: 2403 plumbing_response = self.stub.VerifyJWT( 2404 req, 2405 metadata=self.parent.get_metadata('ControlPanel.VerifyJWT', 2406 req), 2407 timeout=t) 2408 except Exception as e: 2409 if self.parent.shouldRetry(tries, e, deadline): 2410 tries += 1 2411 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2412 continue 2413 raise plumbing.convert_error_to_porcelain(e) from e 2414 break 2415 2416 resp = models.ControlPanelVerifyJWTResponse() 2417 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2418 plumbing_response.meta) 2419 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2420 plumbing_response.rate_limit) 2421 resp.valid = (plumbing_response.valid) 2422 return resp 2423 2424 2425class Roles: 2426 ''' 2427 A Role has a list of access rules which determine which Resources the members 2428 of the Role have access to. An Account can be a member of multiple Roles via 2429 AccountAttachments. 2430 See `strongdm.models.Role`. 2431 ''' 2432 def __init__(self, channel, client): 2433 self.parent = client 2434 self.stub = RolesStub(channel) 2435 2436 def create(self, role, timeout=None): 2437 ''' 2438 Create registers a new Role. 2439 ''' 2440 deadline = None if timeout is None else time.time() + timeout 2441 req = RoleCreateRequest() 2442 2443 if role is not None: 2444 req.role.CopyFrom(plumbing.convert_role_to_plumbing(role)) 2445 tries = 0 2446 plumbing_response = None 2447 while True: 2448 t = None if deadline is None else deadline - time.time() 2449 try: 2450 plumbing_response = self.stub.Create( 2451 req, 2452 metadata=self.parent.get_metadata('Roles.Create', req), 2453 timeout=t) 2454 except Exception as e: 2455 if self.parent.shouldRetry(tries, e, deadline): 2456 tries += 1 2457 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2458 continue 2459 raise plumbing.convert_error_to_porcelain(e) from e 2460 break 2461 2462 resp = models.RoleCreateResponse() 2463 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 2464 plumbing_response.meta) 2465 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2466 plumbing_response.rate_limit) 2467 resp.role = plumbing.convert_role_to_porcelain(plumbing_response.role) 2468 return resp 2469 2470 def get(self, id, timeout=None): 2471 ''' 2472 Get reads one Role by ID. 2473 ''' 2474 deadline = None if timeout is None else time.time() + timeout 2475 req = RoleGetRequest() 2476 if self.parent.snapshot_datetime is not None: 2477 req.meta.CopyFrom(GetRequestMetadata()) 2478 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2479 2480 req.id = (id) 2481 tries = 0 2482 plumbing_response = None 2483 while True: 2484 t = None if deadline is None else deadline - time.time() 2485 try: 2486 plumbing_response = self.stub.Get( 2487 req, 2488 metadata=self.parent.get_metadata('Roles.Get', req), 2489 timeout=t) 2490 except Exception as e: 2491 if self.parent.shouldRetry(tries, e, deadline): 2492 tries += 1 2493 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2494 continue 2495 raise plumbing.convert_error_to_porcelain(e) from e 2496 break 2497 2498 resp = models.RoleGetResponse() 2499 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2500 plumbing_response.meta) 2501 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2502 plumbing_response.rate_limit) 2503 resp.role = plumbing.convert_role_to_porcelain(plumbing_response.role) 2504 return resp 2505 2506 def update(self, role, timeout=None): 2507 ''' 2508 Update replaces all the fields of a Role by ID. 2509 ''' 2510 deadline = None if timeout is None else time.time() + timeout 2511 req = RoleUpdateRequest() 2512 2513 if role is not None: 2514 req.role.CopyFrom(plumbing.convert_role_to_plumbing(role)) 2515 tries = 0 2516 plumbing_response = None 2517 while True: 2518 t = None if deadline is None else deadline - time.time() 2519 try: 2520 plumbing_response = self.stub.Update( 2521 req, 2522 metadata=self.parent.get_metadata('Roles.Update', req), 2523 timeout=t) 2524 except Exception as e: 2525 if self.parent.shouldRetry(tries, e, deadline): 2526 tries += 1 2527 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2528 continue 2529 raise plumbing.convert_error_to_porcelain(e) from e 2530 break 2531 2532 resp = models.RoleUpdateResponse() 2533 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 2534 plumbing_response.meta) 2535 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2536 plumbing_response.rate_limit) 2537 resp.role = plumbing.convert_role_to_porcelain(plumbing_response.role) 2538 return resp 2539 2540 def delete(self, id, timeout=None): 2541 ''' 2542 Delete removes a Role by ID. 2543 ''' 2544 deadline = None if timeout is None else time.time() + timeout 2545 req = RoleDeleteRequest() 2546 2547 req.id = (id) 2548 tries = 0 2549 plumbing_response = None 2550 while True: 2551 t = None if deadline is None else deadline - time.time() 2552 try: 2553 plumbing_response = self.stub.Delete( 2554 req, 2555 metadata=self.parent.get_metadata('Roles.Delete', req), 2556 timeout=t) 2557 except Exception as e: 2558 if self.parent.shouldRetry(tries, e, deadline): 2559 tries += 1 2560 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2561 continue 2562 raise plumbing.convert_error_to_porcelain(e) from e 2563 break 2564 2565 resp = models.RoleDeleteResponse() 2566 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 2567 plumbing_response.meta) 2568 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2569 plumbing_response.rate_limit) 2570 return resp 2571 2572 def list(self, filter, *args, timeout=None): 2573 ''' 2574 List gets a list of Roles matching a given set of criteria. 2575 ''' 2576 deadline = None if timeout is None else time.time() + timeout 2577 req = RoleListRequest() 2578 req.meta.CopyFrom(ListRequestMetadata()) 2579 if self.parent.page_limit > 0: 2580 req.meta.limit = self.parent.page_limit 2581 if self.parent.snapshot_datetime is not None: 2582 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2583 2584 req.filter = plumbing.quote_filter_args(filter, *args) 2585 2586 def generator(svc, req): 2587 tries = 0 2588 while True: 2589 t = None if deadline is None else deadline - time.time() 2590 try: 2591 plumbing_response = svc.stub.List( 2592 req, 2593 metadata=svc.parent.get_metadata('Roles.List', req), 2594 timeout=t) 2595 except Exception as e: 2596 if self.parent.shouldRetry(tries, e, deadline): 2597 tries += 1 2598 time.sleep( 2599 self.parent.exponentialBackoff(tries, deadline)) 2600 continue 2601 raise plumbing.convert_error_to_porcelain(e) from e 2602 tries = 0 2603 for plumbing_item in plumbing_response.roles: 2604 yield plumbing.convert_role_to_porcelain(plumbing_item) 2605 if plumbing_response.meta.next_cursor == '': 2606 break 2607 req.meta.cursor = plumbing_response.meta.next_cursor 2608 2609 return generator(self, req) 2610 2611 2612class SnapshotRoles: 2613 ''' 2614 SnapshotRoles exposes the read only methods of the Roles 2615 service for historical queries. 2616 ''' 2617 def __init__(self, roles): 2618 self.roles = roles 2619 2620 def get(self, id, timeout=None): 2621 ''' 2622 Get reads one Role by ID. 2623 ''' 2624 return self.roles.get(id, timeout=timeout) 2625 2626 def list(self, filter, *args, timeout=None): 2627 ''' 2628 List gets a list of Roles matching a given set of criteria. 2629 ''' 2630 return self.roles.list(filter, *args, timeout=timeout) 2631 2632 2633class Groups: 2634 ''' 2635 A Group is a set of principals. 2636 See `strongdm.models.Group`. 2637 ''' 2638 def __init__(self, channel, client): 2639 self.parent = client 2640 self.stub = GroupsStub(channel) 2641 2642 def create(self, group, timeout=None): 2643 ''' 2644 Create registers a new Group. 2645 ''' 2646 deadline = None if timeout is None else time.time() + timeout 2647 req = GroupCreateRequest() 2648 2649 if group is not None: 2650 req.group.CopyFrom(plumbing.convert_group_to_plumbing(group)) 2651 tries = 0 2652 plumbing_response = None 2653 while True: 2654 t = None if deadline is None else deadline - time.time() 2655 try: 2656 plumbing_response = self.stub.Create( 2657 req, 2658 metadata=self.parent.get_metadata('Groups.Create', req), 2659 timeout=t) 2660 except Exception as e: 2661 if self.parent.shouldRetry(tries, e, deadline): 2662 tries += 1 2663 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2664 continue 2665 raise plumbing.convert_error_to_porcelain(e) from e 2666 break 2667 2668 resp = models.GroupCreateResponse() 2669 resp.group = plumbing.convert_group_to_porcelain( 2670 plumbing_response.group) 2671 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2672 plumbing_response.rate_limit) 2673 return resp 2674 2675 def create_from_roles(self, role_ids, commit, timeout=None): 2676 deadline = None if timeout is None else time.time() + timeout 2677 req = GroupCreateFromRolesRequest() 2678 2679 req.role_ids.extend((role_ids)) 2680 req.commit = (commit) 2681 tries = 0 2682 plumbing_response = None 2683 while True: 2684 t = None if deadline is None else deadline - time.time() 2685 try: 2686 plumbing_response = self.stub.CreateFromRoles( 2687 req, 2688 metadata=self.parent.get_metadata('Groups.CreateFromRoles', 2689 req), 2690 timeout=t) 2691 except Exception as e: 2692 if self.parent.shouldRetry(tries, e, deadline): 2693 tries += 1 2694 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2695 continue 2696 raise plumbing.convert_error_to_porcelain(e) from e 2697 break 2698 2699 resp = models.GroupCreateFromRolesResponse() 2700 resp.group_from_role = plumbing.convert_repeated_group_from_role_to_porcelain( 2701 plumbing_response.group_from_role) 2702 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2703 plumbing_response.rate_limit) 2704 return resp 2705 2706 def get(self, id, timeout=None): 2707 ''' 2708 Get reads one Group by ID. 2709 ''' 2710 deadline = None if timeout is None else time.time() + timeout 2711 req = GroupGetRequest() 2712 if self.parent.snapshot_datetime is not None: 2713 req.meta.CopyFrom(GetRequestMetadata()) 2714 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2715 2716 req.id = (id) 2717 tries = 0 2718 plumbing_response = None 2719 while True: 2720 t = None if deadline is None else deadline - time.time() 2721 try: 2722 plumbing_response = self.stub.Get( 2723 req, 2724 metadata=self.parent.get_metadata('Groups.Get', req), 2725 timeout=t) 2726 except Exception as e: 2727 if self.parent.shouldRetry(tries, e, deadline): 2728 tries += 1 2729 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2730 continue 2731 raise plumbing.convert_error_to_porcelain(e) from e 2732 break 2733 2734 resp = models.GroupGetResponse() 2735 resp.group = plumbing.convert_group_to_porcelain( 2736 plumbing_response.group) 2737 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2738 plumbing_response.meta) 2739 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2740 plumbing_response.rate_limit) 2741 return resp 2742 2743 def update(self, group, timeout=None): 2744 ''' 2745 Update replaces all the fields of a Group by ID. 2746 ''' 2747 deadline = None if timeout is None else time.time() + timeout 2748 req = GroupUpdateRequest() 2749 2750 if group is not None: 2751 req.group.CopyFrom(plumbing.convert_group_to_plumbing(group)) 2752 tries = 0 2753 plumbing_response = None 2754 while True: 2755 t = None if deadline is None else deadline - time.time() 2756 try: 2757 plumbing_response = self.stub.Update( 2758 req, 2759 metadata=self.parent.get_metadata('Groups.Update', req), 2760 timeout=t) 2761 except Exception as e: 2762 if self.parent.shouldRetry(tries, e, deadline): 2763 tries += 1 2764 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2765 continue 2766 raise plumbing.convert_error_to_porcelain(e) from e 2767 break 2768 2769 resp = models.GroupUpdateResponse() 2770 resp.group = plumbing.convert_group_to_porcelain( 2771 plumbing_response.group) 2772 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2773 plumbing_response.rate_limit) 2774 return resp 2775 2776 def delete(self, id, timeout=None): 2777 ''' 2778 Delete removes a Group by ID. 2779 ''' 2780 deadline = None if timeout is None else time.time() + timeout 2781 req = GroupDeleteRequest() 2782 2783 req.id = (id) 2784 tries = 0 2785 plumbing_response = None 2786 while True: 2787 t = None if deadline is None else deadline - time.time() 2788 try: 2789 plumbing_response = self.stub.Delete( 2790 req, 2791 metadata=self.parent.get_metadata('Groups.Delete', req), 2792 timeout=t) 2793 except Exception as e: 2794 if self.parent.shouldRetry(tries, e, deadline): 2795 tries += 1 2796 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2797 continue 2798 raise plumbing.convert_error_to_porcelain(e) from e 2799 break 2800 2801 resp = models.GroupDeleteResponse() 2802 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 2803 plumbing_response.meta) 2804 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2805 plumbing_response.rate_limit) 2806 return resp 2807 2808 def list(self, filter, *args, timeout=None): 2809 ''' 2810 List gets a list of Groups matching a given set of criteria. 2811 ''' 2812 deadline = None if timeout is None else time.time() + timeout 2813 req = GroupListRequest() 2814 req.meta.CopyFrom(ListRequestMetadata()) 2815 if self.parent.page_limit > 0: 2816 req.meta.limit = self.parent.page_limit 2817 if self.parent.snapshot_datetime is not None: 2818 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2819 2820 req.filter = plumbing.quote_filter_args(filter, *args) 2821 2822 def generator(svc, req): 2823 tries = 0 2824 while True: 2825 t = None if deadline is None else deadline - time.time() 2826 try: 2827 plumbing_response = svc.stub.List( 2828 req, 2829 metadata=svc.parent.get_metadata('Groups.List', req), 2830 timeout=t) 2831 except Exception as e: 2832 if self.parent.shouldRetry(tries, e, deadline): 2833 tries += 1 2834 time.sleep( 2835 self.parent.exponentialBackoff(tries, deadline)) 2836 continue 2837 raise plumbing.convert_error_to_porcelain(e) from e 2838 tries = 0 2839 for plumbing_item in plumbing_response.groups: 2840 yield plumbing.convert_group_to_porcelain(plumbing_item) 2841 if plumbing_response.meta.next_cursor == '': 2842 break 2843 req.meta.cursor = plumbing_response.meta.next_cursor 2844 2845 return generator(self, req) 2846 2847 2848class SnapshotGroups: 2849 ''' 2850 SnapshotGroups exposes the read only methods of the Groups 2851 service for historical queries. 2852 ''' 2853 def __init__(self, groups): 2854 self.groups = groups 2855 2856 def get(self, id, timeout=None): 2857 ''' 2858 Get reads one Group by ID. 2859 ''' 2860 return self.groups.get(id, timeout=timeout) 2861 2862 def list(self, filter, *args, timeout=None): 2863 ''' 2864 List gets a list of Groups matching a given set of criteria. 2865 ''' 2866 return self.groups.list(filter, *args, timeout=timeout) 2867 2868 2869class GroupsHistory: 2870 ''' 2871 GroupsHistory records all changes to the state of a Group. 2872 See `strongdm.models.GroupHistory`. 2873 ''' 2874 def __init__(self, channel, client): 2875 self.parent = client 2876 self.stub = GroupsHistoryStub(channel) 2877 2878 def list(self, filter, *args, timeout=None): 2879 ''' 2880 List gets a list of GroupHistory records matching a given set of criteria. 2881 ''' 2882 deadline = None if timeout is None else time.time() + timeout 2883 req = GroupHistoryListRequest() 2884 req.meta.CopyFrom(ListRequestMetadata()) 2885 if self.parent.page_limit > 0: 2886 req.meta.limit = self.parent.page_limit 2887 if self.parent.snapshot_datetime is not None: 2888 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2889 2890 req.filter = plumbing.quote_filter_args(filter, *args) 2891 2892 def generator(svc, req): 2893 tries = 0 2894 while True: 2895 t = None if deadline is None else deadline - time.time() 2896 try: 2897 plumbing_response = svc.stub.List( 2898 req, 2899 metadata=svc.parent.get_metadata( 2900 'GroupsHistory.List', req), 2901 timeout=t) 2902 except Exception as e: 2903 if self.parent.shouldRetry(tries, e, deadline): 2904 tries += 1 2905 time.sleep( 2906 self.parent.exponentialBackoff(tries, deadline)) 2907 continue 2908 raise plumbing.convert_error_to_porcelain(e) from e 2909 tries = 0 2910 for plumbing_item in plumbing_response.history: 2911 yield plumbing.convert_group_history_to_porcelain( 2912 plumbing_item) 2913 if plumbing_response.meta.next_cursor == '': 2914 break 2915 req.meta.cursor = plumbing_response.meta.next_cursor 2916 2917 return generator(self, req) 2918 2919 2920class GroupsRoles: 2921 ''' 2922 A GroupRole is an assignment of a Group to a Role. 2923 See `strongdm.models.GroupRole`. 2924 ''' 2925 def __init__(self, channel, client): 2926 self.parent = client 2927 self.stub = GroupsRolesStub(channel) 2928 2929 def create(self, group_role, timeout=None): 2930 ''' 2931 Create registers a new GroupRole. 2932 ''' 2933 deadline = None if timeout is None else time.time() + timeout 2934 req = GroupRoleCreateRequest() 2935 2936 if group_role is not None: 2937 req.group_role.CopyFrom( 2938 plumbing.convert_group_role_to_plumbing(group_role)) 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.Create( 2945 req, 2946 metadata=self.parent.get_metadata('GroupsRoles.Create', 2947 req), 2948 timeout=t) 2949 except Exception as e: 2950 if self.parent.shouldRetry(tries, e, deadline): 2951 tries += 1 2952 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2953 continue 2954 raise plumbing.convert_error_to_porcelain(e) from e 2955 break 2956 2957 resp = models.GroupRoleCreateResponse() 2958 resp.group_role = plumbing.convert_group_role_to_porcelain( 2959 plumbing_response.group_role) 2960 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2961 plumbing_response.rate_limit) 2962 return resp 2963 2964 def get(self, id, timeout=None): 2965 ''' 2966 Get reads one GroupRole by ID. 2967 ''' 2968 deadline = None if timeout is None else time.time() + timeout 2969 req = GroupRoleGetRequest() 2970 if self.parent.snapshot_datetime is not None: 2971 req.meta.CopyFrom(GetRequestMetadata()) 2972 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2973 2974 req.id = (id) 2975 tries = 0 2976 plumbing_response = None 2977 while True: 2978 t = None if deadline is None else deadline - time.time() 2979 try: 2980 plumbing_response = self.stub.Get( 2981 req, 2982 metadata=self.parent.get_metadata('GroupsRoles.Get', req), 2983 timeout=t) 2984 except Exception as e: 2985 if self.parent.shouldRetry(tries, e, deadline): 2986 tries += 1 2987 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2988 continue 2989 raise plumbing.convert_error_to_porcelain(e) from e 2990 break 2991 2992 resp = models.GroupRoleGetResponse() 2993 resp.group_role = plumbing.convert_group_role_to_porcelain( 2994 plumbing_response.group_role) 2995 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2996 plumbing_response.meta) 2997 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2998 plumbing_response.rate_limit) 2999 return resp 3000 3001 def delete(self, id, timeout=None): 3002 ''' 3003 Delete removes a GroupRole by ID. 3004 ''' 3005 deadline = None if timeout is None else time.time() + timeout 3006 req = GroupRoleDeleteRequest() 3007 3008 req.id = (id) 3009 tries = 0 3010 plumbing_response = None 3011 while True: 3012 t = None if deadline is None else deadline - time.time() 3013 try: 3014 plumbing_response = self.stub.Delete( 3015 req, 3016 metadata=self.parent.get_metadata('GroupsRoles.Delete', 3017 req), 3018 timeout=t) 3019 except Exception as e: 3020 if self.parent.shouldRetry(tries, e, deadline): 3021 tries += 1 3022 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3023 continue 3024 raise plumbing.convert_error_to_porcelain(e) from e 3025 break 3026 3027 resp = models.GroupRoleDeleteResponse() 3028 resp.group_role = plumbing.convert_group_role_to_porcelain( 3029 plumbing_response.group_role) 3030 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3031 plumbing_response.meta) 3032 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3033 plumbing_response.rate_limit) 3034 return resp 3035 3036 def list(self, filter, *args, timeout=None): 3037 ''' 3038 List gets a list of GroupRoles matching a given set of criteria. 3039 ''' 3040 deadline = None if timeout is None else time.time() + timeout 3041 req = GroupRoleListRequest() 3042 req.meta.CopyFrom(ListRequestMetadata()) 3043 if self.parent.page_limit > 0: 3044 req.meta.limit = self.parent.page_limit 3045 if self.parent.snapshot_datetime is not None: 3046 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3047 3048 req.filter = plumbing.quote_filter_args(filter, *args) 3049 3050 def generator(svc, req): 3051 tries = 0 3052 while True: 3053 t = None if deadline is None else deadline - time.time() 3054 try: 3055 plumbing_response = svc.stub.List( 3056 req, 3057 metadata=svc.parent.get_metadata( 3058 'GroupsRoles.List', req), 3059 timeout=t) 3060 except Exception as e: 3061 if self.parent.shouldRetry(tries, e, deadline): 3062 tries += 1 3063 time.sleep( 3064 self.parent.exponentialBackoff(tries, deadline)) 3065 continue 3066 raise plumbing.convert_error_to_porcelain(e) from e 3067 tries = 0 3068 for plumbing_item in plumbing_response.groups_roles: 3069 yield plumbing.convert_group_role_to_porcelain( 3070 plumbing_item) 3071 if plumbing_response.meta.next_cursor == '': 3072 break 3073 req.meta.cursor = plumbing_response.meta.next_cursor 3074 3075 return generator(self, req) 3076 3077 3078class SnapshotGroupsRoles: 3079 ''' 3080 SnapshotGroupsRoles exposes the read only methods of the GroupsRoles 3081 service for historical queries. 3082 ''' 3083 def __init__(self, groups_roles): 3084 self.groups_roles = groups_roles 3085 3086 def get(self, id, timeout=None): 3087 ''' 3088 Get reads one GroupRole by ID. 3089 ''' 3090 return self.groups_roles.get(id, timeout=timeout) 3091 3092 def list(self, filter, *args, timeout=None): 3093 ''' 3094 List gets a list of GroupRoles matching a given set of criteria. 3095 ''' 3096 return self.groups_roles.list(filter, *args, timeout=timeout) 3097 3098 3099class GroupsRolesHistory: 3100 ''' 3101 GroupsRolesHistory records all changes to the state of a GroupRole. 3102 See `strongdm.models.GroupRoleHistory`. 3103 ''' 3104 def __init__(self, channel, client): 3105 self.parent = client 3106 self.stub = GroupsRolesHistoryStub(channel) 3107 3108 def list(self, filter, *args, timeout=None): 3109 ''' 3110 List gets a list of GroupRoleHistory records matching a given set of criteria. 3111 ''' 3112 deadline = None if timeout is None else time.time() + timeout 3113 req = GroupRoleHistoryListRequest() 3114 req.meta.CopyFrom(ListRequestMetadata()) 3115 if self.parent.page_limit > 0: 3116 req.meta.limit = self.parent.page_limit 3117 if self.parent.snapshot_datetime is not None: 3118 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3119 3120 req.filter = plumbing.quote_filter_args(filter, *args) 3121 3122 def generator(svc, req): 3123 tries = 0 3124 while True: 3125 t = None if deadline is None else deadline - time.time() 3126 try: 3127 plumbing_response = svc.stub.List( 3128 req, 3129 metadata=svc.parent.get_metadata( 3130 'GroupsRolesHistory.List', req), 3131 timeout=t) 3132 except Exception as e: 3133 if self.parent.shouldRetry(tries, e, deadline): 3134 tries += 1 3135 time.sleep( 3136 self.parent.exponentialBackoff(tries, deadline)) 3137 continue 3138 raise plumbing.convert_error_to_porcelain(e) from e 3139 tries = 0 3140 for plumbing_item in plumbing_response.history: 3141 yield plumbing.convert_group_role_history_to_porcelain( 3142 plumbing_item) 3143 if plumbing_response.meta.next_cursor == '': 3144 break 3145 req.meta.cursor = plumbing_response.meta.next_cursor 3146 3147 return generator(self, req) 3148 3149 3150class HealthChecks: 3151 ''' 3152 HealthChecks lists the last healthcheck between each node and resource. 3153 Note the unconventional capitalization here is to prevent having a collision with GRPC 3154 See `strongdm.models.Healthcheck`. 3155 ''' 3156 def __init__(self, channel, client): 3157 self.parent = client 3158 self.stub = HealthChecksStub(channel) 3159 3160 def list(self, filter, *args, timeout=None): 3161 ''' 3162 List gets a list of Healthchecks matching a given set of criteria. 3163 ''' 3164 deadline = None if timeout is None else time.time() + timeout 3165 req = HealthcheckListRequest() 3166 req.meta.CopyFrom(ListRequestMetadata()) 3167 if self.parent.page_limit > 0: 3168 req.meta.limit = self.parent.page_limit 3169 if self.parent.snapshot_datetime is not None: 3170 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3171 3172 req.filter = plumbing.quote_filter_args(filter, *args) 3173 3174 def generator(svc, req): 3175 tries = 0 3176 while True: 3177 t = None if deadline is None else deadline - time.time() 3178 try: 3179 plumbing_response = svc.stub.List( 3180 req, 3181 metadata=svc.parent.get_metadata( 3182 'HealthChecks.List', req), 3183 timeout=t) 3184 except Exception as e: 3185 if self.parent.shouldRetry(tries, e, deadline): 3186 tries += 1 3187 time.sleep( 3188 self.parent.exponentialBackoff(tries, deadline)) 3189 continue 3190 raise plumbing.convert_error_to_porcelain(e) from e 3191 tries = 0 3192 for plumbing_item in plumbing_response.healthchecks: 3193 yield plumbing.convert_healthcheck_to_porcelain( 3194 plumbing_item) 3195 if plumbing_response.meta.next_cursor == '': 3196 break 3197 req.meta.cursor = plumbing_response.meta.next_cursor 3198 3199 return generator(self, req) 3200 3201 3202class IdentityAliases: 3203 ''' 3204 IdentityAliases assign an alias to an account within an IdentitySet. 3205 The alias is used as the username when connecting to a identity supported resource. 3206 See `strongdm.models.IdentityAlias`. 3207 ''' 3208 def __init__(self, channel, client): 3209 self.parent = client 3210 self.stub = IdentityAliasesStub(channel) 3211 3212 def create(self, identity_alias, timeout=None): 3213 ''' 3214 Create registers a new IdentityAlias. 3215 ''' 3216 deadline = None if timeout is None else time.time() + timeout 3217 req = IdentityAliasCreateRequest() 3218 3219 if identity_alias is not None: 3220 req.identity_alias.CopyFrom( 3221 plumbing.convert_identity_alias_to_plumbing(identity_alias)) 3222 tries = 0 3223 plumbing_response = None 3224 while True: 3225 t = None if deadline is None else deadline - time.time() 3226 try: 3227 plumbing_response = self.stub.Create( 3228 req, 3229 metadata=self.parent.get_metadata('IdentityAliases.Create', 3230 req), 3231 timeout=t) 3232 except Exception as e: 3233 if self.parent.shouldRetry(tries, e, deadline): 3234 tries += 1 3235 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3236 continue 3237 raise plumbing.convert_error_to_porcelain(e) from e 3238 break 3239 3240 resp = models.IdentityAliasCreateResponse() 3241 resp.identity_alias = plumbing.convert_identity_alias_to_porcelain( 3242 plumbing_response.identity_alias) 3243 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 3244 plumbing_response.meta) 3245 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3246 plumbing_response.rate_limit) 3247 return resp 3248 3249 def get(self, id, timeout=None): 3250 ''' 3251 Get reads one IdentityAlias by ID. 3252 ''' 3253 deadline = None if timeout is None else time.time() + timeout 3254 req = IdentityAliasGetRequest() 3255 if self.parent.snapshot_datetime is not None: 3256 req.meta.CopyFrom(GetRequestMetadata()) 3257 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3258 3259 req.id = (id) 3260 tries = 0 3261 plumbing_response = None 3262 while True: 3263 t = None if deadline is None else deadline - time.time() 3264 try: 3265 plumbing_response = self.stub.Get( 3266 req, 3267 metadata=self.parent.get_metadata('IdentityAliases.Get', 3268 req), 3269 timeout=t) 3270 except Exception as e: 3271 if self.parent.shouldRetry(tries, e, deadline): 3272 tries += 1 3273 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3274 continue 3275 raise plumbing.convert_error_to_porcelain(e) from e 3276 break 3277 3278 resp = models.IdentityAliasGetResponse() 3279 resp.identity_alias = plumbing.convert_identity_alias_to_porcelain( 3280 plumbing_response.identity_alias) 3281 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3282 plumbing_response.meta) 3283 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3284 plumbing_response.rate_limit) 3285 return resp 3286 3287 def update(self, identity_alias, timeout=None): 3288 ''' 3289 Update replaces all the fields of a IdentityAlias by ID. 3290 ''' 3291 deadline = None if timeout is None else time.time() + timeout 3292 req = IdentityAliasUpdateRequest() 3293 3294 if identity_alias is not None: 3295 req.identity_alias.CopyFrom( 3296 plumbing.convert_identity_alias_to_plumbing(identity_alias)) 3297 tries = 0 3298 plumbing_response = None 3299 while True: 3300 t = None if deadline is None else deadline - time.time() 3301 try: 3302 plumbing_response = self.stub.Update( 3303 req, 3304 metadata=self.parent.get_metadata('IdentityAliases.Update', 3305 req), 3306 timeout=t) 3307 except Exception as e: 3308 if self.parent.shouldRetry(tries, e, deadline): 3309 tries += 1 3310 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3311 continue 3312 raise plumbing.convert_error_to_porcelain(e) from e 3313 break 3314 3315 resp = models.IdentityAliasUpdateResponse() 3316 resp.identity_alias = plumbing.convert_identity_alias_to_porcelain( 3317 plumbing_response.identity_alias) 3318 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 3319 plumbing_response.meta) 3320 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3321 plumbing_response.rate_limit) 3322 return resp 3323 3324 def delete(self, id, timeout=None): 3325 ''' 3326 Delete removes a IdentityAlias by ID. 3327 ''' 3328 deadline = None if timeout is None else time.time() + timeout 3329 req = IdentityAliasDeleteRequest() 3330 3331 req.id = (id) 3332 tries = 0 3333 plumbing_response = None 3334 while True: 3335 t = None if deadline is None else deadline - time.time() 3336 try: 3337 plumbing_response = self.stub.Delete( 3338 req, 3339 metadata=self.parent.get_metadata('IdentityAliases.Delete', 3340 req), 3341 timeout=t) 3342 except Exception as e: 3343 if self.parent.shouldRetry(tries, e, deadline): 3344 tries += 1 3345 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3346 continue 3347 raise plumbing.convert_error_to_porcelain(e) from e 3348 break 3349 3350 resp = models.IdentityAliasDeleteResponse() 3351 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3352 plumbing_response.meta) 3353 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3354 plumbing_response.rate_limit) 3355 return resp 3356 3357 def list(self, filter, *args, timeout=None): 3358 ''' 3359 List gets a list of IdentityAliases matching a given set of criteria. 3360 ''' 3361 deadline = None if timeout is None else time.time() + timeout 3362 req = IdentityAliasListRequest() 3363 req.meta.CopyFrom(ListRequestMetadata()) 3364 if self.parent.page_limit > 0: 3365 req.meta.limit = self.parent.page_limit 3366 if self.parent.snapshot_datetime is not None: 3367 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3368 3369 req.filter = plumbing.quote_filter_args(filter, *args) 3370 3371 def generator(svc, req): 3372 tries = 0 3373 while True: 3374 t = None if deadline is None else deadline - time.time() 3375 try: 3376 plumbing_response = svc.stub.List( 3377 req, 3378 metadata=svc.parent.get_metadata( 3379 'IdentityAliases.List', req), 3380 timeout=t) 3381 except Exception as e: 3382 if self.parent.shouldRetry(tries, e, deadline): 3383 tries += 1 3384 time.sleep( 3385 self.parent.exponentialBackoff(tries, deadline)) 3386 continue 3387 raise plumbing.convert_error_to_porcelain(e) from e 3388 tries = 0 3389 for plumbing_item in plumbing_response.identity_aliases: 3390 yield plumbing.convert_identity_alias_to_porcelain( 3391 plumbing_item) 3392 if plumbing_response.meta.next_cursor == '': 3393 break 3394 req.meta.cursor = plumbing_response.meta.next_cursor 3395 3396 return generator(self, req) 3397 3398 3399class SnapshotIdentityAliases: 3400 ''' 3401 SnapshotIdentityAliases exposes the read only methods of the IdentityAliases 3402 service for historical queries. 3403 ''' 3404 def __init__(self, identity_aliases): 3405 self.identity_aliases = identity_aliases 3406 3407 def get(self, id, timeout=None): 3408 ''' 3409 Get reads one IdentityAlias by ID. 3410 ''' 3411 return self.identity_aliases.get(id, timeout=timeout) 3412 3413 def list(self, filter, *args, timeout=None): 3414 ''' 3415 List gets a list of IdentityAliases matching a given set of criteria. 3416 ''' 3417 return self.identity_aliases.list(filter, *args, timeout=timeout) 3418 3419 3420class IdentityAliasesHistory: 3421 ''' 3422 IdentityAliasesHistory records all changes to the state of a IdentityAlias. 3423 See `strongdm.models.IdentityAliasHistory`. 3424 ''' 3425 def __init__(self, channel, client): 3426 self.parent = client 3427 self.stub = IdentityAliasesHistoryStub(channel) 3428 3429 def list(self, filter, *args, timeout=None): 3430 ''' 3431 List gets a list of IdentityAliasHistory records matching a given set of criteria. 3432 ''' 3433 deadline = None if timeout is None else time.time() + timeout 3434 req = IdentityAliasHistoryListRequest() 3435 req.meta.CopyFrom(ListRequestMetadata()) 3436 if self.parent.page_limit > 0: 3437 req.meta.limit = self.parent.page_limit 3438 if self.parent.snapshot_datetime is not None: 3439 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3440 3441 req.filter = plumbing.quote_filter_args(filter, *args) 3442 3443 def generator(svc, req): 3444 tries = 0 3445 while True: 3446 t = None if deadline is None else deadline - time.time() 3447 try: 3448 plumbing_response = svc.stub.List( 3449 req, 3450 metadata=svc.parent.get_metadata( 3451 'IdentityAliasesHistory.List', req), 3452 timeout=t) 3453 except Exception as e: 3454 if self.parent.shouldRetry(tries, e, deadline): 3455 tries += 1 3456 time.sleep( 3457 self.parent.exponentialBackoff(tries, deadline)) 3458 continue 3459 raise plumbing.convert_error_to_porcelain(e) from e 3460 tries = 0 3461 for plumbing_item in plumbing_response.history: 3462 yield plumbing.convert_identity_alias_history_to_porcelain( 3463 plumbing_item) 3464 if plumbing_response.meta.next_cursor == '': 3465 break 3466 req.meta.cursor = plumbing_response.meta.next_cursor 3467 3468 return generator(self, req) 3469 3470 3471class IdentitySets: 3472 ''' 3473 A IdentitySet is a named grouping of Identity Aliases for Accounts. 3474 An Account's relationship to a IdentitySet is defined via IdentityAlias objects. 3475 See `strongdm.models.IdentitySet`. 3476 ''' 3477 def __init__(self, channel, client): 3478 self.parent = client 3479 self.stub = IdentitySetsStub(channel) 3480 3481 def create(self, identity_set, timeout=None): 3482 ''' 3483 Create registers a new IdentitySet. 3484 ''' 3485 deadline = None if timeout is None else time.time() + timeout 3486 req = IdentitySetCreateRequest() 3487 3488 if identity_set is not None: 3489 req.identity_set.CopyFrom( 3490 plumbing.convert_identity_set_to_plumbing(identity_set)) 3491 tries = 0 3492 plumbing_response = None 3493 while True: 3494 t = None if deadline is None else deadline - time.time() 3495 try: 3496 plumbing_response = self.stub.Create( 3497 req, 3498 metadata=self.parent.get_metadata('IdentitySets.Create', 3499 req), 3500 timeout=t) 3501 except Exception as e: 3502 if self.parent.shouldRetry(tries, e, deadline): 3503 tries += 1 3504 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3505 continue 3506 raise plumbing.convert_error_to_porcelain(e) from e 3507 break 3508 3509 resp = models.IdentitySetCreateResponse() 3510 resp.identity_set = plumbing.convert_identity_set_to_porcelain( 3511 plumbing_response.identity_set) 3512 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 3513 plumbing_response.meta) 3514 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3515 plumbing_response.rate_limit) 3516 return resp 3517 3518 def get(self, id, timeout=None): 3519 ''' 3520 Get reads one IdentitySet by ID. 3521 ''' 3522 deadline = None if timeout is None else time.time() + timeout 3523 req = IdentitySetGetRequest() 3524 if self.parent.snapshot_datetime is not None: 3525 req.meta.CopyFrom(GetRequestMetadata()) 3526 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3527 3528 req.id = (id) 3529 tries = 0 3530 plumbing_response = None 3531 while True: 3532 t = None if deadline is None else deadline - time.time() 3533 try: 3534 plumbing_response = self.stub.Get( 3535 req, 3536 metadata=self.parent.get_metadata('IdentitySets.Get', req), 3537 timeout=t) 3538 except Exception as e: 3539 if self.parent.shouldRetry(tries, e, deadline): 3540 tries += 1 3541 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3542 continue 3543 raise plumbing.convert_error_to_porcelain(e) from e 3544 break 3545 3546 resp = models.IdentitySetGetResponse() 3547 resp.identity_set = plumbing.convert_identity_set_to_porcelain( 3548 plumbing_response.identity_set) 3549 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3550 plumbing_response.meta) 3551 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3552 plumbing_response.rate_limit) 3553 return resp 3554 3555 def update(self, identity_set, timeout=None): 3556 ''' 3557 Update replaces all the fields of a IdentitySet by ID. 3558 ''' 3559 deadline = None if timeout is None else time.time() + timeout 3560 req = IdentitySetUpdateRequest() 3561 3562 if identity_set is not None: 3563 req.identity_set.CopyFrom( 3564 plumbing.convert_identity_set_to_plumbing(identity_set)) 3565 tries = 0 3566 plumbing_response = None 3567 while True: 3568 t = None if deadline is None else deadline - time.time() 3569 try: 3570 plumbing_response = self.stub.Update( 3571 req, 3572 metadata=self.parent.get_metadata('IdentitySets.Update', 3573 req), 3574 timeout=t) 3575 except Exception as e: 3576 if self.parent.shouldRetry(tries, e, deadline): 3577 tries += 1 3578 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3579 continue 3580 raise plumbing.convert_error_to_porcelain(e) from e 3581 break 3582 3583 resp = models.IdentitySetUpdateResponse() 3584 resp.identity_set = plumbing.convert_identity_set_to_porcelain( 3585 plumbing_response.identity_set) 3586 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 3587 plumbing_response.meta) 3588 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3589 plumbing_response.rate_limit) 3590 return resp 3591 3592 def delete(self, id, timeout=None): 3593 ''' 3594 Delete removes a IdentitySet by ID. 3595 ''' 3596 deadline = None if timeout is None else time.time() + timeout 3597 req = IdentitySetDeleteRequest() 3598 3599 req.id = (id) 3600 tries = 0 3601 plumbing_response = None 3602 while True: 3603 t = None if deadline is None else deadline - time.time() 3604 try: 3605 plumbing_response = self.stub.Delete( 3606 req, 3607 metadata=self.parent.get_metadata('IdentitySets.Delete', 3608 req), 3609 timeout=t) 3610 except Exception as e: 3611 if self.parent.shouldRetry(tries, e, deadline): 3612 tries += 1 3613 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3614 continue 3615 raise plumbing.convert_error_to_porcelain(e) from e 3616 break 3617 3618 resp = models.IdentitySetDeleteResponse() 3619 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3620 plumbing_response.meta) 3621 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3622 plumbing_response.rate_limit) 3623 return resp 3624 3625 def list(self, filter, *args, timeout=None): 3626 ''' 3627 List gets a list of IdentitySets matching a given set of criteria. 3628 ''' 3629 deadline = None if timeout is None else time.time() + timeout 3630 req = IdentitySetListRequest() 3631 req.meta.CopyFrom(ListRequestMetadata()) 3632 if self.parent.page_limit > 0: 3633 req.meta.limit = self.parent.page_limit 3634 if self.parent.snapshot_datetime is not None: 3635 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3636 3637 req.filter = plumbing.quote_filter_args(filter, *args) 3638 3639 def generator(svc, req): 3640 tries = 0 3641 while True: 3642 t = None if deadline is None else deadline - time.time() 3643 try: 3644 plumbing_response = svc.stub.List( 3645 req, 3646 metadata=svc.parent.get_metadata( 3647 'IdentitySets.List', req), 3648 timeout=t) 3649 except Exception as e: 3650 if self.parent.shouldRetry(tries, e, deadline): 3651 tries += 1 3652 time.sleep( 3653 self.parent.exponentialBackoff(tries, deadline)) 3654 continue 3655 raise plumbing.convert_error_to_porcelain(e) from e 3656 tries = 0 3657 for plumbing_item in plumbing_response.identity_sets: 3658 yield plumbing.convert_identity_set_to_porcelain( 3659 plumbing_item) 3660 if plumbing_response.meta.next_cursor == '': 3661 break 3662 req.meta.cursor = plumbing_response.meta.next_cursor 3663 3664 return generator(self, req) 3665 3666 3667class SnapshotIdentitySets: 3668 ''' 3669 SnapshotIdentitySets exposes the read only methods of the IdentitySets 3670 service for historical queries. 3671 ''' 3672 def __init__(self, identity_sets): 3673 self.identity_sets = identity_sets 3674 3675 def get(self, id, timeout=None): 3676 ''' 3677 Get reads one IdentitySet by ID. 3678 ''' 3679 return self.identity_sets.get(id, timeout=timeout) 3680 3681 def list(self, filter, *args, timeout=None): 3682 ''' 3683 List gets a list of IdentitySets matching a given set of criteria. 3684 ''' 3685 return self.identity_sets.list(filter, *args, timeout=timeout) 3686 3687 3688class IdentitySetsHistory: 3689 ''' 3690 IdentitySetsHistory records all changes to the state of a IdentitySet. 3691 See `strongdm.models.IdentitySetHistory`. 3692 ''' 3693 def __init__(self, channel, client): 3694 self.parent = client 3695 self.stub = IdentitySetsHistoryStub(channel) 3696 3697 def list(self, filter, *args, timeout=None): 3698 ''' 3699 List gets a list of IdentitySetHistory records matching a given set of criteria. 3700 ''' 3701 deadline = None if timeout is None else time.time() + timeout 3702 req = IdentitySetHistoryListRequest() 3703 req.meta.CopyFrom(ListRequestMetadata()) 3704 if self.parent.page_limit > 0: 3705 req.meta.limit = self.parent.page_limit 3706 if self.parent.snapshot_datetime is not None: 3707 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3708 3709 req.filter = plumbing.quote_filter_args(filter, *args) 3710 3711 def generator(svc, req): 3712 tries = 0 3713 while True: 3714 t = None if deadline is None else deadline - time.time() 3715 try: 3716 plumbing_response = svc.stub.List( 3717 req, 3718 metadata=svc.parent.get_metadata( 3719 'IdentitySetsHistory.List', req), 3720 timeout=t) 3721 except Exception as e: 3722 if self.parent.shouldRetry(tries, e, deadline): 3723 tries += 1 3724 time.sleep( 3725 self.parent.exponentialBackoff(tries, deadline)) 3726 continue 3727 raise plumbing.convert_error_to_porcelain(e) from e 3728 tries = 0 3729 for plumbing_item in plumbing_response.history: 3730 yield plumbing.convert_identity_set_history_to_porcelain( 3731 plumbing_item) 3732 if plumbing_response.meta.next_cursor == '': 3733 break 3734 req.meta.cursor = plumbing_response.meta.next_cursor 3735 3736 return generator(self, req) 3737 3738 3739class ManagedSecrets: 3740 ''' 3741 ManagedSecret is a private vertical for creating, reading, updating, 3742 deleting, listing and rotating the managed secrets in the secrets engines as 3743 an authenticated user. 3744 See `strongdm.models.ManagedSecret`. 3745 ''' 3746 def __init__(self, channel, client): 3747 self.parent = client 3748 self.stub = ManagedSecretsStub(channel) 3749 3750 def list(self, filter, *args, timeout=None): 3751 ''' 3752 List returns Managed Secrets from a Secret Engine. 3753 ''' 3754 deadline = None if timeout is None else time.time() + timeout 3755 req = ManagedSecretListRequest() 3756 req.meta.CopyFrom(ListRequestMetadata()) 3757 if self.parent.page_limit > 0: 3758 req.meta.limit = self.parent.page_limit 3759 if self.parent.snapshot_datetime is not None: 3760 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3761 3762 req.filter = plumbing.quote_filter_args(filter, *args) 3763 3764 def generator(svc, req): 3765 tries = 0 3766 while True: 3767 t = None if deadline is None else deadline - time.time() 3768 try: 3769 plumbing_response = svc.stub.List( 3770 req, 3771 metadata=svc.parent.get_metadata( 3772 'ManagedSecrets.List', req), 3773 timeout=t) 3774 except Exception as e: 3775 if self.parent.shouldRetry(tries, e, deadline): 3776 tries += 1 3777 time.sleep( 3778 self.parent.exponentialBackoff(tries, deadline)) 3779 continue 3780 raise plumbing.convert_error_to_porcelain(e) from e 3781 tries = 0 3782 for plumbing_item in plumbing_response.managed_secrets: 3783 yield plumbing.convert_managed_secret_to_porcelain( 3784 plumbing_item) 3785 if plumbing_response.meta.next_cursor == '': 3786 break 3787 req.meta.cursor = plumbing_response.meta.next_cursor 3788 3789 return generator(self, req) 3790 3791 def list_by_actor(self, filter, *args, timeout=None): 3792 ''' 3793 List returns Managed Secrets for an Actor from a Secret Engine. 3794 ''' 3795 deadline = None if timeout is None else time.time() + timeout 3796 req = ManagedSecretListRequest() 3797 req.meta.CopyFrom(ListRequestMetadata()) 3798 if self.parent.page_limit > 0: 3799 req.meta.limit = self.parent.page_limit 3800 if self.parent.snapshot_datetime is not None: 3801 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3802 3803 req.filter = plumbing.quote_filter_args(filter, *args) 3804 3805 def generator(svc, req): 3806 tries = 0 3807 while True: 3808 t = None if deadline is None else deadline - time.time() 3809 try: 3810 plumbing_response = svc.stub.ListByActor( 3811 req, 3812 metadata=svc.parent.get_metadata( 3813 'ManagedSecrets.ListByActor', req), 3814 timeout=t) 3815 except Exception as e: 3816 if self.parent.shouldRetry(tries, e, deadline): 3817 tries += 1 3818 time.sleep( 3819 self.parent.exponentialBackoff(tries, deadline)) 3820 continue 3821 raise plumbing.convert_error_to_porcelain(e) from e 3822 tries = 0 3823 for plumbing_item in plumbing_response.managed_secrets: 3824 yield plumbing.convert_managed_secret_to_porcelain( 3825 plumbing_item) 3826 if plumbing_response.meta.next_cursor == '': 3827 break 3828 req.meta.cursor = plumbing_response.meta.next_cursor 3829 3830 return generator(self, req) 3831 3832 def create(self, managed_secret, timeout=None): 3833 ''' 3834 Create creates a Managed Secret 3835 ''' 3836 deadline = None if timeout is None else time.time() + timeout 3837 req = ManagedSecretCreateRequest() 3838 3839 if managed_secret is not None: 3840 req.managed_secret.CopyFrom( 3841 plumbing.convert_managed_secret_to_plumbing(managed_secret)) 3842 tries = 0 3843 plumbing_response = None 3844 while True: 3845 t = None if deadline is None else deadline - time.time() 3846 try: 3847 plumbing_response = self.stub.Create( 3848 req, 3849 metadata=self.parent.get_metadata('ManagedSecrets.Create', 3850 req), 3851 timeout=t) 3852 except Exception as e: 3853 if self.parent.shouldRetry(tries, e, deadline): 3854 tries += 1 3855 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3856 continue 3857 raise plumbing.convert_error_to_porcelain(e) from e 3858 break 3859 3860 resp = models.ManagedSecretCreateResponse() 3861 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 3862 plumbing_response.managed_secret) 3863 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 3864 plumbing_response.meta) 3865 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3866 plumbing_response.rate_limit) 3867 return resp 3868 3869 def update(self, managed_secret, timeout=None): 3870 ''' 3871 Update updates a Managed Secret 3872 ''' 3873 deadline = None if timeout is None else time.time() + timeout 3874 req = ManagedSecretUpdateRequest() 3875 3876 if managed_secret is not None: 3877 req.managed_secret.CopyFrom( 3878 plumbing.convert_managed_secret_to_plumbing(managed_secret)) 3879 tries = 0 3880 plumbing_response = None 3881 while True: 3882 t = None if deadline is None else deadline - time.time() 3883 try: 3884 plumbing_response = self.stub.Update( 3885 req, 3886 metadata=self.parent.get_metadata('ManagedSecrets.Update', 3887 req), 3888 timeout=t) 3889 except Exception as e: 3890 if self.parent.shouldRetry(tries, e, deadline): 3891 tries += 1 3892 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3893 continue 3894 raise plumbing.convert_error_to_porcelain(e) from e 3895 break 3896 3897 resp = models.ManagedSecretUpdateResponse() 3898 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 3899 plumbing_response.managed_secret) 3900 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 3901 plumbing_response.meta) 3902 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3903 plumbing_response.rate_limit) 3904 return resp 3905 3906 def rotate(self, id, timeout=None): 3907 ''' 3908 Rotate forces rotation of Managed Secret 3909 ''' 3910 deadline = None if timeout is None else time.time() + timeout 3911 req = ManagedSecretRotateRequest() 3912 3913 req.id = (id) 3914 tries = 0 3915 plumbing_response = None 3916 while True: 3917 t = None if deadline is None else deadline - time.time() 3918 try: 3919 plumbing_response = self.stub.Rotate( 3920 req, 3921 metadata=self.parent.get_metadata('ManagedSecrets.Rotate', 3922 req), 3923 timeout=t) 3924 except Exception as e: 3925 if self.parent.shouldRetry(tries, e, deadline): 3926 tries += 1 3927 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3928 continue 3929 raise plumbing.convert_error_to_porcelain(e) from e 3930 break 3931 3932 resp = models.ManagedSecretRotateResponse() 3933 resp.meta = plumbing.convert_generic_response_metadata_to_porcelain( 3934 plumbing_response.meta) 3935 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3936 plumbing_response.rate_limit) 3937 return resp 3938 3939 def delete(self, id, timeout=None): 3940 ''' 3941 Delete deletes a Managed Secret 3942 ''' 3943 deadline = None if timeout is None else time.time() + timeout 3944 req = ManagedSecretDeleteRequest() 3945 3946 req.id = (id) 3947 tries = 0 3948 plumbing_response = None 3949 while True: 3950 t = None if deadline is None else deadline - time.time() 3951 try: 3952 plumbing_response = self.stub.Delete( 3953 req, 3954 metadata=self.parent.get_metadata('ManagedSecrets.Delete', 3955 req), 3956 timeout=t) 3957 except Exception as e: 3958 if self.parent.shouldRetry(tries, e, deadline): 3959 tries += 1 3960 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3961 continue 3962 raise plumbing.convert_error_to_porcelain(e) from e 3963 break 3964 3965 resp = models.ManagedSecretDeleteResponse() 3966 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3967 plumbing_response.rate_limit) 3968 return resp 3969 3970 def force_delete(self, id, timeout=None): 3971 ''' 3972 ForceDelete deletes a Managed Secret regardless of errors on external system 3973 ''' 3974 deadline = None if timeout is None else time.time() + timeout 3975 req = ManagedSecretDeleteRequest() 3976 3977 req.id = (id) 3978 tries = 0 3979 plumbing_response = None 3980 while True: 3981 t = None if deadline is None else deadline - time.time() 3982 try: 3983 plumbing_response = self.stub.ForceDelete( 3984 req, 3985 metadata=self.parent.get_metadata( 3986 'ManagedSecrets.ForceDelete', req), 3987 timeout=t) 3988 except Exception as e: 3989 if self.parent.shouldRetry(tries, e, deadline): 3990 tries += 1 3991 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3992 continue 3993 raise plumbing.convert_error_to_porcelain(e) from e 3994 break 3995 3996 resp = models.ManagedSecretDeleteResponse() 3997 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3998 plumbing_response.rate_limit) 3999 return resp 4000 4001 def get(self, id, timeout=None): 4002 ''' 4003 Get gets details of a Managed Secret without sensitive data 4004 ''' 4005 deadline = None if timeout is None else time.time() + timeout 4006 req = ManagedSecretGetRequest() 4007 if self.parent.snapshot_datetime is not None: 4008 req.meta.CopyFrom(GetRequestMetadata()) 4009 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4010 4011 req.id = (id) 4012 tries = 0 4013 plumbing_response = None 4014 while True: 4015 t = None if deadline is None else deadline - time.time() 4016 try: 4017 plumbing_response = self.stub.Get( 4018 req, 4019 metadata=self.parent.get_metadata('ManagedSecrets.Get', 4020 req), 4021 timeout=t) 4022 except Exception as e: 4023 if self.parent.shouldRetry(tries, e, deadline): 4024 tries += 1 4025 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4026 continue 4027 raise plumbing.convert_error_to_porcelain(e) from e 4028 break 4029 4030 resp = models.ManagedSecretGetResponse() 4031 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 4032 plumbing_response.managed_secret) 4033 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4034 plumbing_response.meta) 4035 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4036 plumbing_response.rate_limit) 4037 return resp 4038 4039 def retrieve(self, id, public_key, timeout=None): 4040 ''' 4041 Retrieve returns Managed Secret with sensitive data 4042 ''' 4043 deadline = None if timeout is None else time.time() + timeout 4044 req = ManagedSecretRetrieveRequest() 4045 4046 req.id = (id) 4047 req.public_key = (public_key) 4048 tries = 0 4049 plumbing_response = None 4050 while True: 4051 t = None if deadline is None else deadline - time.time() 4052 try: 4053 plumbing_response = self.stub.Retrieve( 4054 req, 4055 metadata=self.parent.get_metadata( 4056 'ManagedSecrets.Retrieve', req), 4057 timeout=t) 4058 except Exception as e: 4059 if self.parent.shouldRetry(tries, e, deadline): 4060 tries += 1 4061 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4062 continue 4063 raise plumbing.convert_error_to_porcelain(e) from e 4064 break 4065 4066 resp = models.ManagedSecretRetrieveResponse() 4067 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 4068 plumbing_response.managed_secret) 4069 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4070 plumbing_response.meta) 4071 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4072 plumbing_response.rate_limit) 4073 return resp 4074 4075 def validate(self, id, timeout=None): 4076 ''' 4077 Validate returns the result of testing the stored credential against the 4078 secret engine. 4079 ''' 4080 deadline = None if timeout is None else time.time() + timeout 4081 req = ManagedSecretValidateRequest() 4082 4083 req.id = (id) 4084 tries = 0 4085 plumbing_response = None 4086 while True: 4087 t = None if deadline is None else deadline - time.time() 4088 try: 4089 plumbing_response = self.stub.Validate( 4090 req, 4091 metadata=self.parent.get_metadata( 4092 'ManagedSecrets.Validate', req), 4093 timeout=t) 4094 except Exception as e: 4095 if self.parent.shouldRetry(tries, e, deadline): 4096 tries += 1 4097 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4098 continue 4099 raise plumbing.convert_error_to_porcelain(e) from e 4100 break 4101 4102 resp = models.ManagedSecretValidateResponse() 4103 resp.invalid_info = (plumbing_response.invalid_info) 4104 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4105 plumbing_response.meta) 4106 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4107 plumbing_response.rate_limit) 4108 resp.valid = (plumbing_response.valid) 4109 return resp 4110 4111 def logs(self, filter, *args, timeout=None): 4112 ''' 4113 Logs returns the audit records for the managed secret. This may be replaced 4114 in the future. 4115 ''' 4116 deadline = None if timeout is None else time.time() + timeout 4117 req = ManagedSecretLogsRequest() 4118 req.meta.CopyFrom(ListRequestMetadata()) 4119 if self.parent.page_limit > 0: 4120 req.meta.limit = self.parent.page_limit 4121 if self.parent.snapshot_datetime is not None: 4122 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4123 4124 req.filter = plumbing.quote_filter_args(filter, *args) 4125 4126 def generator(svc, req): 4127 tries = 0 4128 while True: 4129 t = None if deadline is None else deadline - time.time() 4130 try: 4131 plumbing_response = svc.stub.Logs( 4132 req, 4133 metadata=svc.parent.get_metadata( 4134 'ManagedSecrets.Logs', req), 4135 timeout=t) 4136 except Exception as e: 4137 if self.parent.shouldRetry(tries, e, deadline): 4138 tries += 1 4139 time.sleep( 4140 self.parent.exponentialBackoff(tries, deadline)) 4141 continue 4142 raise plumbing.convert_error_to_porcelain(e) from e 4143 tries = 0 4144 for plumbing_item in plumbing_response.managed_secret_logs: 4145 yield plumbing.convert_managed_secret_log_to_porcelain( 4146 plumbing_item) 4147 if plumbing_response.meta.next_cursor == '': 4148 break 4149 req.meta.cursor = plumbing_response.meta.next_cursor 4150 4151 return generator(self, req) 4152 4153 4154class Nodes: 4155 ''' 4156 Nodes make up the StrongDM network, and allow your users to connect securely to your resources. 4157 There are three types of nodes: 4158 1. **Relay:** creates connectivity to your datasources, while maintaining the egress-only nature of your firewall 4159 2. **Gateway:** a relay that also listens for connections from StrongDM clients 4160 3. **Proxy Cluster:** a cluster of workers that together mediate access from clients to resources 4161 See: 4162 `strongdm.models.Gateway` 4163 `strongdm.models.ProxyCluster` 4164 `strongdm.models.Relay` 4165 ''' 4166 def __init__(self, channel, client): 4167 self.parent = client 4168 self.stub = NodesStub(channel) 4169 4170 def create(self, node, timeout=None): 4171 ''' 4172 Create registers a new Node. 4173 ''' 4174 deadline = None if timeout is None else time.time() + timeout 4175 req = NodeCreateRequest() 4176 4177 if node is not None: 4178 req.node.CopyFrom(plumbing.convert_node_to_plumbing(node)) 4179 tries = 0 4180 plumbing_response = None 4181 while True: 4182 t = None if deadline is None else deadline - time.time() 4183 try: 4184 plumbing_response = self.stub.Create( 4185 req, 4186 metadata=self.parent.get_metadata('Nodes.Create', req), 4187 timeout=t) 4188 except Exception as e: 4189 if self.parent.shouldRetry(tries, e, deadline): 4190 tries += 1 4191 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4192 continue 4193 raise plumbing.convert_error_to_porcelain(e) from e 4194 break 4195 4196 resp = models.NodeCreateResponse() 4197 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4198 plumbing_response.meta) 4199 resp.node = plumbing.convert_node_to_porcelain(plumbing_response.node) 4200 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4201 plumbing_response.rate_limit) 4202 resp.token = (plumbing_response.token) 4203 return resp 4204 4205 def get(self, id, timeout=None): 4206 ''' 4207 Get reads one Node by ID. 4208 ''' 4209 deadline = None if timeout is None else time.time() + timeout 4210 req = NodeGetRequest() 4211 if self.parent.snapshot_datetime is not None: 4212 req.meta.CopyFrom(GetRequestMetadata()) 4213 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4214 4215 req.id = (id) 4216 tries = 0 4217 plumbing_response = None 4218 while True: 4219 t = None if deadline is None else deadline - time.time() 4220 try: 4221 plumbing_response = self.stub.Get( 4222 req, 4223 metadata=self.parent.get_metadata('Nodes.Get', req), 4224 timeout=t) 4225 except Exception as e: 4226 if self.parent.shouldRetry(tries, e, deadline): 4227 tries += 1 4228 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4229 continue 4230 raise plumbing.convert_error_to_porcelain(e) from e 4231 break 4232 4233 resp = models.NodeGetResponse() 4234 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4235 plumbing_response.meta) 4236 resp.node = plumbing.convert_node_to_porcelain(plumbing_response.node) 4237 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4238 plumbing_response.rate_limit) 4239 return resp 4240 4241 def update(self, node, timeout=None): 4242 ''' 4243 Update replaces all the fields of a Node by ID. 4244 ''' 4245 deadline = None if timeout is None else time.time() + timeout 4246 req = NodeUpdateRequest() 4247 4248 if node is not None: 4249 req.node.CopyFrom(plumbing.convert_node_to_plumbing(node)) 4250 tries = 0 4251 plumbing_response = None 4252 while True: 4253 t = None if deadline is None else deadline - time.time() 4254 try: 4255 plumbing_response = self.stub.Update( 4256 req, 4257 metadata=self.parent.get_metadata('Nodes.Update', req), 4258 timeout=t) 4259 except Exception as e: 4260 if self.parent.shouldRetry(tries, e, deadline): 4261 tries += 1 4262 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4263 continue 4264 raise plumbing.convert_error_to_porcelain(e) from e 4265 break 4266 4267 resp = models.NodeUpdateResponse() 4268 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 4269 plumbing_response.meta) 4270 resp.node = plumbing.convert_node_to_porcelain(plumbing_response.node) 4271 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4272 plumbing_response.rate_limit) 4273 return resp 4274 4275 def delete(self, id, timeout=None): 4276 ''' 4277 Delete removes a Node by ID. 4278 ''' 4279 deadline = None if timeout is None else time.time() + timeout 4280 req = NodeDeleteRequest() 4281 4282 req.id = (id) 4283 tries = 0 4284 plumbing_response = None 4285 while True: 4286 t = None if deadline is None else deadline - time.time() 4287 try: 4288 plumbing_response = self.stub.Delete( 4289 req, 4290 metadata=self.parent.get_metadata('Nodes.Delete', req), 4291 timeout=t) 4292 except Exception as e: 4293 if self.parent.shouldRetry(tries, e, deadline): 4294 tries += 1 4295 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4296 continue 4297 raise plumbing.convert_error_to_porcelain(e) from e 4298 break 4299 4300 resp = models.NodeDeleteResponse() 4301 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 4302 plumbing_response.meta) 4303 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4304 plumbing_response.rate_limit) 4305 return resp 4306 4307 def list(self, filter, *args, timeout=None): 4308 ''' 4309 List gets a list of Nodes matching a given set of criteria. 4310 ''' 4311 deadline = None if timeout is None else time.time() + timeout 4312 req = NodeListRequest() 4313 req.meta.CopyFrom(ListRequestMetadata()) 4314 if self.parent.page_limit > 0: 4315 req.meta.limit = self.parent.page_limit 4316 if self.parent.snapshot_datetime is not None: 4317 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4318 4319 req.filter = plumbing.quote_filter_args(filter, *args) 4320 4321 def generator(svc, req): 4322 tries = 0 4323 while True: 4324 t = None if deadline is None else deadline - time.time() 4325 try: 4326 plumbing_response = svc.stub.List( 4327 req, 4328 metadata=svc.parent.get_metadata('Nodes.List', req), 4329 timeout=t) 4330 except Exception as e: 4331 if self.parent.shouldRetry(tries, e, deadline): 4332 tries += 1 4333 time.sleep( 4334 self.parent.exponentialBackoff(tries, deadline)) 4335 continue 4336 raise plumbing.convert_error_to_porcelain(e) from e 4337 tries = 0 4338 for plumbing_item in plumbing_response.nodes: 4339 yield plumbing.convert_node_to_porcelain(plumbing_item) 4340 if plumbing_response.meta.next_cursor == '': 4341 break 4342 req.meta.cursor = plumbing_response.meta.next_cursor 4343 4344 return generator(self, req) 4345 4346 def tcp_probe(self, node_id, host, port, timeout=None): 4347 ''' 4348 TCPProbe instructs a Node to connect to an address via TCP and report the 4349 result. 4350 ''' 4351 deadline = None if timeout is None else time.time() + timeout 4352 req = NodeTCPProbeRequest() 4353 4354 req.node_id = (node_id) 4355 req.host = (host) 4356 req.port = (port) 4357 tries = 0 4358 plumbing_response = None 4359 while True: 4360 t = None if deadline is None else deadline - time.time() 4361 try: 4362 plumbing_response = self.stub.TCPProbe( 4363 req, 4364 metadata=self.parent.get_metadata('Nodes.TCPProbe', req), 4365 timeout=t) 4366 except Exception as e: 4367 if self.parent.shouldRetry(tries, e, deadline): 4368 tries += 1 4369 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4370 continue 4371 raise plumbing.convert_error_to_porcelain(e) from e 4372 break 4373 4374 resp = models.NodeTCPProbeResponse() 4375 resp.error = (plumbing_response.error) 4376 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4377 plumbing_response.meta) 4378 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4379 plumbing_response.rate_limit) 4380 resp.succeeded = (plumbing_response.succeeded) 4381 return resp 4382 4383 4384class SnapshotNodes: 4385 ''' 4386 SnapshotNodes exposes the read only methods of the Nodes 4387 service for historical queries. 4388 ''' 4389 def __init__(self, nodes): 4390 self.nodes = nodes 4391 4392 def get(self, id, timeout=None): 4393 ''' 4394 Get reads one Node by ID. 4395 ''' 4396 return self.nodes.get(id, timeout=timeout) 4397 4398 def list(self, filter, *args, timeout=None): 4399 ''' 4400 List gets a list of Nodes matching a given set of criteria. 4401 ''' 4402 return self.nodes.list(filter, *args, timeout=timeout) 4403 4404 4405class NodesHistory: 4406 ''' 4407 NodesHistory records all changes to the state of a Node. 4408 See `strongdm.models.NodeHistory`. 4409 ''' 4410 def __init__(self, channel, client): 4411 self.parent = client 4412 self.stub = NodesHistoryStub(channel) 4413 4414 def list(self, filter, *args, timeout=None): 4415 ''' 4416 List gets a list of NodeHistory records matching a given set of criteria. 4417 ''' 4418 deadline = None if timeout is None else time.time() + timeout 4419 req = NodeHistoryListRequest() 4420 req.meta.CopyFrom(ListRequestMetadata()) 4421 if self.parent.page_limit > 0: 4422 req.meta.limit = self.parent.page_limit 4423 if self.parent.snapshot_datetime is not None: 4424 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4425 4426 req.filter = plumbing.quote_filter_args(filter, *args) 4427 4428 def generator(svc, req): 4429 tries = 0 4430 while True: 4431 t = None if deadline is None else deadline - time.time() 4432 try: 4433 plumbing_response = svc.stub.List( 4434 req, 4435 metadata=svc.parent.get_metadata( 4436 'NodesHistory.List', req), 4437 timeout=t) 4438 except Exception as e: 4439 if self.parent.shouldRetry(tries, e, deadline): 4440 tries += 1 4441 time.sleep( 4442 self.parent.exponentialBackoff(tries, deadline)) 4443 continue 4444 raise plumbing.convert_error_to_porcelain(e) from e 4445 tries = 0 4446 for plumbing_item in plumbing_response.history: 4447 yield plumbing.convert_node_history_to_porcelain( 4448 plumbing_item) 4449 if plumbing_response.meta.next_cursor == '': 4450 break 4451 req.meta.cursor = plumbing_response.meta.next_cursor 4452 4453 return generator(self, req) 4454 4455 4456class OrganizationHistory: 4457 ''' 4458 OrganizationHistory records all changes to the state of an Organization. 4459 See `strongdm.models.OrganizationHistoryRecord`. 4460 ''' 4461 def __init__(self, channel, client): 4462 self.parent = client 4463 self.stub = OrganizationHistoryStub(channel) 4464 4465 def list(self, filter, *args, timeout=None): 4466 ''' 4467 List gets a list of OrganizationHistory records matching a given set of criteria. 4468 ''' 4469 deadline = None if timeout is None else time.time() + timeout 4470 req = OrganizationHistoryListRequest() 4471 req.meta.CopyFrom(ListRequestMetadata()) 4472 if self.parent.page_limit > 0: 4473 req.meta.limit = self.parent.page_limit 4474 if self.parent.snapshot_datetime is not None: 4475 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4476 4477 req.filter = plumbing.quote_filter_args(filter, *args) 4478 4479 def generator(svc, req): 4480 tries = 0 4481 while True: 4482 t = None if deadline is None else deadline - time.time() 4483 try: 4484 plumbing_response = svc.stub.List( 4485 req, 4486 metadata=svc.parent.get_metadata( 4487 'OrganizationHistory.List', req), 4488 timeout=t) 4489 except Exception as e: 4490 if self.parent.shouldRetry(tries, e, deadline): 4491 tries += 1 4492 time.sleep( 4493 self.parent.exponentialBackoff(tries, deadline)) 4494 continue 4495 raise plumbing.convert_error_to_porcelain(e) from e 4496 tries = 0 4497 for plumbing_item in plumbing_response.history: 4498 yield plumbing.convert_organization_history_record_to_porcelain( 4499 plumbing_item) 4500 if plumbing_response.meta.next_cursor == '': 4501 break 4502 req.meta.cursor = plumbing_response.meta.next_cursor 4503 4504 return generator(self, req) 4505 4506 4507class PeeringGroupNodes: 4508 ''' 4509 PeeringGroupNodes provides the building blocks necessary to obtain attach a node to a peering group. 4510 See `strongdm.models.PeeringGroupNode`. 4511 ''' 4512 def __init__(self, channel, client): 4513 self.parent = client 4514 self.stub = PeeringGroupNodesStub(channel) 4515 4516 def create(self, peering_group_node, timeout=None): 4517 ''' 4518 Create attaches a Node to a PeeringGroup 4519 ''' 4520 deadline = None if timeout is None else time.time() + timeout 4521 req = PeeringGroupNodeCreateRequest() 4522 4523 if peering_group_node is not None: 4524 req.peering_group_node.CopyFrom( 4525 plumbing.convert_peering_group_node_to_plumbing( 4526 peering_group_node)) 4527 tries = 0 4528 plumbing_response = None 4529 while True: 4530 t = None if deadline is None else deadline - time.time() 4531 try: 4532 plumbing_response = self.stub.Create( 4533 req, 4534 metadata=self.parent.get_metadata( 4535 'PeeringGroupNodes.Create', req), 4536 timeout=t) 4537 except Exception as e: 4538 if self.parent.shouldRetry(tries, e, deadline): 4539 tries += 1 4540 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4541 continue 4542 raise plumbing.convert_error_to_porcelain(e) from e 4543 break 4544 4545 resp = models.PeeringGroupNodeCreateResponse() 4546 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4547 plumbing_response.meta) 4548 resp.peering_group_node = plumbing.convert_peering_group_node_to_porcelain( 4549 plumbing_response.peering_group_node) 4550 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4551 plumbing_response.rate_limit) 4552 return resp 4553 4554 def delete(self, id, timeout=None): 4555 ''' 4556 Delete detaches a Node to a PeeringGroup. 4557 ''' 4558 deadline = None if timeout is None else time.time() + timeout 4559 req = PeeringGroupNodeDeleteRequest() 4560 4561 req.id = (id) 4562 tries = 0 4563 plumbing_response = None 4564 while True: 4565 t = None if deadline is None else deadline - time.time() 4566 try: 4567 plumbing_response = self.stub.Delete( 4568 req, 4569 metadata=self.parent.get_metadata( 4570 'PeeringGroupNodes.Delete', req), 4571 timeout=t) 4572 except Exception as e: 4573 if self.parent.shouldRetry(tries, e, deadline): 4574 tries += 1 4575 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4576 continue 4577 raise plumbing.convert_error_to_porcelain(e) from e 4578 break 4579 4580 resp = models.PeeringGroupNodeDeleteResponse() 4581 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 4582 plumbing_response.meta) 4583 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4584 plumbing_response.rate_limit) 4585 return resp 4586 4587 def get(self, id, timeout=None): 4588 ''' 4589 Get reads the information of one peering group to node attachment. 4590 ''' 4591 deadline = None if timeout is None else time.time() + timeout 4592 req = PeeringGroupNodeGetRequest() 4593 if self.parent.snapshot_datetime is not None: 4594 req.meta.CopyFrom(GetRequestMetadata()) 4595 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4596 4597 req.id = (id) 4598 tries = 0 4599 plumbing_response = None 4600 while True: 4601 t = None if deadline is None else deadline - time.time() 4602 try: 4603 plumbing_response = self.stub.Get( 4604 req, 4605 metadata=self.parent.get_metadata('PeeringGroupNodes.Get', 4606 req), 4607 timeout=t) 4608 except Exception as e: 4609 if self.parent.shouldRetry(tries, e, deadline): 4610 tries += 1 4611 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4612 continue 4613 raise plumbing.convert_error_to_porcelain(e) from e 4614 break 4615 4616 resp = models.PeeringGroupNodeGetResponse() 4617 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4618 plumbing_response.meta) 4619 resp.peering_group_node = plumbing.convert_peering_group_node_to_porcelain( 4620 plumbing_response.peering_group_node) 4621 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4622 plumbing_response.rate_limit) 4623 return resp 4624 4625 def list(self, filter, *args, timeout=None): 4626 ''' 4627 List gets a list of peering group node attachments. 4628 ''' 4629 deadline = None if timeout is None else time.time() + timeout 4630 req = PeeringGroupNodeListRequest() 4631 req.meta.CopyFrom(ListRequestMetadata()) 4632 if self.parent.page_limit > 0: 4633 req.meta.limit = self.parent.page_limit 4634 if self.parent.snapshot_datetime is not None: 4635 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4636 4637 req.filter = plumbing.quote_filter_args(filter, *args) 4638 4639 def generator(svc, req): 4640 tries = 0 4641 while True: 4642 t = None if deadline is None else deadline - time.time() 4643 try: 4644 plumbing_response = svc.stub.List( 4645 req, 4646 metadata=svc.parent.get_metadata( 4647 'PeeringGroupNodes.List', req), 4648 timeout=t) 4649 except Exception as e: 4650 if self.parent.shouldRetry(tries, e, deadline): 4651 tries += 1 4652 time.sleep( 4653 self.parent.exponentialBackoff(tries, deadline)) 4654 continue 4655 raise plumbing.convert_error_to_porcelain(e) from e 4656 tries = 0 4657 for plumbing_item in plumbing_response.peering_group_nodes: 4658 yield plumbing.convert_peering_group_node_to_porcelain( 4659 plumbing_item) 4660 if plumbing_response.meta.next_cursor == '': 4661 break 4662 req.meta.cursor = plumbing_response.meta.next_cursor 4663 4664 return generator(self, req) 4665 4666 4667class PeeringGroupPeers: 4668 ''' 4669 PeeringGroupPeers provides the building blocks necessary to link two peering groups. 4670 See `strongdm.models.PeeringGroupPeer`. 4671 ''' 4672 def __init__(self, channel, client): 4673 self.parent = client 4674 self.stub = PeeringGroupPeersStub(channel) 4675 4676 def create(self, peering_group_peer, timeout=None): 4677 ''' 4678 Create links two peering groups. 4679 ''' 4680 deadline = None if timeout is None else time.time() + timeout 4681 req = PeeringGroupPeerCreateRequest() 4682 4683 if peering_group_peer is not None: 4684 req.peering_group_peer.CopyFrom( 4685 plumbing.convert_peering_group_peer_to_plumbing( 4686 peering_group_peer)) 4687 tries = 0 4688 plumbing_response = None 4689 while True: 4690 t = None if deadline is None else deadline - time.time() 4691 try: 4692 plumbing_response = self.stub.Create( 4693 req, 4694 metadata=self.parent.get_metadata( 4695 'PeeringGroupPeers.Create', req), 4696 timeout=t) 4697 except Exception as e: 4698 if self.parent.shouldRetry(tries, e, deadline): 4699 tries += 1 4700 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4701 continue 4702 raise plumbing.convert_error_to_porcelain(e) from e 4703 break 4704 4705 resp = models.PeeringGroupPeerCreateResponse() 4706 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4707 plumbing_response.meta) 4708 resp.peering_group_peer = plumbing.convert_peering_group_peer_to_porcelain( 4709 plumbing_response.peering_group_peer) 4710 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4711 plumbing_response.rate_limit) 4712 return resp 4713 4714 def delete(self, id, timeout=None): 4715 ''' 4716 Delete unlinks two peering groups. 4717 ''' 4718 deadline = None if timeout is None else time.time() + timeout 4719 req = PeeringGroupPeerDeleteRequest() 4720 4721 req.id = (id) 4722 tries = 0 4723 plumbing_response = None 4724 while True: 4725 t = None if deadline is None else deadline - time.time() 4726 try: 4727 plumbing_response = self.stub.Delete( 4728 req, 4729 metadata=self.parent.get_metadata( 4730 'PeeringGroupPeers.Delete', req), 4731 timeout=t) 4732 except Exception as e: 4733 if self.parent.shouldRetry(tries, e, deadline): 4734 tries += 1 4735 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4736 continue 4737 raise plumbing.convert_error_to_porcelain(e) from e 4738 break 4739 4740 resp = models.PeeringGroupPeerDeleteResponse() 4741 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 4742 plumbing_response.meta) 4743 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4744 plumbing_response.rate_limit) 4745 return resp 4746 4747 def get(self, id, timeout=None): 4748 ''' 4749 Get reads the information of one peering group link. 4750 ''' 4751 deadline = None if timeout is None else time.time() + timeout 4752 req = PeeringGroupPeerGetRequest() 4753 if self.parent.snapshot_datetime is not None: 4754 req.meta.CopyFrom(GetRequestMetadata()) 4755 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4756 4757 req.id = (id) 4758 tries = 0 4759 plumbing_response = None 4760 while True: 4761 t = None if deadline is None else deadline - time.time() 4762 try: 4763 plumbing_response = self.stub.Get( 4764 req, 4765 metadata=self.parent.get_metadata('PeeringGroupPeers.Get', 4766 req), 4767 timeout=t) 4768 except Exception as e: 4769 if self.parent.shouldRetry(tries, e, deadline): 4770 tries += 1 4771 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4772 continue 4773 raise plumbing.convert_error_to_porcelain(e) from e 4774 break 4775 4776 resp = models.PeeringGroupPeerGetResponse() 4777 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4778 plumbing_response.meta) 4779 resp.peering_group_peer = plumbing.convert_peering_group_peer_to_porcelain( 4780 plumbing_response.peering_group_peer) 4781 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4782 plumbing_response.rate_limit) 4783 return resp 4784 4785 def list(self, filter, *args, timeout=None): 4786 ''' 4787 List gets a list of peering group links. 4788 ''' 4789 deadline = None if timeout is None else time.time() + timeout 4790 req = PeeringGroupPeerListRequest() 4791 req.meta.CopyFrom(ListRequestMetadata()) 4792 if self.parent.page_limit > 0: 4793 req.meta.limit = self.parent.page_limit 4794 if self.parent.snapshot_datetime is not None: 4795 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4796 4797 req.filter = plumbing.quote_filter_args(filter, *args) 4798 4799 def generator(svc, req): 4800 tries = 0 4801 while True: 4802 t = None if deadline is None else deadline - time.time() 4803 try: 4804 plumbing_response = svc.stub.List( 4805 req, 4806 metadata=svc.parent.get_metadata( 4807 'PeeringGroupPeers.List', req), 4808 timeout=t) 4809 except Exception as e: 4810 if self.parent.shouldRetry(tries, e, deadline): 4811 tries += 1 4812 time.sleep( 4813 self.parent.exponentialBackoff(tries, deadline)) 4814 continue 4815 raise plumbing.convert_error_to_porcelain(e) from e 4816 tries = 0 4817 for plumbing_item in plumbing_response.peering_group_peers: 4818 yield plumbing.convert_peering_group_peer_to_porcelain( 4819 plumbing_item) 4820 if plumbing_response.meta.next_cursor == '': 4821 break 4822 req.meta.cursor = plumbing_response.meta.next_cursor 4823 4824 return generator(self, req) 4825 4826 4827class PeeringGroupResources: 4828 ''' 4829 PeeringGroupResources provides the building blocks necessary to obtain attach a resource to a peering group. 4830 See `strongdm.models.PeeringGroupResource`. 4831 ''' 4832 def __init__(self, channel, client): 4833 self.parent = client 4834 self.stub = PeeringGroupResourcesStub(channel) 4835 4836 def create(self, peering_group_resource, timeout=None): 4837 ''' 4838 Create attaches a Resource to a PeeringGroup 4839 ''' 4840 deadline = None if timeout is None else time.time() + timeout 4841 req = PeeringGroupResourceCreateRequest() 4842 4843 if peering_group_resource is not None: 4844 req.peering_group_resource.CopyFrom( 4845 plumbing.convert_peering_group_resource_to_plumbing( 4846 peering_group_resource)) 4847 tries = 0 4848 plumbing_response = None 4849 while True: 4850 t = None if deadline is None else deadline - time.time() 4851 try: 4852 plumbing_response = self.stub.Create( 4853 req, 4854 metadata=self.parent.get_metadata( 4855 'PeeringGroupResources.Create', req), 4856 timeout=t) 4857 except Exception as e: 4858 if self.parent.shouldRetry(tries, e, deadline): 4859 tries += 1 4860 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4861 continue 4862 raise plumbing.convert_error_to_porcelain(e) from e 4863 break 4864 4865 resp = models.PeeringGroupResourceCreateResponse() 4866 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4867 plumbing_response.meta) 4868 resp.peering_group_resource = plumbing.convert_peering_group_resource_to_porcelain( 4869 plumbing_response.peering_group_resource) 4870 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4871 plumbing_response.rate_limit) 4872 return resp 4873 4874 def delete(self, id, timeout=None): 4875 ''' 4876 Delete detaches a Resource to a PeeringGroup 4877 ''' 4878 deadline = None if timeout is None else time.time() + timeout 4879 req = PeeringGroupResourceDeleteRequest() 4880 4881 req.id = (id) 4882 tries = 0 4883 plumbing_response = None 4884 while True: 4885 t = None if deadline is None else deadline - time.time() 4886 try: 4887 plumbing_response = self.stub.Delete( 4888 req, 4889 metadata=self.parent.get_metadata( 4890 'PeeringGroupResources.Delete', req), 4891 timeout=t) 4892 except Exception as e: 4893 if self.parent.shouldRetry(tries, e, deadline): 4894 tries += 1 4895 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4896 continue 4897 raise plumbing.convert_error_to_porcelain(e) from e 4898 break 4899 4900 resp = models.PeeringGroupResourceDeleteResponse() 4901 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 4902 plumbing_response.meta) 4903 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4904 plumbing_response.rate_limit) 4905 return resp 4906 4907 def get(self, id, timeout=None): 4908 ''' 4909 Get reads the information of one peering group to resource attachment. 4910 ''' 4911 deadline = None if timeout is None else time.time() + timeout 4912 req = PeeringGroupResourceGetRequest() 4913 if self.parent.snapshot_datetime is not None: 4914 req.meta.CopyFrom(GetRequestMetadata()) 4915 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4916 4917 req.id = (id) 4918 tries = 0 4919 plumbing_response = None 4920 while True: 4921 t = None if deadline is None else deadline - time.time() 4922 try: 4923 plumbing_response = self.stub.Get( 4924 req, 4925 metadata=self.parent.get_metadata( 4926 'PeeringGroupResources.Get', req), 4927 timeout=t) 4928 except Exception as e: 4929 if self.parent.shouldRetry(tries, e, deadline): 4930 tries += 1 4931 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4932 continue 4933 raise plumbing.convert_error_to_porcelain(e) from e 4934 break 4935 4936 resp = models.PeeringGroupResourceGetResponse() 4937 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4938 plumbing_response.meta) 4939 resp.peering_group_resource = plumbing.convert_peering_group_resource_to_porcelain( 4940 plumbing_response.peering_group_resource) 4941 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4942 plumbing_response.rate_limit) 4943 return resp 4944 4945 def list(self, filter, *args, timeout=None): 4946 ''' 4947 List gets a list of peering group resource attachments. 4948 ''' 4949 deadline = None if timeout is None else time.time() + timeout 4950 req = PeeringGroupResourceListRequest() 4951 req.meta.CopyFrom(ListRequestMetadata()) 4952 if self.parent.page_limit > 0: 4953 req.meta.limit = self.parent.page_limit 4954 if self.parent.snapshot_datetime is not None: 4955 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4956 4957 req.filter = plumbing.quote_filter_args(filter, *args) 4958 4959 def generator(svc, req): 4960 tries = 0 4961 while True: 4962 t = None if deadline is None else deadline - time.time() 4963 try: 4964 plumbing_response = svc.stub.List( 4965 req, 4966 metadata=svc.parent.get_metadata( 4967 'PeeringGroupResources.List', req), 4968 timeout=t) 4969 except Exception as e: 4970 if self.parent.shouldRetry(tries, e, deadline): 4971 tries += 1 4972 time.sleep( 4973 self.parent.exponentialBackoff(tries, deadline)) 4974 continue 4975 raise plumbing.convert_error_to_porcelain(e) from e 4976 tries = 0 4977 for plumbing_item in plumbing_response.peering_group_resources: 4978 yield plumbing.convert_peering_group_resource_to_porcelain( 4979 plumbing_item) 4980 if plumbing_response.meta.next_cursor == '': 4981 break 4982 req.meta.cursor = plumbing_response.meta.next_cursor 4983 4984 return generator(self, req) 4985 4986 4987class PeeringGroups: 4988 ''' 4989 PeeringGroups provides the building blocks necessary to obtain explicit network topology and routing. 4990 See `strongdm.models.PeeringGroup`. 4991 ''' 4992 def __init__(self, channel, client): 4993 self.parent = client 4994 self.stub = PeeringGroupsStub(channel) 4995 4996 def create(self, peering_group, timeout=None): 4997 ''' 4998 Create registers a new PeeringGroup. 4999 ''' 5000 deadline = None if timeout is None else time.time() + timeout 5001 req = PeeringGroupCreateRequest() 5002 5003 if peering_group is not None: 5004 req.peering_group.CopyFrom( 5005 plumbing.convert_peering_group_to_plumbing(peering_group)) 5006 tries = 0 5007 plumbing_response = None 5008 while True: 5009 t = None if deadline is None else deadline - time.time() 5010 try: 5011 plumbing_response = self.stub.Create( 5012 req, 5013 metadata=self.parent.get_metadata('PeeringGroups.Create', 5014 req), 5015 timeout=t) 5016 except Exception as e: 5017 if self.parent.shouldRetry(tries, e, deadline): 5018 tries += 1 5019 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5020 continue 5021 raise plumbing.convert_error_to_porcelain(e) from e 5022 break 5023 5024 resp = models.PeeringGroupCreateResponse() 5025 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5026 plumbing_response.meta) 5027 resp.peering_group = plumbing.convert_peering_group_to_porcelain( 5028 plumbing_response.peering_group) 5029 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5030 plumbing_response.rate_limit) 5031 return resp 5032 5033 def delete(self, id, timeout=None): 5034 ''' 5035 Delete removes a PeeringGroup by ID. 5036 ''' 5037 deadline = None if timeout is None else time.time() + timeout 5038 req = PeeringGroupDeleteRequest() 5039 5040 req.id = (id) 5041 tries = 0 5042 plumbing_response = None 5043 while True: 5044 t = None if deadline is None else deadline - time.time() 5045 try: 5046 plumbing_response = self.stub.Delete( 5047 req, 5048 metadata=self.parent.get_metadata('PeeringGroups.Delete', 5049 req), 5050 timeout=t) 5051 except Exception as e: 5052 if self.parent.shouldRetry(tries, e, deadline): 5053 tries += 1 5054 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5055 continue 5056 raise plumbing.convert_error_to_porcelain(e) from e 5057 break 5058 5059 resp = models.PeeringGroupDeleteResponse() 5060 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 5061 plumbing_response.meta) 5062 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5063 plumbing_response.rate_limit) 5064 return resp 5065 5066 def get(self, id, timeout=None): 5067 ''' 5068 Get reads one PeeringGroup by ID. It will load all its dependencies. 5069 ''' 5070 deadline = None if timeout is None else time.time() + timeout 5071 req = PeeringGroupGetRequest() 5072 if self.parent.snapshot_datetime is not None: 5073 req.meta.CopyFrom(GetRequestMetadata()) 5074 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5075 5076 req.id = (id) 5077 tries = 0 5078 plumbing_response = None 5079 while True: 5080 t = None if deadline is None else deadline - time.time() 5081 try: 5082 plumbing_response = self.stub.Get( 5083 req, 5084 metadata=self.parent.get_metadata('PeeringGroups.Get', 5085 req), 5086 timeout=t) 5087 except Exception as e: 5088 if self.parent.shouldRetry(tries, e, deadline): 5089 tries += 1 5090 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5091 continue 5092 raise plumbing.convert_error_to_porcelain(e) from e 5093 break 5094 5095 resp = models.PeeringGroupGetResponse() 5096 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5097 plumbing_response.meta) 5098 resp.peering_group = plumbing.convert_peering_group_to_porcelain( 5099 plumbing_response.peering_group) 5100 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5101 plumbing_response.rate_limit) 5102 return resp 5103 5104 def list(self, filter, *args, timeout=None): 5105 ''' 5106 List gets a list of Peering Groups. 5107 ''' 5108 deadline = None if timeout is None else time.time() + timeout 5109 req = PeeringGroupListRequest() 5110 req.meta.CopyFrom(ListRequestMetadata()) 5111 if self.parent.page_limit > 0: 5112 req.meta.limit = self.parent.page_limit 5113 if self.parent.snapshot_datetime is not None: 5114 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5115 5116 req.filter = plumbing.quote_filter_args(filter, *args) 5117 5118 def generator(svc, req): 5119 tries = 0 5120 while True: 5121 t = None if deadline is None else deadline - time.time() 5122 try: 5123 plumbing_response = svc.stub.List( 5124 req, 5125 metadata=svc.parent.get_metadata( 5126 'PeeringGroups.List', req), 5127 timeout=t) 5128 except Exception as e: 5129 if self.parent.shouldRetry(tries, e, deadline): 5130 tries += 1 5131 time.sleep( 5132 self.parent.exponentialBackoff(tries, deadline)) 5133 continue 5134 raise plumbing.convert_error_to_porcelain(e) from e 5135 tries = 0 5136 for plumbing_item in plumbing_response.peering_groups: 5137 yield plumbing.convert_peering_group_to_porcelain( 5138 plumbing_item) 5139 if plumbing_response.meta.next_cursor == '': 5140 break 5141 req.meta.cursor = plumbing_response.meta.next_cursor 5142 5143 return generator(self, req) 5144 5145 5146class Policies: 5147 ''' 5148 Policies are the collection of one or more statements that enforce fine-grained access 5149 control for the users of an organization. 5150 See `strongdm.models.Policy`. 5151 ''' 5152 def __init__(self, channel, client): 5153 self.parent = client 5154 self.stub = PoliciesStub(channel) 5155 5156 def create(self, policy, timeout=None): 5157 ''' 5158 Create creates a new Policy. 5159 ''' 5160 deadline = None if timeout is None else time.time() + timeout 5161 req = PolicyCreateRequest() 5162 5163 if policy is not None: 5164 req.policy.CopyFrom(plumbing.convert_policy_to_plumbing(policy)) 5165 tries = 0 5166 plumbing_response = None 5167 while True: 5168 t = None if deadline is None else deadline - time.time() 5169 try: 5170 plumbing_response = self.stub.Create( 5171 req, 5172 metadata=self.parent.get_metadata('Policies.Create', req), 5173 timeout=t) 5174 except Exception as e: 5175 if self.parent.shouldRetry(tries, e, deadline): 5176 tries += 1 5177 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5178 continue 5179 raise plumbing.convert_error_to_porcelain(e) from e 5180 break 5181 5182 resp = models.PolicyCreateResponse() 5183 resp.policy = plumbing.convert_policy_to_porcelain( 5184 plumbing_response.policy) 5185 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5186 plumbing_response.rate_limit) 5187 return resp 5188 5189 def delete(self, id, timeout=None): 5190 ''' 5191 Delete removes a Policy by ID. 5192 ''' 5193 deadline = None if timeout is None else time.time() + timeout 5194 req = PolicyDeleteRequest() 5195 5196 req.id = (id) 5197 tries = 0 5198 plumbing_response = None 5199 while True: 5200 t = None if deadline is None else deadline - time.time() 5201 try: 5202 plumbing_response = self.stub.Delete( 5203 req, 5204 metadata=self.parent.get_metadata('Policies.Delete', req), 5205 timeout=t) 5206 except Exception as e: 5207 if self.parent.shouldRetry(tries, e, deadline): 5208 tries += 1 5209 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5210 continue 5211 raise plumbing.convert_error_to_porcelain(e) from e 5212 break 5213 5214 resp = models.PolicyDeleteResponse() 5215 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5216 plumbing_response.rate_limit) 5217 return resp 5218 5219 def update(self, policy, timeout=None): 5220 ''' 5221 Update replaces all the fields of a Policy by ID. 5222 ''' 5223 deadline = None if timeout is None else time.time() + timeout 5224 req = PolicyUpdateRequest() 5225 5226 if policy is not None: 5227 req.policy.CopyFrom(plumbing.convert_policy_to_plumbing(policy)) 5228 tries = 0 5229 plumbing_response = None 5230 while True: 5231 t = None if deadline is None else deadline - time.time() 5232 try: 5233 plumbing_response = self.stub.Update( 5234 req, 5235 metadata=self.parent.get_metadata('Policies.Update', 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.PolicyUpdateResponse() 5246 resp.policy = plumbing.convert_policy_to_porcelain( 5247 plumbing_response.policy) 5248 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5249 plumbing_response.rate_limit) 5250 return resp 5251 5252 def get(self, id, timeout=None): 5253 ''' 5254 Get reads one Policy by ID. 5255 ''' 5256 deadline = None if timeout is None else time.time() + timeout 5257 req = PolicyGetRequest() 5258 if self.parent.snapshot_datetime is not None: 5259 req.meta.CopyFrom(GetRequestMetadata()) 5260 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5261 5262 req.id = (id) 5263 tries = 0 5264 plumbing_response = None 5265 while True: 5266 t = None if deadline is None else deadline - time.time() 5267 try: 5268 plumbing_response = self.stub.Get( 5269 req, 5270 metadata=self.parent.get_metadata('Policies.Get', 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.PolicyGetResponse() 5281 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5282 plumbing_response.meta) 5283 resp.policy = plumbing.convert_policy_to_porcelain( 5284 plumbing_response.policy) 5285 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5286 plumbing_response.rate_limit) 5287 return resp 5288 5289 def list(self, filter, *args, timeout=None): 5290 ''' 5291 List gets a list of Policy matching a given set of criteria 5292 ''' 5293 deadline = None if timeout is None else time.time() + timeout 5294 req = PolicyListRequest() 5295 req.meta.CopyFrom(ListRequestMetadata()) 5296 if self.parent.page_limit > 0: 5297 req.meta.limit = self.parent.page_limit 5298 if self.parent.snapshot_datetime is not None: 5299 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5300 5301 req.filter = plumbing.quote_filter_args(filter, *args) 5302 5303 def generator(svc, req): 5304 tries = 0 5305 while True: 5306 t = None if deadline is None else deadline - time.time() 5307 try: 5308 plumbing_response = svc.stub.List( 5309 req, 5310 metadata=svc.parent.get_metadata('Policies.List', req), 5311 timeout=t) 5312 except Exception as e: 5313 if self.parent.shouldRetry(tries, e, deadline): 5314 tries += 1 5315 time.sleep( 5316 self.parent.exponentialBackoff(tries, deadline)) 5317 continue 5318 raise plumbing.convert_error_to_porcelain(e) from e 5319 tries = 0 5320 for plumbing_item in plumbing_response.policies: 5321 yield plumbing.convert_policy_to_porcelain(plumbing_item) 5322 if plumbing_response.meta.next_cursor == '': 5323 break 5324 req.meta.cursor = plumbing_response.meta.next_cursor 5325 5326 return generator(self, req) 5327 5328 5329class SnapshotPolicies: 5330 ''' 5331 SnapshotPolicies exposes the read only methods of the Policies 5332 service for historical queries. 5333 ''' 5334 def __init__(self, policies): 5335 self.policies = policies 5336 5337 def get(self, id, timeout=None): 5338 ''' 5339 Get reads one Policy by ID. 5340 ''' 5341 return self.policies.get(id, timeout=timeout) 5342 5343 def list(self, filter, *args, timeout=None): 5344 ''' 5345 List gets a list of Policy matching a given set of criteria 5346 ''' 5347 return self.policies.list(filter, *args, timeout=timeout) 5348 5349 5350class PoliciesHistory: 5351 ''' 5352 PoliciesHistory records all changes to the state of a Policy. 5353 See `strongdm.models.PolicyHistory`. 5354 ''' 5355 def __init__(self, channel, client): 5356 self.parent = client 5357 self.stub = PoliciesHistoryStub(channel) 5358 5359 def list(self, filter, *args, timeout=None): 5360 ''' 5361 List gets a list of PolicyHistory records matching a given set of criteria. 5362 ''' 5363 deadline = None if timeout is None else time.time() + timeout 5364 req = PoliciesHistoryListRequest() 5365 req.meta.CopyFrom(ListRequestMetadata()) 5366 if self.parent.page_limit > 0: 5367 req.meta.limit = self.parent.page_limit 5368 if self.parent.snapshot_datetime is not None: 5369 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5370 5371 req.filter = plumbing.quote_filter_args(filter, *args) 5372 5373 def generator(svc, req): 5374 tries = 0 5375 while True: 5376 t = None if deadline is None else deadline - time.time() 5377 try: 5378 plumbing_response = svc.stub.List( 5379 req, 5380 metadata=svc.parent.get_metadata( 5381 'PoliciesHistory.List', req), 5382 timeout=t) 5383 except Exception as e: 5384 if self.parent.shouldRetry(tries, e, deadline): 5385 tries += 1 5386 time.sleep( 5387 self.parent.exponentialBackoff(tries, deadline)) 5388 continue 5389 raise plumbing.convert_error_to_porcelain(e) from e 5390 tries = 0 5391 for plumbing_item in plumbing_response.history: 5392 yield plumbing.convert_policy_history_to_porcelain( 5393 plumbing_item) 5394 if plumbing_response.meta.next_cursor == '': 5395 break 5396 req.meta.cursor = plumbing_response.meta.next_cursor 5397 5398 return generator(self, req) 5399 5400 5401class ProxyClusterKeys: 5402 ''' 5403 Proxy Cluster Keys are authentication keys for all proxies within a cluster. 5404 The proxies within a cluster share the same key. One cluster can have 5405 multiple keys in order to facilitate key rotation. 5406 See `strongdm.models.ProxyClusterKey`. 5407 ''' 5408 def __init__(self, channel, client): 5409 self.parent = client 5410 self.stub = ProxyClusterKeysStub(channel) 5411 5412 def create(self, proxy_cluster_key, timeout=None): 5413 ''' 5414 Create registers a new ProxyClusterKey. 5415 ''' 5416 deadline = None if timeout is None else time.time() + timeout 5417 req = ProxyClusterKeyCreateRequest() 5418 5419 if proxy_cluster_key is not None: 5420 req.proxy_cluster_key.CopyFrom( 5421 plumbing.convert_proxy_cluster_key_to_plumbing( 5422 proxy_cluster_key)) 5423 tries = 0 5424 plumbing_response = None 5425 while True: 5426 t = None if deadline is None else deadline - time.time() 5427 try: 5428 plumbing_response = self.stub.Create( 5429 req, 5430 metadata=self.parent.get_metadata( 5431 'ProxyClusterKeys.Create', req), 5432 timeout=t) 5433 except Exception as e: 5434 if self.parent.shouldRetry(tries, e, deadline): 5435 tries += 1 5436 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5437 continue 5438 raise plumbing.convert_error_to_porcelain(e) from e 5439 break 5440 5441 resp = models.ProxyClusterKeyCreateResponse() 5442 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5443 plumbing_response.meta) 5444 resp.proxy_cluster_key = plumbing.convert_proxy_cluster_key_to_porcelain( 5445 plumbing_response.proxy_cluster_key) 5446 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5447 plumbing_response.rate_limit) 5448 resp.secret_key = (plumbing_response.secret_key) 5449 return resp 5450 5451 def get(self, id, timeout=None): 5452 ''' 5453 Get reads one ProxyClusterKey by ID. 5454 ''' 5455 deadline = None if timeout is None else time.time() + timeout 5456 req = ProxyClusterKeyGetRequest() 5457 if self.parent.snapshot_datetime is not None: 5458 req.meta.CopyFrom(GetRequestMetadata()) 5459 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5460 5461 req.id = (id) 5462 tries = 0 5463 plumbing_response = None 5464 while True: 5465 t = None if deadline is None else deadline - time.time() 5466 try: 5467 plumbing_response = self.stub.Get( 5468 req, 5469 metadata=self.parent.get_metadata('ProxyClusterKeys.Get', 5470 req), 5471 timeout=t) 5472 except Exception as e: 5473 if self.parent.shouldRetry(tries, e, deadline): 5474 tries += 1 5475 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5476 continue 5477 raise plumbing.convert_error_to_porcelain(e) from e 5478 break 5479 5480 resp = models.ProxyClusterKeyGetResponse() 5481 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5482 plumbing_response.meta) 5483 resp.proxy_cluster_key = plumbing.convert_proxy_cluster_key_to_porcelain( 5484 plumbing_response.proxy_cluster_key) 5485 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5486 plumbing_response.rate_limit) 5487 return resp 5488 5489 def delete(self, id, timeout=None): 5490 ''' 5491 Delete removes a ProxyClusterKey by ID. 5492 ''' 5493 deadline = None if timeout is None else time.time() + timeout 5494 req = ProxyClusterKeyDeleteRequest() 5495 5496 req.id = (id) 5497 tries = 0 5498 plumbing_response = None 5499 while True: 5500 t = None if deadline is None else deadline - time.time() 5501 try: 5502 plumbing_response = self.stub.Delete( 5503 req, 5504 metadata=self.parent.get_metadata( 5505 'ProxyClusterKeys.Delete', req), 5506 timeout=t) 5507 except Exception as e: 5508 if self.parent.shouldRetry(tries, e, deadline): 5509 tries += 1 5510 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5511 continue 5512 raise plumbing.convert_error_to_porcelain(e) from e 5513 break 5514 5515 resp = models.ProxyClusterKeyDeleteResponse() 5516 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 5517 plumbing_response.meta) 5518 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5519 plumbing_response.rate_limit) 5520 return resp 5521 5522 def list(self, filter, *args, timeout=None): 5523 ''' 5524 List gets a list of ProxyClusterKeys matching a given set of criteria. 5525 ''' 5526 deadline = None if timeout is None else time.time() + timeout 5527 req = ProxyClusterKeyListRequest() 5528 req.meta.CopyFrom(ListRequestMetadata()) 5529 if self.parent.page_limit > 0: 5530 req.meta.limit = self.parent.page_limit 5531 if self.parent.snapshot_datetime is not None: 5532 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5533 5534 req.filter = plumbing.quote_filter_args(filter, *args) 5535 5536 def generator(svc, req): 5537 tries = 0 5538 while True: 5539 t = None if deadline is None else deadline - time.time() 5540 try: 5541 plumbing_response = svc.stub.List( 5542 req, 5543 metadata=svc.parent.get_metadata( 5544 'ProxyClusterKeys.List', req), 5545 timeout=t) 5546 except Exception as e: 5547 if self.parent.shouldRetry(tries, e, deadline): 5548 tries += 1 5549 time.sleep( 5550 self.parent.exponentialBackoff(tries, deadline)) 5551 continue 5552 raise plumbing.convert_error_to_porcelain(e) from e 5553 tries = 0 5554 for plumbing_item in plumbing_response.proxy_cluster_keys: 5555 yield plumbing.convert_proxy_cluster_key_to_porcelain( 5556 plumbing_item) 5557 if plumbing_response.meta.next_cursor == '': 5558 break 5559 req.meta.cursor = plumbing_response.meta.next_cursor 5560 5561 return generator(self, req) 5562 5563 5564class SnapshotProxyClusterKeys: 5565 ''' 5566 SnapshotProxyClusterKeys exposes the read only methods of the ProxyClusterKeys 5567 service for historical queries. 5568 ''' 5569 def __init__(self, proxy_cluster_keys): 5570 self.proxy_cluster_keys = proxy_cluster_keys 5571 5572 def get(self, id, timeout=None): 5573 ''' 5574 Get reads one ProxyClusterKey by ID. 5575 ''' 5576 return self.proxy_cluster_keys.get(id, timeout=timeout) 5577 5578 def list(self, filter, *args, timeout=None): 5579 ''' 5580 List gets a list of ProxyClusterKeys matching a given set of criteria. 5581 ''' 5582 return self.proxy_cluster_keys.list(filter, *args, timeout=timeout) 5583 5584 5585class Queries: 5586 ''' 5587 A Query is a record of a single client request to a resource, such as a SQL query. 5588 Long-running SSH, RDP, or Kubernetes interactive sessions also count as queries. 5589 The Queries service is read-only. 5590 See `strongdm.models.Query`. 5591 ''' 5592 def __init__(self, channel, client): 5593 self.parent = client 5594 self.stub = QueriesStub(channel) 5595 5596 def list(self, filter, *args, timeout=None): 5597 ''' 5598 List gets a list of Queries matching a given set of criteria. 5599 ''' 5600 deadline = None if timeout is None else time.time() + timeout 5601 req = QueryListRequest() 5602 req.meta.CopyFrom(ListRequestMetadata()) 5603 if self.parent.page_limit > 0: 5604 req.meta.limit = self.parent.page_limit 5605 if self.parent.snapshot_datetime is not None: 5606 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5607 5608 req.filter = plumbing.quote_filter_args(filter, *args) 5609 5610 def generator(svc, req): 5611 tries = 0 5612 while True: 5613 t = None if deadline is None else deadline - time.time() 5614 try: 5615 plumbing_response = svc.stub.List( 5616 req, 5617 metadata=svc.parent.get_metadata('Queries.List', req), 5618 timeout=t) 5619 except Exception as e: 5620 if self.parent.shouldRetry(tries, e, deadline): 5621 tries += 1 5622 time.sleep( 5623 self.parent.exponentialBackoff(tries, deadline)) 5624 continue 5625 raise plumbing.convert_error_to_porcelain(e) from e 5626 tries = 0 5627 for plumbing_item in plumbing_response.queries: 5628 yield plumbing.convert_query_to_porcelain(plumbing_item) 5629 if plumbing_response.meta.next_cursor == '': 5630 break 5631 req.meta.cursor = plumbing_response.meta.next_cursor 5632 5633 return generator(self, req) 5634 5635 5636class RemoteIdentities: 5637 ''' 5638 RemoteIdentities assign a resource directly to an account, giving the account the permission to connect to that resource. 5639 See `strongdm.models.RemoteIdentity`. 5640 ''' 5641 def __init__(self, channel, client): 5642 self.parent = client 5643 self.stub = RemoteIdentitiesStub(channel) 5644 5645 def create(self, remote_identity, timeout=None): 5646 ''' 5647 Create registers a new RemoteIdentity. 5648 ''' 5649 deadline = None if timeout is None else time.time() + timeout 5650 req = RemoteIdentityCreateRequest() 5651 5652 if remote_identity is not None: 5653 req.remote_identity.CopyFrom( 5654 plumbing.convert_remote_identity_to_plumbing(remote_identity)) 5655 tries = 0 5656 plumbing_response = None 5657 while True: 5658 t = None if deadline is None else deadline - time.time() 5659 try: 5660 plumbing_response = self.stub.Create( 5661 req, 5662 metadata=self.parent.get_metadata( 5663 'RemoteIdentities.Create', req), 5664 timeout=t) 5665 except Exception as e: 5666 if self.parent.shouldRetry(tries, e, deadline): 5667 tries += 1 5668 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5669 continue 5670 raise plumbing.convert_error_to_porcelain(e) from e 5671 break 5672 5673 resp = models.RemoteIdentityCreateResponse() 5674 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5675 plumbing_response.meta) 5676 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5677 plumbing_response.rate_limit) 5678 resp.remote_identity = plumbing.convert_remote_identity_to_porcelain( 5679 plumbing_response.remote_identity) 5680 return resp 5681 5682 def get(self, id, timeout=None): 5683 ''' 5684 Get reads one RemoteIdentity by ID. 5685 ''' 5686 deadline = None if timeout is None else time.time() + timeout 5687 req = RemoteIdentityGetRequest() 5688 if self.parent.snapshot_datetime is not None: 5689 req.meta.CopyFrom(GetRequestMetadata()) 5690 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5691 5692 req.id = (id) 5693 tries = 0 5694 plumbing_response = None 5695 while True: 5696 t = None if deadline is None else deadline - time.time() 5697 try: 5698 plumbing_response = self.stub.Get( 5699 req, 5700 metadata=self.parent.get_metadata('RemoteIdentities.Get', 5701 req), 5702 timeout=t) 5703 except Exception as e: 5704 if self.parent.shouldRetry(tries, e, deadline): 5705 tries += 1 5706 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5707 continue 5708 raise plumbing.convert_error_to_porcelain(e) from e 5709 break 5710 5711 resp = models.RemoteIdentityGetResponse() 5712 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5713 plumbing_response.meta) 5714 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5715 plumbing_response.rate_limit) 5716 resp.remote_identity = plumbing.convert_remote_identity_to_porcelain( 5717 plumbing_response.remote_identity) 5718 return resp 5719 5720 def update(self, remote_identity, timeout=None): 5721 ''' 5722 Update replaces all the fields of a RemoteIdentity by ID. 5723 ''' 5724 deadline = None if timeout is None else time.time() + timeout 5725 req = RemoteIdentityUpdateRequest() 5726 5727 if remote_identity is not None: 5728 req.remote_identity.CopyFrom( 5729 plumbing.convert_remote_identity_to_plumbing(remote_identity)) 5730 tries = 0 5731 plumbing_response = None 5732 while True: 5733 t = None if deadline is None else deadline - time.time() 5734 try: 5735 plumbing_response = self.stub.Update( 5736 req, 5737 metadata=self.parent.get_metadata( 5738 'RemoteIdentities.Update', req), 5739 timeout=t) 5740 except Exception as e: 5741 if self.parent.shouldRetry(tries, e, deadline): 5742 tries += 1 5743 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5744 continue 5745 raise plumbing.convert_error_to_porcelain(e) from e 5746 break 5747 5748 resp = models.RemoteIdentityUpdateResponse() 5749 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 5750 plumbing_response.meta) 5751 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5752 plumbing_response.rate_limit) 5753 resp.remote_identity = plumbing.convert_remote_identity_to_porcelain( 5754 plumbing_response.remote_identity) 5755 return resp 5756 5757 def delete(self, id, timeout=None): 5758 ''' 5759 Delete removes a RemoteIdentity by ID. 5760 ''' 5761 deadline = None if timeout is None else time.time() + timeout 5762 req = RemoteIdentityDeleteRequest() 5763 5764 req.id = (id) 5765 tries = 0 5766 plumbing_response = None 5767 while True: 5768 t = None if deadline is None else deadline - time.time() 5769 try: 5770 plumbing_response = self.stub.Delete( 5771 req, 5772 metadata=self.parent.get_metadata( 5773 'RemoteIdentities.Delete', req), 5774 timeout=t) 5775 except Exception as e: 5776 if self.parent.shouldRetry(tries, e, deadline): 5777 tries += 1 5778 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5779 continue 5780 raise plumbing.convert_error_to_porcelain(e) from e 5781 break 5782 5783 resp = models.RemoteIdentityDeleteResponse() 5784 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 5785 plumbing_response.meta) 5786 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5787 plumbing_response.rate_limit) 5788 return resp 5789 5790 def list(self, filter, *args, timeout=None): 5791 ''' 5792 List gets a list of RemoteIdentities matching a given set of criteria. 5793 ''' 5794 deadline = None if timeout is None else time.time() + timeout 5795 req = RemoteIdentityListRequest() 5796 req.meta.CopyFrom(ListRequestMetadata()) 5797 if self.parent.page_limit > 0: 5798 req.meta.limit = self.parent.page_limit 5799 if self.parent.snapshot_datetime is not None: 5800 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5801 5802 req.filter = plumbing.quote_filter_args(filter, *args) 5803 5804 def generator(svc, req): 5805 tries = 0 5806 while True: 5807 t = None if deadline is None else deadline - time.time() 5808 try: 5809 plumbing_response = svc.stub.List( 5810 req, 5811 metadata=svc.parent.get_metadata( 5812 'RemoteIdentities.List', req), 5813 timeout=t) 5814 except Exception as e: 5815 if self.parent.shouldRetry(tries, e, deadline): 5816 tries += 1 5817 time.sleep( 5818 self.parent.exponentialBackoff(tries, deadline)) 5819 continue 5820 raise plumbing.convert_error_to_porcelain(e) from e 5821 tries = 0 5822 for plumbing_item in plumbing_response.remote_identities: 5823 yield plumbing.convert_remote_identity_to_porcelain( 5824 plumbing_item) 5825 if plumbing_response.meta.next_cursor == '': 5826 break 5827 req.meta.cursor = plumbing_response.meta.next_cursor 5828 5829 return generator(self, req) 5830 5831 5832class SnapshotRemoteIdentities: 5833 ''' 5834 SnapshotRemoteIdentities exposes the read only methods of the RemoteIdentities 5835 service for historical queries. 5836 ''' 5837 def __init__(self, remote_identities): 5838 self.remote_identities = remote_identities 5839 5840 def get(self, id, timeout=None): 5841 ''' 5842 Get reads one RemoteIdentity by ID. 5843 ''' 5844 return self.remote_identities.get(id, timeout=timeout) 5845 5846 def list(self, filter, *args, timeout=None): 5847 ''' 5848 List gets a list of RemoteIdentities matching a given set of criteria. 5849 ''' 5850 return self.remote_identities.list(filter, *args, timeout=timeout) 5851 5852 5853class RemoteIdentitiesHistory: 5854 ''' 5855 RemoteIdentitiesHistory records all changes to the state of a RemoteIdentity. 5856 See `strongdm.models.RemoteIdentityHistory`. 5857 ''' 5858 def __init__(self, channel, client): 5859 self.parent = client 5860 self.stub = RemoteIdentitiesHistoryStub(channel) 5861 5862 def list(self, filter, *args, timeout=None): 5863 ''' 5864 List gets a list of RemoteIdentityHistory records matching a given set of criteria. 5865 ''' 5866 deadline = None if timeout is None else time.time() + timeout 5867 req = RemoteIdentityHistoryListRequest() 5868 req.meta.CopyFrom(ListRequestMetadata()) 5869 if self.parent.page_limit > 0: 5870 req.meta.limit = self.parent.page_limit 5871 if self.parent.snapshot_datetime is not None: 5872 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5873 5874 req.filter = plumbing.quote_filter_args(filter, *args) 5875 5876 def generator(svc, req): 5877 tries = 0 5878 while True: 5879 t = None if deadline is None else deadline - time.time() 5880 try: 5881 plumbing_response = svc.stub.List( 5882 req, 5883 metadata=svc.parent.get_metadata( 5884 'RemoteIdentitiesHistory.List', req), 5885 timeout=t) 5886 except Exception as e: 5887 if self.parent.shouldRetry(tries, e, deadline): 5888 tries += 1 5889 time.sleep( 5890 self.parent.exponentialBackoff(tries, deadline)) 5891 continue 5892 raise plumbing.convert_error_to_porcelain(e) from e 5893 tries = 0 5894 for plumbing_item in plumbing_response.history: 5895 yield plumbing.convert_remote_identity_history_to_porcelain( 5896 plumbing_item) 5897 if plumbing_response.meta.next_cursor == '': 5898 break 5899 req.meta.cursor = plumbing_response.meta.next_cursor 5900 5901 return generator(self, req) 5902 5903 5904class RemoteIdentityGroups: 5905 ''' 5906 A RemoteIdentityGroup is a named grouping of Remote Identities for Accounts. 5907 An Account's relationship to a RemoteIdentityGroup is defined via RemoteIdentity objects. 5908 See `strongdm.models.RemoteIdentityGroup`. 5909 ''' 5910 def __init__(self, channel, client): 5911 self.parent = client 5912 self.stub = RemoteIdentityGroupsStub(channel) 5913 5914 def get(self, id, timeout=None): 5915 ''' 5916 Get reads one RemoteIdentityGroup by ID. 5917 ''' 5918 deadline = None if timeout is None else time.time() + timeout 5919 req = RemoteIdentityGroupGetRequest() 5920 if self.parent.snapshot_datetime is not None: 5921 req.meta.CopyFrom(GetRequestMetadata()) 5922 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5923 5924 req.id = (id) 5925 tries = 0 5926 plumbing_response = None 5927 while True: 5928 t = None if deadline is None else deadline - time.time() 5929 try: 5930 plumbing_response = self.stub.Get( 5931 req, 5932 metadata=self.parent.get_metadata( 5933 'RemoteIdentityGroups.Get', req), 5934 timeout=t) 5935 except Exception as e: 5936 if self.parent.shouldRetry(tries, e, deadline): 5937 tries += 1 5938 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5939 continue 5940 raise plumbing.convert_error_to_porcelain(e) from e 5941 break 5942 5943 resp = models.RemoteIdentityGroupGetResponse() 5944 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5945 plumbing_response.meta) 5946 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5947 plumbing_response.rate_limit) 5948 resp.remote_identity_group = plumbing.convert_remote_identity_group_to_porcelain( 5949 plumbing_response.remote_identity_group) 5950 return resp 5951 5952 def list(self, filter, *args, timeout=None): 5953 ''' 5954 List gets a list of RemoteIdentityGroups matching a given set of criteria. 5955 ''' 5956 deadline = None if timeout is None else time.time() + timeout 5957 req = RemoteIdentityGroupListRequest() 5958 req.meta.CopyFrom(ListRequestMetadata()) 5959 if self.parent.page_limit > 0: 5960 req.meta.limit = self.parent.page_limit 5961 if self.parent.snapshot_datetime is not None: 5962 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5963 5964 req.filter = plumbing.quote_filter_args(filter, *args) 5965 5966 def generator(svc, req): 5967 tries = 0 5968 while True: 5969 t = None if deadline is None else deadline - time.time() 5970 try: 5971 plumbing_response = svc.stub.List( 5972 req, 5973 metadata=svc.parent.get_metadata( 5974 'RemoteIdentityGroups.List', req), 5975 timeout=t) 5976 except Exception as e: 5977 if self.parent.shouldRetry(tries, e, deadline): 5978 tries += 1 5979 time.sleep( 5980 self.parent.exponentialBackoff(tries, deadline)) 5981 continue 5982 raise plumbing.convert_error_to_porcelain(e) from e 5983 tries = 0 5984 for plumbing_item in plumbing_response.remote_identity_groups: 5985 yield plumbing.convert_remote_identity_group_to_porcelain( 5986 plumbing_item) 5987 if plumbing_response.meta.next_cursor == '': 5988 break 5989 req.meta.cursor = plumbing_response.meta.next_cursor 5990 5991 return generator(self, req) 5992 5993 5994class SnapshotRemoteIdentityGroups: 5995 ''' 5996 SnapshotRemoteIdentityGroups exposes the read only methods of the RemoteIdentityGroups 5997 service for historical queries. 5998 ''' 5999 def __init__(self, remote_identity_groups): 6000 self.remote_identity_groups = remote_identity_groups 6001 6002 def get(self, id, timeout=None): 6003 ''' 6004 Get reads one RemoteIdentityGroup by ID. 6005 ''' 6006 return self.remote_identity_groups.get(id, timeout=timeout) 6007 6008 def list(self, filter, *args, timeout=None): 6009 ''' 6010 List gets a list of RemoteIdentityGroups matching a given set of criteria. 6011 ''' 6012 return self.remote_identity_groups.list(filter, *args, timeout=timeout) 6013 6014 6015class RemoteIdentityGroupsHistory: 6016 ''' 6017 RemoteIdentityGroupsHistory records all changes to the state of a RemoteIdentityGroup. 6018 See `strongdm.models.RemoteIdentityGroupHistory`. 6019 ''' 6020 def __init__(self, channel, client): 6021 self.parent = client 6022 self.stub = RemoteIdentityGroupsHistoryStub(channel) 6023 6024 def list(self, filter, *args, timeout=None): 6025 ''' 6026 List gets a list of RemoteIdentityGroupHistory records matching a given set of criteria. 6027 ''' 6028 deadline = None if timeout is None else time.time() + timeout 6029 req = RemoteIdentityGroupHistoryListRequest() 6030 req.meta.CopyFrom(ListRequestMetadata()) 6031 if self.parent.page_limit > 0: 6032 req.meta.limit = self.parent.page_limit 6033 if self.parent.snapshot_datetime is not None: 6034 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6035 6036 req.filter = plumbing.quote_filter_args(filter, *args) 6037 6038 def generator(svc, req): 6039 tries = 0 6040 while True: 6041 t = None if deadline is None else deadline - time.time() 6042 try: 6043 plumbing_response = svc.stub.List( 6044 req, 6045 metadata=svc.parent.get_metadata( 6046 'RemoteIdentityGroupsHistory.List', req), 6047 timeout=t) 6048 except Exception as e: 6049 if self.parent.shouldRetry(tries, e, deadline): 6050 tries += 1 6051 time.sleep( 6052 self.parent.exponentialBackoff(tries, deadline)) 6053 continue 6054 raise plumbing.convert_error_to_porcelain(e) from e 6055 tries = 0 6056 for plumbing_item in plumbing_response.history: 6057 yield plumbing.convert_remote_identity_group_history_to_porcelain( 6058 plumbing_item) 6059 if plumbing_response.meta.next_cursor == '': 6060 break 6061 req.meta.cursor = plumbing_response.meta.next_cursor 6062 6063 return generator(self, req) 6064 6065 6066class Replays: 6067 ''' 6068 A Replay captures the data transferred over a long-running SSH, RDP, or Kubernetes interactive session 6069 (otherwise referred to as a query). The Replays service is read-only. 6070 See `strongdm.models.ReplayChunk`. 6071 ''' 6072 def __init__(self, channel, client): 6073 self.parent = client 6074 self.stub = ReplaysStub(channel) 6075 6076 def list(self, filter, *args, timeout=None): 6077 ''' 6078 List gets a list of ReplayChunks for the Query ID specified by the filter criteria. 6079 ''' 6080 deadline = None if timeout is None else time.time() + timeout 6081 req = ReplayListRequest() 6082 req.meta.CopyFrom(ListRequestMetadata()) 6083 if self.parent.page_limit > 0: 6084 req.meta.limit = self.parent.page_limit 6085 if self.parent.snapshot_datetime is not None: 6086 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6087 6088 req.filter = plumbing.quote_filter_args(filter, *args) 6089 6090 def generator(svc, req): 6091 tries = 0 6092 while True: 6093 t = None if deadline is None else deadline - time.time() 6094 try: 6095 plumbing_response = svc.stub.List( 6096 req, 6097 metadata=svc.parent.get_metadata('Replays.List', req), 6098 timeout=t) 6099 except Exception as e: 6100 if self.parent.shouldRetry(tries, e, deadline): 6101 tries += 1 6102 time.sleep( 6103 self.parent.exponentialBackoff(tries, deadline)) 6104 continue 6105 raise plumbing.convert_error_to_porcelain(e) from e 6106 tries = 0 6107 for plumbing_item in plumbing_response.chunks: 6108 yield plumbing.convert_replay_chunk_to_porcelain( 6109 plumbing_item) 6110 if plumbing_response.meta.next_cursor == '': 6111 break 6112 req.meta.cursor = plumbing_response.meta.next_cursor 6113 6114 return generator(self, req) 6115 6116 6117class Resources: 6118 ''' 6119 Resources are databases, servers, clusters, websites, or clouds that strongDM 6120 delegates access to. 6121 See: 6122 `strongdm.models.Aerospike` 6123 `strongdm.models.AKS` 6124 `strongdm.models.AKSBasicAuth` 6125 `strongdm.models.AKSServiceAccount` 6126 `strongdm.models.AKSServiceAccountUserImpersonation` 6127 `strongdm.models.AKSUserImpersonation` 6128 `strongdm.models.AmazonEKS` 6129 `strongdm.models.AmazonEKSInstanceProfile` 6130 `strongdm.models.AmazonEKSInstanceProfileUserImpersonation` 6131 `strongdm.models.AmazonEKSUserImpersonation` 6132 `strongdm.models.AmazonES` 6133 `strongdm.models.AmazonESIAM` 6134 `strongdm.models.AmazonMQAMQP091` 6135 `strongdm.models.AMQP` 6136 `strongdm.models.Athena` 6137 `strongdm.models.AthenaIAM` 6138 `strongdm.models.AuroraMysql` 6139 `strongdm.models.AuroraMysqlIAM` 6140 `strongdm.models.AuroraPostgres` 6141 `strongdm.models.AuroraPostgresIAM` 6142 `strongdm.models.AWS` 6143 `strongdm.models.AWSConsole` 6144 `strongdm.models.AWSConsoleStaticKeyPair` 6145 `strongdm.models.AWSInstanceProfile` 6146 `strongdm.models.Azure` 6147 `strongdm.models.AzureCertificate` 6148 `strongdm.models.AzureMysql` 6149 `strongdm.models.AzureMysqlManagedIdentity` 6150 `strongdm.models.AzurePostgres` 6151 `strongdm.models.AzurePostgresManagedIdentity` 6152 `strongdm.models.BigQuery` 6153 `strongdm.models.Cassandra` 6154 `strongdm.models.Citus` 6155 `strongdm.models.ClickHouseHTTP` 6156 `strongdm.models.ClickHouseMySQL` 6157 `strongdm.models.ClickHouseTCP` 6158 `strongdm.models.Clustrix` 6159 `strongdm.models.Cockroach` 6160 `strongdm.models.CouchbaseDatabase` 6161 `strongdm.models.CouchbaseWebUI` 6162 `strongdm.models.DB2I` 6163 `strongdm.models.DB2LUW` 6164 `strongdm.models.DocumentDBHost` 6165 `strongdm.models.DocumentDBHostIAM` 6166 `strongdm.models.DocumentDBReplicaSet` 6167 `strongdm.models.DocumentDBReplicaSetIAM` 6168 `strongdm.models.Druid` 6169 `strongdm.models.DynamoDB` 6170 `strongdm.models.DynamoDBIAM` 6171 `strongdm.models.Elastic` 6172 `strongdm.models.ElasticacheRedis` 6173 `strongdm.models.ElasticacheRedisIAM` 6174 `strongdm.models.EntraID` 6175 `strongdm.models.GCP` 6176 `strongdm.models.GCPConsole` 6177 `strongdm.models.GCPWIF` 6178 `strongdm.models.GoogleGKE` 6179 `strongdm.models.GoogleGKEUserImpersonation` 6180 `strongdm.models.Greenplum` 6181 `strongdm.models.HTTPAuth` 6182 `strongdm.models.HTTPBasicAuth` 6183 `strongdm.models.HTTPNoAuth` 6184 `strongdm.models.Kubernetes` 6185 `strongdm.models.KubernetesBasicAuth` 6186 `strongdm.models.KubernetesPodIdentity` 6187 `strongdm.models.KubernetesServiceAccount` 6188 `strongdm.models.KubernetesServiceAccountUserImpersonation` 6189 `strongdm.models.KubernetesUserImpersonation` 6190 `strongdm.models.Maria` 6191 `strongdm.models.MCP` 6192 `strongdm.models.Memcached` 6193 `strongdm.models.Memsql` 6194 `strongdm.models.MongoHost` 6195 `strongdm.models.MongoLegacyHost` 6196 `strongdm.models.MongoLegacyReplicaset` 6197 `strongdm.models.MongoReplicaSet` 6198 `strongdm.models.MongoShardedCluster` 6199 `strongdm.models.MTLSMysql` 6200 `strongdm.models.MTLSPostgres` 6201 `strongdm.models.Mysql` 6202 `strongdm.models.Neptune` 6203 `strongdm.models.NeptuneIAM` 6204 `strongdm.models.Oracle` 6205 `strongdm.models.OracleNNE` 6206 `strongdm.models.Postgres` 6207 `strongdm.models.Presto` 6208 `strongdm.models.RabbitMQAMQP091` 6209 `strongdm.models.RawTCP` 6210 `strongdm.models.RDP` 6211 `strongdm.models.RDPCert` 6212 `strongdm.models.RDSPostgresIAM` 6213 `strongdm.models.Redis` 6214 `strongdm.models.RedisCluster` 6215 `strongdm.models.Redshift` 6216 `strongdm.models.RedshiftIAM` 6217 `strongdm.models.RedshiftServerlessIAM` 6218 `strongdm.models.SingleStore` 6219 `strongdm.models.Snowflake` 6220 `strongdm.models.Snowsight` 6221 `strongdm.models.SQLServer` 6222 `strongdm.models.SQLServerAzureAD` 6223 `strongdm.models.SQLServerKerberosAD` 6224 `strongdm.models.SSH` 6225 `strongdm.models.SSHCert` 6226 `strongdm.models.SSHCustomerKey` 6227 `strongdm.models.SSHPassword` 6228 `strongdm.models.Sybase` 6229 `strongdm.models.SybaseIQ` 6230 `strongdm.models.Teradata` 6231 `strongdm.models.Trino` 6232 `strongdm.models.Vertica` 6233 ''' 6234 def __init__(self, channel, client): 6235 self.parent = client 6236 self.stub = ResourcesStub(channel) 6237 6238 def enumerate_tags(self, filter, *args, timeout=None): 6239 ''' 6240 EnumerateTags gets a list of the filter matching tags. 6241 ''' 6242 deadline = None if timeout is None else time.time() + timeout 6243 req = EnumerateTagsRequest() 6244 req.meta.CopyFrom(ListRequestMetadata()) 6245 if self.parent.page_limit > 0: 6246 req.meta.limit = self.parent.page_limit 6247 if self.parent.snapshot_datetime is not None: 6248 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6249 6250 req.filter = plumbing.quote_filter_args(filter, *args) 6251 6252 def generator(svc, req): 6253 tries = 0 6254 while True: 6255 t = None if deadline is None else deadline - time.time() 6256 try: 6257 plumbing_response = svc.stub.EnumerateTags( 6258 req, 6259 metadata=svc.parent.get_metadata( 6260 'Resources.EnumerateTags', req), 6261 timeout=t) 6262 except Exception as e: 6263 if self.parent.shouldRetry(tries, e, deadline): 6264 tries += 1 6265 time.sleep( 6266 self.parent.exponentialBackoff(tries, deadline)) 6267 continue 6268 raise plumbing.convert_error_to_porcelain(e) from e 6269 tries = 0 6270 for plumbing_item in plumbing_response.matches: 6271 yield plumbing.convert_tag_to_porcelain(plumbing_item) 6272 if plumbing_response.meta.next_cursor == '': 6273 break 6274 req.meta.cursor = plumbing_response.meta.next_cursor 6275 6276 return generator(self, req) 6277 6278 def create(self, resource, timeout=None): 6279 ''' 6280 Create registers a new Resource. 6281 ''' 6282 deadline = None if timeout is None else time.time() + timeout 6283 req = ResourceCreateRequest() 6284 6285 if resource is not None: 6286 req.resource.CopyFrom( 6287 plumbing.convert_resource_to_plumbing(resource)) 6288 tries = 0 6289 plumbing_response = None 6290 while True: 6291 t = None if deadline is None else deadline - time.time() 6292 try: 6293 plumbing_response = self.stub.Create( 6294 req, 6295 metadata=self.parent.get_metadata('Resources.Create', req), 6296 timeout=t) 6297 except Exception as e: 6298 if self.parent.shouldRetry(tries, e, deadline): 6299 tries += 1 6300 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6301 continue 6302 raise plumbing.convert_error_to_porcelain(e) from e 6303 break 6304 6305 resp = models.ResourceCreateResponse() 6306 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 6307 plumbing_response.meta) 6308 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6309 plumbing_response.rate_limit) 6310 resp.resource = plumbing.convert_resource_to_porcelain( 6311 plumbing_response.resource) 6312 return resp 6313 6314 def get(self, id, timeout=None): 6315 ''' 6316 Get reads one Resource by ID. 6317 ''' 6318 deadline = None if timeout is None else time.time() + timeout 6319 req = ResourceGetRequest() 6320 if self.parent.snapshot_datetime is not None: 6321 req.meta.CopyFrom(GetRequestMetadata()) 6322 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6323 6324 req.id = (id) 6325 tries = 0 6326 plumbing_response = None 6327 while True: 6328 t = None if deadline is None else deadline - time.time() 6329 try: 6330 plumbing_response = self.stub.Get( 6331 req, 6332 metadata=self.parent.get_metadata('Resources.Get', req), 6333 timeout=t) 6334 except Exception as e: 6335 if self.parent.shouldRetry(tries, e, deadline): 6336 tries += 1 6337 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6338 continue 6339 raise plumbing.convert_error_to_porcelain(e) from e 6340 break 6341 6342 resp = models.ResourceGetResponse() 6343 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 6344 plumbing_response.meta) 6345 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6346 plumbing_response.rate_limit) 6347 resp.resource = plumbing.convert_resource_to_porcelain( 6348 plumbing_response.resource) 6349 return resp 6350 6351 def update(self, resource, timeout=None): 6352 ''' 6353 Update replaces all the fields of a Resource by ID. 6354 ''' 6355 deadline = None if timeout is None else time.time() + timeout 6356 req = ResourceUpdateRequest() 6357 6358 if resource is not None: 6359 req.resource.CopyFrom( 6360 plumbing.convert_resource_to_plumbing(resource)) 6361 tries = 0 6362 plumbing_response = None 6363 while True: 6364 t = None if deadline is None else deadline - time.time() 6365 try: 6366 plumbing_response = self.stub.Update( 6367 req, 6368 metadata=self.parent.get_metadata('Resources.Update', req), 6369 timeout=t) 6370 except Exception as e: 6371 if self.parent.shouldRetry(tries, e, deadline): 6372 tries += 1 6373 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6374 continue 6375 raise plumbing.convert_error_to_porcelain(e) from e 6376 break 6377 6378 resp = models.ResourceUpdateResponse() 6379 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 6380 plumbing_response.meta) 6381 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6382 plumbing_response.rate_limit) 6383 resp.resource = plumbing.convert_resource_to_porcelain( 6384 plumbing_response.resource) 6385 return resp 6386 6387 def delete(self, id, timeout=None): 6388 ''' 6389 Delete removes a Resource by ID. 6390 ''' 6391 deadline = None if timeout is None else time.time() + timeout 6392 req = ResourceDeleteRequest() 6393 6394 req.id = (id) 6395 tries = 0 6396 plumbing_response = None 6397 while True: 6398 t = None if deadline is None else deadline - time.time() 6399 try: 6400 plumbing_response = self.stub.Delete( 6401 req, 6402 metadata=self.parent.get_metadata('Resources.Delete', req), 6403 timeout=t) 6404 except Exception as e: 6405 if self.parent.shouldRetry(tries, e, deadline): 6406 tries += 1 6407 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6408 continue 6409 raise plumbing.convert_error_to_porcelain(e) from e 6410 break 6411 6412 resp = models.ResourceDeleteResponse() 6413 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 6414 plumbing_response.meta) 6415 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6416 plumbing_response.rate_limit) 6417 return resp 6418 6419 def list(self, filter, *args, timeout=None): 6420 ''' 6421 List gets a list of Resources matching a given set of criteria. 6422 ''' 6423 deadline = None if timeout is None else time.time() + timeout 6424 req = ResourceListRequest() 6425 req.meta.CopyFrom(ListRequestMetadata()) 6426 if self.parent.page_limit > 0: 6427 req.meta.limit = self.parent.page_limit 6428 if self.parent.snapshot_datetime is not None: 6429 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6430 6431 req.filter = plumbing.quote_filter_args(filter, *args) 6432 6433 def generator(svc, req): 6434 tries = 0 6435 while True: 6436 t = None if deadline is None else deadline - time.time() 6437 try: 6438 plumbing_response = svc.stub.List( 6439 req, 6440 metadata=svc.parent.get_metadata( 6441 'Resources.List', req), 6442 timeout=t) 6443 except Exception as e: 6444 if self.parent.shouldRetry(tries, e, deadline): 6445 tries += 1 6446 time.sleep( 6447 self.parent.exponentialBackoff(tries, deadline)) 6448 continue 6449 raise plumbing.convert_error_to_porcelain(e) from e 6450 tries = 0 6451 for plumbing_item in plumbing_response.resources: 6452 yield plumbing.convert_resource_to_porcelain(plumbing_item) 6453 if plumbing_response.meta.next_cursor == '': 6454 break 6455 req.meta.cursor = plumbing_response.meta.next_cursor 6456 6457 return generator(self, req) 6458 6459 def healthcheck(self, id, timeout=None): 6460 ''' 6461 Healthcheck triggers a remote healthcheck. It may take minutes to propagate across a 6462 large network of Nodes. The call will return immediately, and the updated health of the 6463 Resource can be retrieved via Get or List. 6464 ''' 6465 deadline = None if timeout is None else time.time() + timeout 6466 req = ResourceHealthcheckRequest() 6467 6468 req.id = (id) 6469 tries = 0 6470 plumbing_response = None 6471 while True: 6472 t = None if deadline is None else deadline - time.time() 6473 try: 6474 plumbing_response = self.stub.Healthcheck( 6475 req, 6476 metadata=self.parent.get_metadata('Resources.Healthcheck', 6477 req), 6478 timeout=t) 6479 except Exception as e: 6480 if self.parent.shouldRetry(tries, e, deadline): 6481 tries += 1 6482 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6483 continue 6484 raise plumbing.convert_error_to_porcelain(e) from e 6485 break 6486 6487 resp = models.ResourceHealthcheckResponse() 6488 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 6489 plumbing_response.meta) 6490 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6491 plumbing_response.rate_limit) 6492 return resp 6493 6494 6495class SnapshotResources: 6496 ''' 6497 SnapshotResources exposes the read only methods of the Resources 6498 service for historical queries. 6499 ''' 6500 def __init__(self, resources): 6501 self.resources = resources 6502 6503 def get(self, id, timeout=None): 6504 ''' 6505 Get reads one Resource by ID. 6506 ''' 6507 return self.resources.get(id, timeout=timeout) 6508 6509 def list(self, filter, *args, timeout=None): 6510 ''' 6511 List gets a list of Resources matching a given set of criteria. 6512 ''' 6513 return self.resources.list(filter, *args, timeout=timeout) 6514 6515 6516class ResourcesHistory: 6517 ''' 6518 ResourcesHistory records all changes to the state of a Resource. 6519 See `strongdm.models.ResourceHistory`. 6520 ''' 6521 def __init__(self, channel, client): 6522 self.parent = client 6523 self.stub = ResourcesHistoryStub(channel) 6524 6525 def list(self, filter, *args, timeout=None): 6526 ''' 6527 List gets a list of ResourceHistory records matching a given set of criteria. 6528 ''' 6529 deadline = None if timeout is None else time.time() + timeout 6530 req = ResourceHistoryListRequest() 6531 req.meta.CopyFrom(ListRequestMetadata()) 6532 if self.parent.page_limit > 0: 6533 req.meta.limit = self.parent.page_limit 6534 if self.parent.snapshot_datetime is not None: 6535 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6536 6537 req.filter = plumbing.quote_filter_args(filter, *args) 6538 6539 def generator(svc, req): 6540 tries = 0 6541 while True: 6542 t = None if deadline is None else deadline - time.time() 6543 try: 6544 plumbing_response = svc.stub.List( 6545 req, 6546 metadata=svc.parent.get_metadata( 6547 'ResourcesHistory.List', req), 6548 timeout=t) 6549 except Exception as e: 6550 if self.parent.shouldRetry(tries, e, deadline): 6551 tries += 1 6552 time.sleep( 6553 self.parent.exponentialBackoff(tries, deadline)) 6554 continue 6555 raise plumbing.convert_error_to_porcelain(e) from e 6556 tries = 0 6557 for plumbing_item in plumbing_response.history: 6558 yield plumbing.convert_resource_history_to_porcelain( 6559 plumbing_item) 6560 if plumbing_response.meta.next_cursor == '': 6561 break 6562 req.meta.cursor = plumbing_response.meta.next_cursor 6563 6564 return generator(self, req) 6565 6566 6567class RoleResources: 6568 ''' 6569 RoleResources enumerates the resources to which roles have access. 6570 The RoleResources service is read-only. 6571 See `strongdm.models.RoleResource`. 6572 ''' 6573 def __init__(self, channel, client): 6574 self.parent = client 6575 self.stub = RoleResourcesStub(channel) 6576 6577 def list(self, filter, *args, timeout=None): 6578 ''' 6579 List gets a list of RoleResource records matching a given set of criteria. 6580 ''' 6581 deadline = None if timeout is None else time.time() + timeout 6582 req = RoleResourceListRequest() 6583 req.meta.CopyFrom(ListRequestMetadata()) 6584 if self.parent.page_limit > 0: 6585 req.meta.limit = self.parent.page_limit 6586 if self.parent.snapshot_datetime is not None: 6587 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6588 6589 req.filter = plumbing.quote_filter_args(filter, *args) 6590 6591 def generator(svc, req): 6592 tries = 0 6593 while True: 6594 t = None if deadline is None else deadline - time.time() 6595 try: 6596 plumbing_response = svc.stub.List( 6597 req, 6598 metadata=svc.parent.get_metadata( 6599 'RoleResources.List', req), 6600 timeout=t) 6601 except Exception as e: 6602 if self.parent.shouldRetry(tries, e, deadline): 6603 tries += 1 6604 time.sleep( 6605 self.parent.exponentialBackoff(tries, deadline)) 6606 continue 6607 raise plumbing.convert_error_to_porcelain(e) from e 6608 tries = 0 6609 for plumbing_item in plumbing_response.role_resources: 6610 yield plumbing.convert_role_resource_to_porcelain( 6611 plumbing_item) 6612 if plumbing_response.meta.next_cursor == '': 6613 break 6614 req.meta.cursor = plumbing_response.meta.next_cursor 6615 6616 return generator(self, req) 6617 6618 6619class SnapshotRoleResources: 6620 ''' 6621 SnapshotRoleResources exposes the read only methods of the RoleResources 6622 service for historical queries. 6623 ''' 6624 def __init__(self, role_resources): 6625 self.role_resources = role_resources 6626 6627 def list(self, filter, *args, timeout=None): 6628 ''' 6629 List gets a list of RoleResource records matching a given set of criteria. 6630 ''' 6631 return self.role_resources.list(filter, *args, timeout=timeout) 6632 6633 6634class RoleResourcesHistory: 6635 ''' 6636 RoleResourcesHistory records all changes to the state of a RoleResource. 6637 See `strongdm.models.RoleResourceHistory`. 6638 ''' 6639 def __init__(self, channel, client): 6640 self.parent = client 6641 self.stub = RoleResourcesHistoryStub(channel) 6642 6643 def list(self, filter, *args, timeout=None): 6644 ''' 6645 List gets a list of RoleResourceHistory records matching a given set of criteria. 6646 ''' 6647 deadline = None if timeout is None else time.time() + timeout 6648 req = RoleResourceHistoryListRequest() 6649 req.meta.CopyFrom(ListRequestMetadata()) 6650 if self.parent.page_limit > 0: 6651 req.meta.limit = self.parent.page_limit 6652 if self.parent.snapshot_datetime is not None: 6653 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6654 6655 req.filter = plumbing.quote_filter_args(filter, *args) 6656 6657 def generator(svc, req): 6658 tries = 0 6659 while True: 6660 t = None if deadline is None else deadline - time.time() 6661 try: 6662 plumbing_response = svc.stub.List( 6663 req, 6664 metadata=svc.parent.get_metadata( 6665 'RoleResourcesHistory.List', req), 6666 timeout=t) 6667 except Exception as e: 6668 if self.parent.shouldRetry(tries, e, deadline): 6669 tries += 1 6670 time.sleep( 6671 self.parent.exponentialBackoff(tries, deadline)) 6672 continue 6673 raise plumbing.convert_error_to_porcelain(e) from e 6674 tries = 0 6675 for plumbing_item in plumbing_response.history: 6676 yield plumbing.convert_role_resource_history_to_porcelain( 6677 plumbing_item) 6678 if plumbing_response.meta.next_cursor == '': 6679 break 6680 req.meta.cursor = plumbing_response.meta.next_cursor 6681 6682 return generator(self, req) 6683 6684 6685class RolesHistory: 6686 ''' 6687 RolesHistory records all changes to the state of a Role. 6688 See `strongdm.models.RoleHistory`. 6689 ''' 6690 def __init__(self, channel, client): 6691 self.parent = client 6692 self.stub = RolesHistoryStub(channel) 6693 6694 def list(self, filter, *args, timeout=None): 6695 ''' 6696 List gets a list of RoleHistory records matching a given set of criteria. 6697 ''' 6698 deadline = None if timeout is None else time.time() + timeout 6699 req = RoleHistoryListRequest() 6700 req.meta.CopyFrom(ListRequestMetadata()) 6701 if self.parent.page_limit > 0: 6702 req.meta.limit = self.parent.page_limit 6703 if self.parent.snapshot_datetime is not None: 6704 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6705 6706 req.filter = plumbing.quote_filter_args(filter, *args) 6707 6708 def generator(svc, req): 6709 tries = 0 6710 while True: 6711 t = None if deadline is None else deadline - time.time() 6712 try: 6713 plumbing_response = svc.stub.List( 6714 req, 6715 metadata=svc.parent.get_metadata( 6716 'RolesHistory.List', req), 6717 timeout=t) 6718 except Exception as e: 6719 if self.parent.shouldRetry(tries, e, deadline): 6720 tries += 1 6721 time.sleep( 6722 self.parent.exponentialBackoff(tries, deadline)) 6723 continue 6724 raise plumbing.convert_error_to_porcelain(e) from e 6725 tries = 0 6726 for plumbing_item in plumbing_response.history: 6727 yield plumbing.convert_role_history_to_porcelain( 6728 plumbing_item) 6729 if plumbing_response.meta.next_cursor == '': 6730 break 6731 req.meta.cursor = plumbing_response.meta.next_cursor 6732 6733 return generator(self, req) 6734 6735 6736class SecretStores: 6737 ''' 6738 SecretStores are servers where resource secrets (passwords, keys) are stored. 6739 See: 6740 `strongdm.models.ActiveDirectoryStore` 6741 `strongdm.models.AWSStore` 6742 `strongdm.models.AWSCertX509Store` 6743 `strongdm.models.AzureStore` 6744 `strongdm.models.CyberarkConjurStore` 6745 `strongdm.models.CyberarkPAMStore` 6746 `strongdm.models.CyberarkPAMExperimentalStore` 6747 `strongdm.models.DelineaStore` 6748 `strongdm.models.GCPStore` 6749 `strongdm.models.GCPCertX509Store` 6750 `strongdm.models.KeyfactorSSHStore` 6751 `strongdm.models.KeyfactorX509Store` 6752 `strongdm.models.StrongVaultStore` 6753 `strongdm.models.VaultAppRoleStore` 6754 `strongdm.models.VaultAppRoleCertSSHStore` 6755 `strongdm.models.VaultAppRoleCertX509Store` 6756 `strongdm.models.VaultAWSEC2Store` 6757 `strongdm.models.VaultAWSEC2CertSSHStore` 6758 `strongdm.models.VaultAWSEC2CertX509Store` 6759 `strongdm.models.VaultAWSIAMStore` 6760 `strongdm.models.VaultAWSIAMCertSSHStore` 6761 `strongdm.models.VaultAWSIAMCertX509Store` 6762 `strongdm.models.VaultTLSStore` 6763 `strongdm.models.VaultTLSCertSSHStore` 6764 `strongdm.models.VaultTLSCertX509Store` 6765 `strongdm.models.VaultTokenStore` 6766 `strongdm.models.VaultTokenCertSSHStore` 6767 `strongdm.models.VaultTokenCertX509Store` 6768 ''' 6769 def __init__(self, channel, client): 6770 self.parent = client 6771 self.stub = SecretStoresStub(channel) 6772 6773 def create(self, secret_store, timeout=None): 6774 deadline = None if timeout is None else time.time() + timeout 6775 req = SecretStoreCreateRequest() 6776 6777 if secret_store is not None: 6778 req.secret_store.CopyFrom( 6779 plumbing.convert_secret_store_to_plumbing(secret_store)) 6780 tries = 0 6781 plumbing_response = None 6782 while True: 6783 t = None if deadline is None else deadline - time.time() 6784 try: 6785 plumbing_response = self.stub.Create( 6786 req, 6787 metadata=self.parent.get_metadata('SecretStores.Create', 6788 req), 6789 timeout=t) 6790 except Exception as e: 6791 if self.parent.shouldRetry(tries, e, deadline): 6792 tries += 1 6793 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6794 continue 6795 raise plumbing.convert_error_to_porcelain(e) from e 6796 break 6797 6798 resp = models.SecretStoreCreateResponse() 6799 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 6800 plumbing_response.meta) 6801 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6802 plumbing_response.rate_limit) 6803 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 6804 plumbing_response.secret_store) 6805 return resp 6806 6807 def get(self, id, timeout=None): 6808 ''' 6809 Get reads one SecretStore by ID. 6810 ''' 6811 deadline = None if timeout is None else time.time() + timeout 6812 req = SecretStoreGetRequest() 6813 if self.parent.snapshot_datetime is not None: 6814 req.meta.CopyFrom(GetRequestMetadata()) 6815 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6816 6817 req.id = (id) 6818 tries = 0 6819 plumbing_response = None 6820 while True: 6821 t = None if deadline is None else deadline - time.time() 6822 try: 6823 plumbing_response = self.stub.Get( 6824 req, 6825 metadata=self.parent.get_metadata('SecretStores.Get', req), 6826 timeout=t) 6827 except Exception as e: 6828 if self.parent.shouldRetry(tries, e, deadline): 6829 tries += 1 6830 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6831 continue 6832 raise plumbing.convert_error_to_porcelain(e) from e 6833 break 6834 6835 resp = models.SecretStoreGetResponse() 6836 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 6837 plumbing_response.meta) 6838 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6839 plumbing_response.rate_limit) 6840 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 6841 plumbing_response.secret_store) 6842 return resp 6843 6844 def update(self, secret_store, timeout=None): 6845 ''' 6846 Update replaces all the fields of a SecretStore by ID. 6847 ''' 6848 deadline = None if timeout is None else time.time() + timeout 6849 req = SecretStoreUpdateRequest() 6850 6851 if secret_store is not None: 6852 req.secret_store.CopyFrom( 6853 plumbing.convert_secret_store_to_plumbing(secret_store)) 6854 tries = 0 6855 plumbing_response = None 6856 while True: 6857 t = None if deadline is None else deadline - time.time() 6858 try: 6859 plumbing_response = self.stub.Update( 6860 req, 6861 metadata=self.parent.get_metadata('SecretStores.Update', 6862 req), 6863 timeout=t) 6864 except Exception as e: 6865 if self.parent.shouldRetry(tries, e, deadline): 6866 tries += 1 6867 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6868 continue 6869 raise plumbing.convert_error_to_porcelain(e) from e 6870 break 6871 6872 resp = models.SecretStoreUpdateResponse() 6873 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 6874 plumbing_response.meta) 6875 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6876 plumbing_response.rate_limit) 6877 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 6878 plumbing_response.secret_store) 6879 return resp 6880 6881 def delete(self, id, timeout=None): 6882 ''' 6883 Delete removes a SecretStore by ID. 6884 ''' 6885 deadline = None if timeout is None else time.time() + timeout 6886 req = SecretStoreDeleteRequest() 6887 6888 req.id = (id) 6889 tries = 0 6890 plumbing_response = None 6891 while True: 6892 t = None if deadline is None else deadline - time.time() 6893 try: 6894 plumbing_response = self.stub.Delete( 6895 req, 6896 metadata=self.parent.get_metadata('SecretStores.Delete', 6897 req), 6898 timeout=t) 6899 except Exception as e: 6900 if self.parent.shouldRetry(tries, e, deadline): 6901 tries += 1 6902 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6903 continue 6904 raise plumbing.convert_error_to_porcelain(e) from e 6905 break 6906 6907 resp = models.SecretStoreDeleteResponse() 6908 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 6909 plumbing_response.meta) 6910 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6911 plumbing_response.rate_limit) 6912 return resp 6913 6914 def list(self, filter, *args, timeout=None): 6915 ''' 6916 List gets a list of SecretStores matching a given set of criteria. 6917 ''' 6918 deadline = None if timeout is None else time.time() + timeout 6919 req = SecretStoreListRequest() 6920 req.meta.CopyFrom(ListRequestMetadata()) 6921 if self.parent.page_limit > 0: 6922 req.meta.limit = self.parent.page_limit 6923 if self.parent.snapshot_datetime is not None: 6924 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6925 6926 req.filter = plumbing.quote_filter_args(filter, *args) 6927 6928 def generator(svc, req): 6929 tries = 0 6930 while True: 6931 t = None if deadline is None else deadline - time.time() 6932 try: 6933 plumbing_response = svc.stub.List( 6934 req, 6935 metadata=svc.parent.get_metadata( 6936 'SecretStores.List', req), 6937 timeout=t) 6938 except Exception as e: 6939 if self.parent.shouldRetry(tries, e, deadline): 6940 tries += 1 6941 time.sleep( 6942 self.parent.exponentialBackoff(tries, deadline)) 6943 continue 6944 raise plumbing.convert_error_to_porcelain(e) from e 6945 tries = 0 6946 for plumbing_item in plumbing_response.secret_stores: 6947 yield plumbing.convert_secret_store_to_porcelain( 6948 plumbing_item) 6949 if plumbing_response.meta.next_cursor == '': 6950 break 6951 req.meta.cursor = plumbing_response.meta.next_cursor 6952 6953 return generator(self, req) 6954 6955 6956class SnapshotSecretStores: 6957 ''' 6958 SnapshotSecretStores exposes the read only methods of the SecretStores 6959 service for historical queries. 6960 ''' 6961 def __init__(self, secret_stores): 6962 self.secret_stores = secret_stores 6963 6964 def get(self, id, timeout=None): 6965 ''' 6966 Get reads one SecretStore by ID. 6967 ''' 6968 return self.secret_stores.get(id, timeout=timeout) 6969 6970 def list(self, filter, *args, timeout=None): 6971 ''' 6972 List gets a list of SecretStores matching a given set of criteria. 6973 ''' 6974 return self.secret_stores.list(filter, *args, timeout=timeout) 6975 6976 6977class SecretEngines: 6978 ''' 6979 6980 See: 6981 `strongdm.models.ActiveDirectoryEngine` 6982 `strongdm.models.KeyValueEngine` 6983 `strongdm.models.MysqlEngine` 6984 `strongdm.models.PostgresEngine` 6985 `strongdm.models.SqlserverEngine` 6986 ''' 6987 def __init__(self, channel, client): 6988 self.parent = client 6989 self.stub = SecretEnginesStub(channel) 6990 6991 def list(self, filter, *args, timeout=None): 6992 ''' 6993 List returns a list of Secret Engines 6994 ''' 6995 deadline = None if timeout is None else time.time() + timeout 6996 req = SecretEngineListRequest() 6997 req.meta.CopyFrom(ListRequestMetadata()) 6998 if self.parent.page_limit > 0: 6999 req.meta.limit = self.parent.page_limit 7000 if self.parent.snapshot_datetime is not None: 7001 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7002 7003 req.filter = plumbing.quote_filter_args(filter, *args) 7004 7005 def generator(svc, req): 7006 tries = 0 7007 while True: 7008 t = None if deadline is None else deadline - time.time() 7009 try: 7010 plumbing_response = svc.stub.List( 7011 req, 7012 metadata=svc.parent.get_metadata( 7013 'SecretEngines.List', req), 7014 timeout=t) 7015 except Exception as e: 7016 if self.parent.shouldRetry(tries, e, deadline): 7017 tries += 1 7018 time.sleep( 7019 self.parent.exponentialBackoff(tries, deadline)) 7020 continue 7021 raise plumbing.convert_error_to_porcelain(e) from e 7022 tries = 0 7023 for plumbing_item in plumbing_response.secret_engines: 7024 yield plumbing.convert_secret_engine_to_porcelain( 7025 plumbing_item) 7026 if plumbing_response.meta.next_cursor == '': 7027 break 7028 req.meta.cursor = plumbing_response.meta.next_cursor 7029 7030 return generator(self, req) 7031 7032 def get(self, id, timeout=None): 7033 ''' 7034 Get returns a secret engine details 7035 ''' 7036 deadline = None if timeout is None else time.time() + timeout 7037 req = SecretEngineGetRequest() 7038 if self.parent.snapshot_datetime is not None: 7039 req.meta.CopyFrom(GetRequestMetadata()) 7040 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7041 7042 req.id = (id) 7043 tries = 0 7044 plumbing_response = None 7045 while True: 7046 t = None if deadline is None else deadline - time.time() 7047 try: 7048 plumbing_response = self.stub.Get( 7049 req, 7050 metadata=self.parent.get_metadata('SecretEngines.Get', 7051 req), 7052 timeout=t) 7053 except Exception as e: 7054 if self.parent.shouldRetry(tries, e, deadline): 7055 tries += 1 7056 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7057 continue 7058 raise plumbing.convert_error_to_porcelain(e) from e 7059 break 7060 7061 resp = models.SecretEngineGetResponse() 7062 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 7063 plumbing_response.meta) 7064 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7065 plumbing_response.rate_limit) 7066 resp.secret_engine = plumbing.convert_secret_engine_to_porcelain( 7067 plumbing_response.secret_engine) 7068 return resp 7069 7070 def create(self, secret_engine, timeout=None): 7071 ''' 7072 Create creates a secret engine 7073 ''' 7074 deadline = None if timeout is None else time.time() + timeout 7075 req = SecretEngineCreateRequest() 7076 7077 if secret_engine is not None: 7078 req.secret_engine.CopyFrom( 7079 plumbing.convert_secret_engine_to_plumbing(secret_engine)) 7080 tries = 0 7081 plumbing_response = None 7082 while True: 7083 t = None if deadline is None else deadline - time.time() 7084 try: 7085 plumbing_response = self.stub.Create( 7086 req, 7087 metadata=self.parent.get_metadata('SecretEngines.Create', 7088 req), 7089 timeout=t) 7090 except Exception as e: 7091 if self.parent.shouldRetry(tries, e, deadline): 7092 tries += 1 7093 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7094 continue 7095 raise plumbing.convert_error_to_porcelain(e) from e 7096 break 7097 7098 resp = models.SecretEngineCreateResponse() 7099 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 7100 plumbing_response.meta) 7101 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7102 plumbing_response.rate_limit) 7103 resp.secret_engine = plumbing.convert_secret_engine_to_porcelain( 7104 plumbing_response.secret_engine) 7105 return resp 7106 7107 def update(self, secret_engine, timeout=None): 7108 ''' 7109 Update updates a secret engine 7110 ''' 7111 deadline = None if timeout is None else time.time() + timeout 7112 req = SecretEngineUpdateRequest() 7113 7114 if secret_engine is not None: 7115 req.secret_engine.CopyFrom( 7116 plumbing.convert_secret_engine_to_plumbing(secret_engine)) 7117 tries = 0 7118 plumbing_response = None 7119 while True: 7120 t = None if deadline is None else deadline - time.time() 7121 try: 7122 plumbing_response = self.stub.Update( 7123 req, 7124 metadata=self.parent.get_metadata('SecretEngines.Update', 7125 req), 7126 timeout=t) 7127 except Exception as e: 7128 if self.parent.shouldRetry(tries, e, deadline): 7129 tries += 1 7130 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7131 continue 7132 raise plumbing.convert_error_to_porcelain(e) from e 7133 break 7134 7135 resp = models.SecretEngineUpdateResponse() 7136 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 7137 plumbing_response.meta) 7138 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7139 plumbing_response.rate_limit) 7140 resp.secret_engine = plumbing.convert_secret_engine_to_porcelain( 7141 plumbing_response.secret_engine) 7142 return resp 7143 7144 def delete(self, id, timeout=None): 7145 ''' 7146 Delete deletes a secret engine 7147 ''' 7148 deadline = None if timeout is None else time.time() + timeout 7149 req = SecretEngineDeleteRequest() 7150 7151 req.id = (id) 7152 tries = 0 7153 plumbing_response = None 7154 while True: 7155 t = None if deadline is None else deadline - time.time() 7156 try: 7157 plumbing_response = self.stub.Delete( 7158 req, 7159 metadata=self.parent.get_metadata('SecretEngines.Delete', 7160 req), 7161 timeout=t) 7162 except Exception as e: 7163 if self.parent.shouldRetry(tries, e, deadline): 7164 tries += 1 7165 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7166 continue 7167 raise plumbing.convert_error_to_porcelain(e) from e 7168 break 7169 7170 resp = models.SecretEngineDeleteResponse() 7171 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7172 plumbing_response.rate_limit) 7173 return resp 7174 7175 def list_secret_stores(self, filter, *args, timeout=None): 7176 ''' 7177 ListSecretStores returns a list of Secret Stores that can be used as a backing store 7178 for Secret Engine 7179 ''' 7180 deadline = None if timeout is None else time.time() + timeout 7181 req = SecretStoreListRequest() 7182 req.meta.CopyFrom(ListRequestMetadata()) 7183 if self.parent.page_limit > 0: 7184 req.meta.limit = self.parent.page_limit 7185 if self.parent.snapshot_datetime is not None: 7186 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7187 7188 req.filter = plumbing.quote_filter_args(filter, *args) 7189 7190 def generator(svc, req): 7191 tries = 0 7192 while True: 7193 t = None if deadline is None else deadline - time.time() 7194 try: 7195 plumbing_response = svc.stub.ListSecretStores( 7196 req, 7197 metadata=svc.parent.get_metadata( 7198 'SecretEngines.ListSecretStores', req), 7199 timeout=t) 7200 except Exception as e: 7201 if self.parent.shouldRetry(tries, e, deadline): 7202 tries += 1 7203 time.sleep( 7204 self.parent.exponentialBackoff(tries, deadline)) 7205 continue 7206 raise plumbing.convert_error_to_porcelain(e) from e 7207 tries = 0 7208 for plumbing_item in plumbing_response.secret_stores: 7209 yield plumbing.convert_secret_store_to_porcelain( 7210 plumbing_item) 7211 if plumbing_response.meta.next_cursor == '': 7212 break 7213 req.meta.cursor = plumbing_response.meta.next_cursor 7214 7215 return generator(self, req) 7216 7217 def generate_keys(self, secret_engine_id, timeout=None): 7218 ''' 7219 GenerateKeys generates a private key, stores it in a secret store and stores a public key in a secret engine 7220 ''' 7221 deadline = None if timeout is None else time.time() + timeout 7222 req = GenerateKeysRequest() 7223 7224 req.secret_engine_id = (secret_engine_id) 7225 tries = 0 7226 plumbing_response = None 7227 while True: 7228 t = None if deadline is None else deadline - time.time() 7229 try: 7230 plumbing_response = self.stub.GenerateKeys( 7231 req, 7232 metadata=self.parent.get_metadata( 7233 'SecretEngines.GenerateKeys', req), 7234 timeout=t) 7235 except Exception as e: 7236 if self.parent.shouldRetry(tries, e, deadline): 7237 tries += 1 7238 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7239 continue 7240 raise plumbing.convert_error_to_porcelain(e) from e 7241 break 7242 7243 resp = models.GenerateKeysResponse() 7244 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7245 plumbing_response.rate_limit) 7246 return resp 7247 7248 def healthcheck(self, secret_engine_id, timeout=None): 7249 ''' 7250 Healthcheck triggers a healthcheck for all nodes serving a secret engine 7251 ''' 7252 deadline = None if timeout is None else time.time() + timeout 7253 req = HealthcheckRequest() 7254 7255 req.secret_engine_id = (secret_engine_id) 7256 tries = 0 7257 plumbing_response = None 7258 while True: 7259 t = None if deadline is None else deadline - time.time() 7260 try: 7261 plumbing_response = self.stub.Healthcheck( 7262 req, 7263 metadata=self.parent.get_metadata( 7264 'SecretEngines.Healthcheck', req), 7265 timeout=t) 7266 except Exception as e: 7267 if self.parent.shouldRetry(tries, e, deadline): 7268 tries += 1 7269 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7270 continue 7271 raise plumbing.convert_error_to_porcelain(e) from e 7272 break 7273 7274 resp = models.HealthcheckResponse() 7275 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7276 plumbing_response.rate_limit) 7277 resp.status = plumbing.convert_repeated_healthcheck_status_to_porcelain( 7278 plumbing_response.status) 7279 return resp 7280 7281 def rotate(self, id, password_policy, timeout=None): 7282 ''' 7283 Rotate rotates secret engine's credentials 7284 ''' 7285 deadline = None if timeout is None else time.time() + timeout 7286 req = SecretEngineRotateRequest() 7287 7288 req.id = (id) 7289 if password_policy is not None: 7290 req.password_policy.CopyFrom( 7291 plumbing.convert_secret_engine_password_policy_to_plumbing( 7292 password_policy)) 7293 tries = 0 7294 plumbing_response = None 7295 while True: 7296 t = None if deadline is None else deadline - time.time() 7297 try: 7298 plumbing_response = self.stub.Rotate( 7299 req, 7300 metadata=self.parent.get_metadata('SecretEngines.Rotate', 7301 req), 7302 timeout=t) 7303 except Exception as e: 7304 if self.parent.shouldRetry(tries, e, deadline): 7305 tries += 1 7306 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7307 continue 7308 raise plumbing.convert_error_to_porcelain(e) from e 7309 break 7310 7311 resp = models.SecretEngineRotateResponse() 7312 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7313 plumbing_response.rate_limit) 7314 return resp 7315 7316 7317class SecretStoreHealths: 7318 ''' 7319 SecretStoreHealths exposes health states for secret stores. 7320 See `strongdm.models.SecretStoreHealth`. 7321 ''' 7322 def __init__(self, channel, client): 7323 self.parent = client 7324 self.stub = SecretStoreHealthsStub(channel) 7325 7326 def list(self, filter, *args, timeout=None): 7327 ''' 7328 List reports the health status of node to secret store pairs. 7329 ''' 7330 deadline = None if timeout is None else time.time() + timeout 7331 req = SecretStoreHealthListRequest() 7332 req.meta.CopyFrom(ListRequestMetadata()) 7333 if self.parent.page_limit > 0: 7334 req.meta.limit = self.parent.page_limit 7335 if self.parent.snapshot_datetime is not None: 7336 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7337 7338 req.filter = plumbing.quote_filter_args(filter, *args) 7339 7340 def generator(svc, req): 7341 tries = 0 7342 while True: 7343 t = None if deadline is None else deadline - time.time() 7344 try: 7345 plumbing_response = svc.stub.List( 7346 req, 7347 metadata=svc.parent.get_metadata( 7348 'SecretStoreHealths.List', req), 7349 timeout=t) 7350 except Exception as e: 7351 if self.parent.shouldRetry(tries, e, deadline): 7352 tries += 1 7353 time.sleep( 7354 self.parent.exponentialBackoff(tries, deadline)) 7355 continue 7356 raise plumbing.convert_error_to_porcelain(e) from e 7357 tries = 0 7358 for plumbing_item in plumbing_response.secret_store_healths: 7359 yield plumbing.convert_secret_store_health_to_porcelain( 7360 plumbing_item) 7361 if plumbing_response.meta.next_cursor == '': 7362 break 7363 req.meta.cursor = plumbing_response.meta.next_cursor 7364 7365 return generator(self, req) 7366 7367 def healthcheck(self, secret_store_id, timeout=None): 7368 ''' 7369 Healthcheck triggers a remote healthcheck request for a secret store. It may take minutes 7370 to propagate across a large network of Nodes. The call will return immediately, and the 7371 updated health of the Secret Store can be retrieved via List. 7372 ''' 7373 deadline = None if timeout is None else time.time() + timeout 7374 req = SecretStoreHealthcheckRequest() 7375 7376 req.secret_store_id = (secret_store_id) 7377 tries = 0 7378 plumbing_response = None 7379 while True: 7380 t = None if deadline is None else deadline - time.time() 7381 try: 7382 plumbing_response = self.stub.Healthcheck( 7383 req, 7384 metadata=self.parent.get_metadata( 7385 'SecretStoreHealths.Healthcheck', req), 7386 timeout=t) 7387 except Exception as e: 7388 if self.parent.shouldRetry(tries, e, deadline): 7389 tries += 1 7390 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7391 continue 7392 raise plumbing.convert_error_to_porcelain(e) from e 7393 break 7394 7395 resp = models.SecretStoreHealthcheckResponse() 7396 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7397 plumbing_response.rate_limit) 7398 return resp 7399 7400 7401class SecretStoresHistory: 7402 ''' 7403 SecretStoresHistory records all changes to the state of a SecretStore. 7404 See `strongdm.models.SecretStoreHistory`. 7405 ''' 7406 def __init__(self, channel, client): 7407 self.parent = client 7408 self.stub = SecretStoresHistoryStub(channel) 7409 7410 def list(self, filter, *args, timeout=None): 7411 ''' 7412 List gets a list of SecretStoreHistory records matching a given set of criteria. 7413 ''' 7414 deadline = None if timeout is None else time.time() + timeout 7415 req = SecretStoreHistoryListRequest() 7416 req.meta.CopyFrom(ListRequestMetadata()) 7417 if self.parent.page_limit > 0: 7418 req.meta.limit = self.parent.page_limit 7419 if self.parent.snapshot_datetime is not None: 7420 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7421 7422 req.filter = plumbing.quote_filter_args(filter, *args) 7423 7424 def generator(svc, req): 7425 tries = 0 7426 while True: 7427 t = None if deadline is None else deadline - time.time() 7428 try: 7429 plumbing_response = svc.stub.List( 7430 req, 7431 metadata=svc.parent.get_metadata( 7432 'SecretStoresHistory.List', req), 7433 timeout=t) 7434 except Exception as e: 7435 if self.parent.shouldRetry(tries, e, deadline): 7436 tries += 1 7437 time.sleep( 7438 self.parent.exponentialBackoff(tries, deadline)) 7439 continue 7440 raise plumbing.convert_error_to_porcelain(e) from e 7441 tries = 0 7442 for plumbing_item in plumbing_response.history: 7443 yield plumbing.convert_secret_store_history_to_porcelain( 7444 plumbing_item) 7445 if plumbing_response.meta.next_cursor == '': 7446 break 7447 req.meta.cursor = plumbing_response.meta.next_cursor 7448 7449 return generator(self, req) 7450 7451 7452class WorkflowApprovers: 7453 ''' 7454 WorkflowApprovers is an account or a role with the ability to approve requests bound to a workflow. 7455 See `strongdm.models.WorkflowApprover`. 7456 ''' 7457 def __init__(self, channel, client): 7458 self.parent = client 7459 self.stub = WorkflowApproversStub(channel) 7460 7461 def create(self, workflow_approver, timeout=None): 7462 ''' 7463 Create creates a new workflow approver 7464 ''' 7465 deadline = None if timeout is None else time.time() + timeout 7466 req = WorkflowApproversCreateRequest() 7467 7468 if workflow_approver is not None: 7469 req.workflow_approver.CopyFrom( 7470 plumbing.convert_workflow_approver_to_plumbing( 7471 workflow_approver)) 7472 tries = 0 7473 plumbing_response = None 7474 while True: 7475 t = None if deadline is None else deadline - time.time() 7476 try: 7477 plumbing_response = self.stub.Create( 7478 req, 7479 metadata=self.parent.get_metadata( 7480 'WorkflowApprovers.Create', req), 7481 timeout=t) 7482 except Exception as e: 7483 if self.parent.shouldRetry(tries, e, deadline): 7484 tries += 1 7485 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7486 continue 7487 raise plumbing.convert_error_to_porcelain(e) from e 7488 break 7489 7490 resp = models.WorkflowApproversCreateResponse() 7491 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7492 plumbing_response.rate_limit) 7493 resp.workflow_approver = plumbing.convert_workflow_approver_to_porcelain( 7494 plumbing_response.workflow_approver) 7495 return resp 7496 7497 def get(self, id, timeout=None): 7498 ''' 7499 Get reads one workflow approver by ID. 7500 ''' 7501 deadline = None if timeout is None else time.time() + timeout 7502 req = WorkflowApproverGetRequest() 7503 if self.parent.snapshot_datetime is not None: 7504 req.meta.CopyFrom(GetRequestMetadata()) 7505 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7506 7507 req.id = (id) 7508 tries = 0 7509 plumbing_response = None 7510 while True: 7511 t = None if deadline is None else deadline - time.time() 7512 try: 7513 plumbing_response = self.stub.Get( 7514 req, 7515 metadata=self.parent.get_metadata('WorkflowApprovers.Get', 7516 req), 7517 timeout=t) 7518 except Exception as e: 7519 if self.parent.shouldRetry(tries, e, deadline): 7520 tries += 1 7521 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7522 continue 7523 raise plumbing.convert_error_to_porcelain(e) from e 7524 break 7525 7526 resp = models.WorkflowApproverGetResponse() 7527 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 7528 plumbing_response.meta) 7529 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7530 plumbing_response.rate_limit) 7531 resp.workflow_approver = plumbing.convert_workflow_approver_to_porcelain( 7532 plumbing_response.workflow_approver) 7533 return resp 7534 7535 def delete(self, id, timeout=None): 7536 ''' 7537 Delete deletes a workflow approver 7538 ''' 7539 deadline = None if timeout is None else time.time() + timeout 7540 req = WorkflowApproversDeleteRequest() 7541 7542 req.id = (id) 7543 tries = 0 7544 plumbing_response = None 7545 while True: 7546 t = None if deadline is None else deadline - time.time() 7547 try: 7548 plumbing_response = self.stub.Delete( 7549 req, 7550 metadata=self.parent.get_metadata( 7551 'WorkflowApprovers.Delete', req), 7552 timeout=t) 7553 except Exception as e: 7554 if self.parent.shouldRetry(tries, e, deadline): 7555 tries += 1 7556 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7557 continue 7558 raise plumbing.convert_error_to_porcelain(e) from e 7559 break 7560 7561 resp = models.WorkflowApproversDeleteResponse() 7562 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7563 plumbing_response.rate_limit) 7564 return resp 7565 7566 def list(self, filter, *args, timeout=None): 7567 ''' 7568 Lists existing workflow approvers. 7569 ''' 7570 deadline = None if timeout is None else time.time() + timeout 7571 req = WorkflowApproversListRequest() 7572 req.meta.CopyFrom(ListRequestMetadata()) 7573 if self.parent.page_limit > 0: 7574 req.meta.limit = self.parent.page_limit 7575 if self.parent.snapshot_datetime is not None: 7576 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7577 7578 req.filter = plumbing.quote_filter_args(filter, *args) 7579 7580 def generator(svc, req): 7581 tries = 0 7582 while True: 7583 t = None if deadline is None else deadline - time.time() 7584 try: 7585 plumbing_response = svc.stub.List( 7586 req, 7587 metadata=svc.parent.get_metadata( 7588 'WorkflowApprovers.List', req), 7589 timeout=t) 7590 except Exception as e: 7591 if self.parent.shouldRetry(tries, e, deadline): 7592 tries += 1 7593 time.sleep( 7594 self.parent.exponentialBackoff(tries, deadline)) 7595 continue 7596 raise plumbing.convert_error_to_porcelain(e) from e 7597 tries = 0 7598 for plumbing_item in plumbing_response.workflow_approvers: 7599 yield plumbing.convert_workflow_approver_to_porcelain( 7600 plumbing_item) 7601 if plumbing_response.meta.next_cursor == '': 7602 break 7603 req.meta.cursor = plumbing_response.meta.next_cursor 7604 7605 return generator(self, req) 7606 7607 7608class SnapshotWorkflowApprovers: 7609 ''' 7610 SnapshotWorkflowApprovers exposes the read only methods of the WorkflowApprovers 7611 service for historical queries. 7612 ''' 7613 def __init__(self, workflow_approvers): 7614 self.workflow_approvers = workflow_approvers 7615 7616 def get(self, id, timeout=None): 7617 ''' 7618 Get reads one workflow approver by ID. 7619 ''' 7620 return self.workflow_approvers.get(id, timeout=timeout) 7621 7622 def list(self, filter, *args, timeout=None): 7623 ''' 7624 Lists existing workflow approvers. 7625 ''' 7626 return self.workflow_approvers.list(filter, *args, timeout=timeout) 7627 7628 7629class WorkflowApproversHistory: 7630 ''' 7631 WorkflowApproversHistory provides records of all changes to the state of a WorkflowApprover. 7632 See `strongdm.models.WorkflowApproverHistory`. 7633 ''' 7634 def __init__(self, channel, client): 7635 self.parent = client 7636 self.stub = WorkflowApproversHistoryStub(channel) 7637 7638 def list(self, filter, *args, timeout=None): 7639 ''' 7640 List gets a list of WorkflowApproversHistory records matching a given set of criteria. 7641 ''' 7642 deadline = None if timeout is None else time.time() + timeout 7643 req = WorkflowApproversHistoryListRequest() 7644 req.meta.CopyFrom(ListRequestMetadata()) 7645 if self.parent.page_limit > 0: 7646 req.meta.limit = self.parent.page_limit 7647 if self.parent.snapshot_datetime is not None: 7648 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7649 7650 req.filter = plumbing.quote_filter_args(filter, *args) 7651 7652 def generator(svc, req): 7653 tries = 0 7654 while True: 7655 t = None if deadline is None else deadline - time.time() 7656 try: 7657 plumbing_response = svc.stub.List( 7658 req, 7659 metadata=svc.parent.get_metadata( 7660 'WorkflowApproversHistory.List', req), 7661 timeout=t) 7662 except Exception as e: 7663 if self.parent.shouldRetry(tries, e, deadline): 7664 tries += 1 7665 time.sleep( 7666 self.parent.exponentialBackoff(tries, deadline)) 7667 continue 7668 raise plumbing.convert_error_to_porcelain(e) from e 7669 tries = 0 7670 for plumbing_item in plumbing_response.history: 7671 yield plumbing.convert_workflow_approver_history_to_porcelain( 7672 plumbing_item) 7673 if plumbing_response.meta.next_cursor == '': 7674 break 7675 req.meta.cursor = plumbing_response.meta.next_cursor 7676 7677 return generator(self, req) 7678 7679 7680class WorkflowRoles: 7681 ''' 7682 WorkflowRole links a role to a workflow. The linked roles indicate which roles a user must be a part of 7683 to request access to a resource via the workflow. 7684 See `strongdm.models.WorkflowRole`. 7685 ''' 7686 def __init__(self, channel, client): 7687 self.parent = client 7688 self.stub = WorkflowRolesStub(channel) 7689 7690 def create(self, workflow_role, timeout=None): 7691 ''' 7692 Create creates a new workflow role 7693 ''' 7694 deadline = None if timeout is None else time.time() + timeout 7695 req = WorkflowRolesCreateRequest() 7696 7697 if workflow_role is not None: 7698 req.workflow_role.CopyFrom( 7699 plumbing.convert_workflow_role_to_plumbing(workflow_role)) 7700 tries = 0 7701 plumbing_response = None 7702 while True: 7703 t = None if deadline is None else deadline - time.time() 7704 try: 7705 plumbing_response = self.stub.Create( 7706 req, 7707 metadata=self.parent.get_metadata('WorkflowRoles.Create', 7708 req), 7709 timeout=t) 7710 except Exception as e: 7711 if self.parent.shouldRetry(tries, e, deadline): 7712 tries += 1 7713 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7714 continue 7715 raise plumbing.convert_error_to_porcelain(e) from e 7716 break 7717 7718 resp = models.WorkflowRolesCreateResponse() 7719 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7720 plumbing_response.rate_limit) 7721 resp.workflow_role = plumbing.convert_workflow_role_to_porcelain( 7722 plumbing_response.workflow_role) 7723 return resp 7724 7725 def get(self, id, timeout=None): 7726 ''' 7727 Get reads one workflow role by ID. 7728 ''' 7729 deadline = None if timeout is None else time.time() + timeout 7730 req = WorkflowRoleGetRequest() 7731 if self.parent.snapshot_datetime is not None: 7732 req.meta.CopyFrom(GetRequestMetadata()) 7733 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7734 7735 req.id = (id) 7736 tries = 0 7737 plumbing_response = None 7738 while True: 7739 t = None if deadline is None else deadline - time.time() 7740 try: 7741 plumbing_response = self.stub.Get( 7742 req, 7743 metadata=self.parent.get_metadata('WorkflowRoles.Get', 7744 req), 7745 timeout=t) 7746 except Exception as e: 7747 if self.parent.shouldRetry(tries, e, deadline): 7748 tries += 1 7749 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7750 continue 7751 raise plumbing.convert_error_to_porcelain(e) from e 7752 break 7753 7754 resp = models.WorkflowRoleGetResponse() 7755 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 7756 plumbing_response.meta) 7757 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7758 plumbing_response.rate_limit) 7759 resp.workflow_role = plumbing.convert_workflow_role_to_porcelain( 7760 plumbing_response.workflow_role) 7761 return resp 7762 7763 def delete(self, id, timeout=None): 7764 ''' 7765 Delete deletes a workflow role 7766 ''' 7767 deadline = None if timeout is None else time.time() + timeout 7768 req = WorkflowRolesDeleteRequest() 7769 7770 req.id = (id) 7771 tries = 0 7772 plumbing_response = None 7773 while True: 7774 t = None if deadline is None else deadline - time.time() 7775 try: 7776 plumbing_response = self.stub.Delete( 7777 req, 7778 metadata=self.parent.get_metadata('WorkflowRoles.Delete', 7779 req), 7780 timeout=t) 7781 except Exception as e: 7782 if self.parent.shouldRetry(tries, e, deadline): 7783 tries += 1 7784 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7785 continue 7786 raise plumbing.convert_error_to_porcelain(e) from e 7787 break 7788 7789 resp = models.WorkflowRolesDeleteResponse() 7790 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7791 plumbing_response.rate_limit) 7792 return resp 7793 7794 def list(self, filter, *args, timeout=None): 7795 ''' 7796 Lists existing workflow roles. 7797 ''' 7798 deadline = None if timeout is None else time.time() + timeout 7799 req = WorkflowRolesListRequest() 7800 req.meta.CopyFrom(ListRequestMetadata()) 7801 if self.parent.page_limit > 0: 7802 req.meta.limit = self.parent.page_limit 7803 if self.parent.snapshot_datetime is not None: 7804 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7805 7806 req.filter = plumbing.quote_filter_args(filter, *args) 7807 7808 def generator(svc, req): 7809 tries = 0 7810 while True: 7811 t = None if deadline is None else deadline - time.time() 7812 try: 7813 plumbing_response = svc.stub.List( 7814 req, 7815 metadata=svc.parent.get_metadata( 7816 'WorkflowRoles.List', req), 7817 timeout=t) 7818 except Exception as e: 7819 if self.parent.shouldRetry(tries, e, deadline): 7820 tries += 1 7821 time.sleep( 7822 self.parent.exponentialBackoff(tries, deadline)) 7823 continue 7824 raise plumbing.convert_error_to_porcelain(e) from e 7825 tries = 0 7826 for plumbing_item in plumbing_response.workflow_role: 7827 yield plumbing.convert_workflow_role_to_porcelain( 7828 plumbing_item) 7829 if plumbing_response.meta.next_cursor == '': 7830 break 7831 req.meta.cursor = plumbing_response.meta.next_cursor 7832 7833 return generator(self, req) 7834 7835 7836class SnapshotWorkflowRoles: 7837 ''' 7838 SnapshotWorkflowRoles exposes the read only methods of the WorkflowRoles 7839 service for historical queries. 7840 ''' 7841 def __init__(self, workflow_roles): 7842 self.workflow_roles = workflow_roles 7843 7844 def get(self, id, timeout=None): 7845 ''' 7846 Get reads one workflow role by ID. 7847 ''' 7848 return self.workflow_roles.get(id, timeout=timeout) 7849 7850 def list(self, filter, *args, timeout=None): 7851 ''' 7852 Lists existing workflow roles. 7853 ''' 7854 return self.workflow_roles.list(filter, *args, timeout=timeout) 7855 7856 7857class WorkflowRolesHistory: 7858 ''' 7859 WorkflowRolesHistory provides records of all changes to the state of a WorkflowRole 7860 See `strongdm.models.WorkflowRoleHistory`. 7861 ''' 7862 def __init__(self, channel, client): 7863 self.parent = client 7864 self.stub = WorkflowRolesHistoryStub(channel) 7865 7866 def list(self, filter, *args, timeout=None): 7867 ''' 7868 List gets a list of WorkflowRolesHistory records matching a given set of criteria. 7869 ''' 7870 deadline = None if timeout is None else time.time() + timeout 7871 req = WorkflowRolesHistoryListRequest() 7872 req.meta.CopyFrom(ListRequestMetadata()) 7873 if self.parent.page_limit > 0: 7874 req.meta.limit = self.parent.page_limit 7875 if self.parent.snapshot_datetime is not None: 7876 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7877 7878 req.filter = plumbing.quote_filter_args(filter, *args) 7879 7880 def generator(svc, req): 7881 tries = 0 7882 while True: 7883 t = None if deadline is None else deadline - time.time() 7884 try: 7885 plumbing_response = svc.stub.List( 7886 req, 7887 metadata=svc.parent.get_metadata( 7888 'WorkflowRolesHistory.List', req), 7889 timeout=t) 7890 except Exception as e: 7891 if self.parent.shouldRetry(tries, e, deadline): 7892 tries += 1 7893 time.sleep( 7894 self.parent.exponentialBackoff(tries, deadline)) 7895 continue 7896 raise plumbing.convert_error_to_porcelain(e) from e 7897 tries = 0 7898 for plumbing_item in plumbing_response.history: 7899 yield plumbing.convert_workflow_role_history_to_porcelain( 7900 plumbing_item) 7901 if plumbing_response.meta.next_cursor == '': 7902 break 7903 req.meta.cursor = plumbing_response.meta.next_cursor 7904 7905 return generator(self, req) 7906 7907 7908class Workflows: 7909 ''' 7910 Workflows are the collection of rules that define the resources to which access can be requested, 7911 the users that can request that access, and the mechanism for approving those requests which can either 7912 be automatic approval or a set of users authorized to approve the requests. 7913 See `strongdm.models.Workflow`. 7914 ''' 7915 def __init__(self, channel, client): 7916 self.parent = client 7917 self.stub = WorkflowsStub(channel) 7918 7919 def create(self, workflow, timeout=None): 7920 ''' 7921 Create creates a new workflow and requires a name for the workflow. 7922 ''' 7923 deadline = None if timeout is None else time.time() + timeout 7924 req = WorkflowCreateRequest() 7925 7926 if workflow is not None: 7927 req.workflow.CopyFrom( 7928 plumbing.convert_workflow_to_plumbing(workflow)) 7929 tries = 0 7930 plumbing_response = None 7931 while True: 7932 t = None if deadline is None else deadline - time.time() 7933 try: 7934 plumbing_response = self.stub.Create( 7935 req, 7936 metadata=self.parent.get_metadata('Workflows.Create', req), 7937 timeout=t) 7938 except Exception as e: 7939 if self.parent.shouldRetry(tries, e, deadline): 7940 tries += 1 7941 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7942 continue 7943 raise plumbing.convert_error_to_porcelain(e) from e 7944 break 7945 7946 resp = models.WorkflowCreateResponse() 7947 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7948 plumbing_response.rate_limit) 7949 resp.workflow = plumbing.convert_workflow_to_porcelain( 7950 plumbing_response.workflow) 7951 return resp 7952 7953 def get(self, id, timeout=None): 7954 ''' 7955 Get reads one workflow by ID. 7956 ''' 7957 deadline = None if timeout is None else time.time() + timeout 7958 req = WorkflowGetRequest() 7959 if self.parent.snapshot_datetime is not None: 7960 req.meta.CopyFrom(GetRequestMetadata()) 7961 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7962 7963 req.id = (id) 7964 tries = 0 7965 plumbing_response = None 7966 while True: 7967 t = None if deadline is None else deadline - time.time() 7968 try: 7969 plumbing_response = self.stub.Get( 7970 req, 7971 metadata=self.parent.get_metadata('Workflows.Get', req), 7972 timeout=t) 7973 except Exception as e: 7974 if self.parent.shouldRetry(tries, e, deadline): 7975 tries += 1 7976 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7977 continue 7978 raise plumbing.convert_error_to_porcelain(e) from e 7979 break 7980 7981 resp = models.WorkflowGetResponse() 7982 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 7983 plumbing_response.meta) 7984 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7985 plumbing_response.rate_limit) 7986 resp.workflow = plumbing.convert_workflow_to_porcelain( 7987 plumbing_response.workflow) 7988 return resp 7989 7990 def delete(self, id, timeout=None): 7991 ''' 7992 Delete deletes an existing workflow. 7993 ''' 7994 deadline = None if timeout is None else time.time() + timeout 7995 req = WorkflowDeleteRequest() 7996 7997 req.id = (id) 7998 tries = 0 7999 plumbing_response = None 8000 while True: 8001 t = None if deadline is None else deadline - time.time() 8002 try: 8003 plumbing_response = self.stub.Delete( 8004 req, 8005 metadata=self.parent.get_metadata('Workflows.Delete', req), 8006 timeout=t) 8007 except Exception as e: 8008 if self.parent.shouldRetry(tries, e, deadline): 8009 tries += 1 8010 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8011 continue 8012 raise plumbing.convert_error_to_porcelain(e) from e 8013 break 8014 8015 resp = models.WorkflowDeleteResponse() 8016 resp.id = (plumbing_response.id) 8017 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8018 plumbing_response.rate_limit) 8019 return resp 8020 8021 def update(self, workflow, timeout=None): 8022 ''' 8023 Update updates an existing workflow. 8024 ''' 8025 deadline = None if timeout is None else time.time() + timeout 8026 req = WorkflowUpdateRequest() 8027 8028 if workflow is not None: 8029 req.workflow.CopyFrom( 8030 plumbing.convert_workflow_to_plumbing(workflow)) 8031 tries = 0 8032 plumbing_response = None 8033 while True: 8034 t = None if deadline is None else deadline - time.time() 8035 try: 8036 plumbing_response = self.stub.Update( 8037 req, 8038 metadata=self.parent.get_metadata('Workflows.Update', req), 8039 timeout=t) 8040 except Exception as e: 8041 if self.parent.shouldRetry(tries, e, deadline): 8042 tries += 1 8043 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8044 continue 8045 raise plumbing.convert_error_to_porcelain(e) from e 8046 break 8047 8048 resp = models.WorkflowUpdateResponse() 8049 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8050 plumbing_response.rate_limit) 8051 resp.workflow = plumbing.convert_workflow_to_porcelain( 8052 plumbing_response.workflow) 8053 return resp 8054 8055 def list(self, filter, *args, timeout=None): 8056 ''' 8057 Lists existing workflows. 8058 ''' 8059 deadline = None if timeout is None else time.time() + timeout 8060 req = WorkflowListRequest() 8061 req.meta.CopyFrom(ListRequestMetadata()) 8062 if self.parent.page_limit > 0: 8063 req.meta.limit = self.parent.page_limit 8064 if self.parent.snapshot_datetime is not None: 8065 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8066 8067 req.filter = plumbing.quote_filter_args(filter, *args) 8068 8069 def generator(svc, req): 8070 tries = 0 8071 while True: 8072 t = None if deadline is None else deadline - time.time() 8073 try: 8074 plumbing_response = svc.stub.List( 8075 req, 8076 metadata=svc.parent.get_metadata( 8077 'Workflows.List', req), 8078 timeout=t) 8079 except Exception as e: 8080 if self.parent.shouldRetry(tries, e, deadline): 8081 tries += 1 8082 time.sleep( 8083 self.parent.exponentialBackoff(tries, deadline)) 8084 continue 8085 raise plumbing.convert_error_to_porcelain(e) from e 8086 tries = 0 8087 for plumbing_item in plumbing_response.workflows: 8088 yield plumbing.convert_workflow_to_porcelain(plumbing_item) 8089 if plumbing_response.meta.next_cursor == '': 8090 break 8091 req.meta.cursor = plumbing_response.meta.next_cursor 8092 8093 return generator(self, req) 8094 8095 8096class SnapshotWorkflows: 8097 ''' 8098 SnapshotWorkflows exposes the read only methods of the Workflows 8099 service for historical queries. 8100 ''' 8101 def __init__(self, workflows): 8102 self.workflows = workflows 8103 8104 def get(self, id, timeout=None): 8105 ''' 8106 Get reads one workflow by ID. 8107 ''' 8108 return self.workflows.get(id, timeout=timeout) 8109 8110 def list(self, filter, *args, timeout=None): 8111 ''' 8112 Lists existing workflows. 8113 ''' 8114 return self.workflows.list(filter, *args, timeout=timeout) 8115 8116 8117class WorkflowsHistory: 8118 ''' 8119 WorkflowsHistory provides records of all changes to the state of a Workflow. 8120 See `strongdm.models.WorkflowHistory`. 8121 ''' 8122 def __init__(self, channel, client): 8123 self.parent = client 8124 self.stub = WorkflowsHistoryStub(channel) 8125 8126 def list(self, filter, *args, timeout=None): 8127 ''' 8128 List gets a list of WorkflowHistory records matching a given set of criteria. 8129 ''' 8130 deadline = None if timeout is None else time.time() + timeout 8131 req = WorkflowHistoryListRequest() 8132 req.meta.CopyFrom(ListRequestMetadata()) 8133 if self.parent.page_limit > 0: 8134 req.meta.limit = self.parent.page_limit 8135 if self.parent.snapshot_datetime is not None: 8136 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8137 8138 req.filter = plumbing.quote_filter_args(filter, *args) 8139 8140 def generator(svc, req): 8141 tries = 0 8142 while True: 8143 t = None if deadline is None else deadline - time.time() 8144 try: 8145 plumbing_response = svc.stub.List( 8146 req, 8147 metadata=svc.parent.get_metadata( 8148 'WorkflowsHistory.List', req), 8149 timeout=t) 8150 except Exception as e: 8151 if self.parent.shouldRetry(tries, e, deadline): 8152 tries += 1 8153 time.sleep( 8154 self.parent.exponentialBackoff(tries, deadline)) 8155 continue 8156 raise plumbing.convert_error_to_porcelain(e) from e 8157 tries = 0 8158 for plumbing_item in plumbing_response.history: 8159 yield plumbing.convert_workflow_history_to_porcelain( 8160 plumbing_item) 8161 if plumbing_response.meta.next_cursor == '': 8162 break 8163 req.meta.cursor = plumbing_response.meta.next_cursor 8164 8165 return generator(self, req)
def
deprecated(func)
169def deprecated(func): 170 """This is a decorator which can be used to mark functions 171 as deprecated. It will result in a warning being emitted 172 when the function is used.""" 173 @functools.wraps(func) 174 def new_func(*args, **kwargs): 175 warnings.warn("Call to deprecated function {}.".format(func.__name__), 176 category=DeprecationWarning, 177 stacklevel=2) 178 return func(*args, **kwargs) 179 180 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:
183class AccessRequests: 184 ''' 185 AccessRequests are requests for access to a resource that may match a Workflow. 186 See `strongdm.models.AccessRequest`. 187 ''' 188 def __init__(self, channel, client): 189 self.parent = client 190 self.stub = AccessRequestsStub(channel) 191 192 def list(self, filter, *args, timeout=None): 193 ''' 194 Lists existing access requests. 195 ''' 196 deadline = None if timeout is None else time.time() + timeout 197 req = AccessRequestListRequest() 198 req.meta.CopyFrom(ListRequestMetadata()) 199 if self.parent.page_limit > 0: 200 req.meta.limit = self.parent.page_limit 201 if self.parent.snapshot_datetime is not None: 202 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 203 204 req.filter = plumbing.quote_filter_args(filter, *args) 205 206 def generator(svc, req): 207 tries = 0 208 while True: 209 t = None if deadline is None else deadline - time.time() 210 try: 211 plumbing_response = svc.stub.List( 212 req, 213 metadata=svc.parent.get_metadata( 214 'AccessRequests.List', req), 215 timeout=t) 216 except Exception as e: 217 if self.parent.shouldRetry(tries, e, deadline): 218 tries += 1 219 time.sleep( 220 self.parent.exponentialBackoff(tries, deadline)) 221 continue 222 raise plumbing.convert_error_to_porcelain(e) from e 223 tries = 0 224 for plumbing_item in plumbing_response.access_requests: 225 yield plumbing.convert_access_request_to_porcelain( 226 plumbing_item) 227 if plumbing_response.meta.next_cursor == '': 228 break 229 req.meta.cursor = plumbing_response.meta.next_cursor 230 231 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)
192 def list(self, filter, *args, timeout=None): 193 ''' 194 Lists existing access requests. 195 ''' 196 deadline = None if timeout is None else time.time() + timeout 197 req = AccessRequestListRequest() 198 req.meta.CopyFrom(ListRequestMetadata()) 199 if self.parent.page_limit > 0: 200 req.meta.limit = self.parent.page_limit 201 if self.parent.snapshot_datetime is not None: 202 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 203 204 req.filter = plumbing.quote_filter_args(filter, *args) 205 206 def generator(svc, req): 207 tries = 0 208 while True: 209 t = None if deadline is None else deadline - time.time() 210 try: 211 plumbing_response = svc.stub.List( 212 req, 213 metadata=svc.parent.get_metadata( 214 'AccessRequests.List', req), 215 timeout=t) 216 except Exception as e: 217 if self.parent.shouldRetry(tries, e, deadline): 218 tries += 1 219 time.sleep( 220 self.parent.exponentialBackoff(tries, deadline)) 221 continue 222 raise plumbing.convert_error_to_porcelain(e) from e 223 tries = 0 224 for plumbing_item in plumbing_response.access_requests: 225 yield plumbing.convert_access_request_to_porcelain( 226 plumbing_item) 227 if plumbing_response.meta.next_cursor == '': 228 break 229 req.meta.cursor = plumbing_response.meta.next_cursor 230 231 return generator(self, req)
Lists existing access requests.
class
SnapshotAccessRequests:
234class SnapshotAccessRequests: 235 ''' 236 SnapshotAccessRequests exposes the read only methods of the AccessRequests 237 service for historical queries. 238 ''' 239 def __init__(self, access_requests): 240 self.access_requests = access_requests 241 242 def list(self, filter, *args, timeout=None): 243 ''' 244 Lists existing access requests. 245 ''' 246 return self.access_requests.list(filter, *args, timeout=timeout)
SnapshotAccessRequests exposes the read only methods of the AccessRequests service for historical queries.
class
AccessRequestEventsHistory:
249class AccessRequestEventsHistory: 250 ''' 251 AccessRequestEventsHistory provides records of all changes to the state of an AccessRequest. 252 See `strongdm.models.AccessRequestEventHistory`. 253 ''' 254 def __init__(self, channel, client): 255 self.parent = client 256 self.stub = AccessRequestEventsHistoryStub(channel) 257 258 def list(self, filter, *args, timeout=None): 259 ''' 260 List gets a list of AccessRequestEventHistory records matching a given set of criteria. 261 ''' 262 deadline = None if timeout is None else time.time() + timeout 263 req = AccessRequestEventHistoryListRequest() 264 req.meta.CopyFrom(ListRequestMetadata()) 265 if self.parent.page_limit > 0: 266 req.meta.limit = self.parent.page_limit 267 if self.parent.snapshot_datetime is not None: 268 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 269 270 req.filter = plumbing.quote_filter_args(filter, *args) 271 272 def generator(svc, req): 273 tries = 0 274 while True: 275 t = None if deadline is None else deadline - time.time() 276 try: 277 plumbing_response = svc.stub.List( 278 req, 279 metadata=svc.parent.get_metadata( 280 'AccessRequestEventsHistory.List', req), 281 timeout=t) 282 except Exception as e: 283 if self.parent.shouldRetry(tries, e, deadline): 284 tries += 1 285 time.sleep( 286 self.parent.exponentialBackoff(tries, deadline)) 287 continue 288 raise plumbing.convert_error_to_porcelain(e) from e 289 tries = 0 290 for plumbing_item in plumbing_response.history: 291 yield plumbing.convert_access_request_event_history_to_porcelain( 292 plumbing_item) 293 if plumbing_response.meta.next_cursor == '': 294 break 295 req.meta.cursor = plumbing_response.meta.next_cursor 296 297 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)
258 def list(self, filter, *args, timeout=None): 259 ''' 260 List gets a list of AccessRequestEventHistory records matching a given set of criteria. 261 ''' 262 deadline = None if timeout is None else time.time() + timeout 263 req = AccessRequestEventHistoryListRequest() 264 req.meta.CopyFrom(ListRequestMetadata()) 265 if self.parent.page_limit > 0: 266 req.meta.limit = self.parent.page_limit 267 if self.parent.snapshot_datetime is not None: 268 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 269 270 req.filter = plumbing.quote_filter_args(filter, *args) 271 272 def generator(svc, req): 273 tries = 0 274 while True: 275 t = None if deadline is None else deadline - time.time() 276 try: 277 plumbing_response = svc.stub.List( 278 req, 279 metadata=svc.parent.get_metadata( 280 'AccessRequestEventsHistory.List', req), 281 timeout=t) 282 except Exception as e: 283 if self.parent.shouldRetry(tries, e, deadline): 284 tries += 1 285 time.sleep( 286 self.parent.exponentialBackoff(tries, deadline)) 287 continue 288 raise plumbing.convert_error_to_porcelain(e) from e 289 tries = 0 290 for plumbing_item in plumbing_response.history: 291 yield plumbing.convert_access_request_event_history_to_porcelain( 292 plumbing_item) 293 if plumbing_response.meta.next_cursor == '': 294 break 295 req.meta.cursor = plumbing_response.meta.next_cursor 296 297 return generator(self, req)
List gets a list of AccessRequestEventHistory records matching a given set of criteria.
class
AccessRequestsHistory:
300class AccessRequestsHistory: 301 ''' 302 AccessRequestsHistory provides records of all changes to the state of an AccessRequest. 303 See `strongdm.models.AccessRequestHistory`. 304 ''' 305 def __init__(self, channel, client): 306 self.parent = client 307 self.stub = AccessRequestsHistoryStub(channel) 308 309 def list(self, filter, *args, timeout=None): 310 ''' 311 List gets a list of AccessRequestHistory records matching a given set of criteria. 312 ''' 313 deadline = None if timeout is None else time.time() + timeout 314 req = AccessRequestHistoryListRequest() 315 req.meta.CopyFrom(ListRequestMetadata()) 316 if self.parent.page_limit > 0: 317 req.meta.limit = self.parent.page_limit 318 if self.parent.snapshot_datetime is not None: 319 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 320 321 req.filter = plumbing.quote_filter_args(filter, *args) 322 323 def generator(svc, req): 324 tries = 0 325 while True: 326 t = None if deadline is None else deadline - time.time() 327 try: 328 plumbing_response = svc.stub.List( 329 req, 330 metadata=svc.parent.get_metadata( 331 'AccessRequestsHistory.List', req), 332 timeout=t) 333 except Exception as e: 334 if self.parent.shouldRetry(tries, e, deadline): 335 tries += 1 336 time.sleep( 337 self.parent.exponentialBackoff(tries, deadline)) 338 continue 339 raise plumbing.convert_error_to_porcelain(e) from e 340 tries = 0 341 for plumbing_item in plumbing_response.history: 342 yield plumbing.convert_access_request_history_to_porcelain( 343 plumbing_item) 344 if plumbing_response.meta.next_cursor == '': 345 break 346 req.meta.cursor = plumbing_response.meta.next_cursor 347 348 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)
309 def list(self, filter, *args, timeout=None): 310 ''' 311 List gets a list of AccessRequestHistory records matching a given set of criteria. 312 ''' 313 deadline = None if timeout is None else time.time() + timeout 314 req = AccessRequestHistoryListRequest() 315 req.meta.CopyFrom(ListRequestMetadata()) 316 if self.parent.page_limit > 0: 317 req.meta.limit = self.parent.page_limit 318 if self.parent.snapshot_datetime is not None: 319 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 320 321 req.filter = plumbing.quote_filter_args(filter, *args) 322 323 def generator(svc, req): 324 tries = 0 325 while True: 326 t = None if deadline is None else deadline - time.time() 327 try: 328 plumbing_response = svc.stub.List( 329 req, 330 metadata=svc.parent.get_metadata( 331 'AccessRequestsHistory.List', req), 332 timeout=t) 333 except Exception as e: 334 if self.parent.shouldRetry(tries, e, deadline): 335 tries += 1 336 time.sleep( 337 self.parent.exponentialBackoff(tries, deadline)) 338 continue 339 raise plumbing.convert_error_to_porcelain(e) from e 340 tries = 0 341 for plumbing_item in plumbing_response.history: 342 yield plumbing.convert_access_request_history_to_porcelain( 343 plumbing_item) 344 if plumbing_response.meta.next_cursor == '': 345 break 346 req.meta.cursor = plumbing_response.meta.next_cursor 347 348 return generator(self, req)
List gets a list of AccessRequestHistory records matching a given set of criteria.
class
AccountAttachments:
351class AccountAttachments: 352 ''' 353 AccountAttachments assign an account to a role. 354 See `strongdm.models.AccountAttachment`. 355 ''' 356 def __init__(self, channel, client): 357 self.parent = client 358 self.stub = AccountAttachmentsStub(channel) 359 360 def create(self, account_attachment, timeout=None): 361 ''' 362 Create registers a new AccountAttachment. 363 ''' 364 deadline = None if timeout is None else time.time() + timeout 365 req = AccountAttachmentCreateRequest() 366 367 if account_attachment is not None: 368 req.account_attachment.CopyFrom( 369 plumbing.convert_account_attachment_to_plumbing( 370 account_attachment)) 371 tries = 0 372 plumbing_response = None 373 while True: 374 t = None if deadline is None else deadline - time.time() 375 try: 376 plumbing_response = self.stub.Create( 377 req, 378 metadata=self.parent.get_metadata( 379 'AccountAttachments.Create', req), 380 timeout=t) 381 except Exception as e: 382 if self.parent.shouldRetry(tries, e, deadline): 383 tries += 1 384 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 385 continue 386 raise plumbing.convert_error_to_porcelain(e) from e 387 break 388 389 resp = models.AccountAttachmentCreateResponse() 390 resp.account_attachment = plumbing.convert_account_attachment_to_porcelain( 391 plumbing_response.account_attachment) 392 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 393 plumbing_response.meta) 394 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 395 plumbing_response.rate_limit) 396 return resp 397 398 def get(self, id, timeout=None): 399 ''' 400 Get reads one AccountAttachment by ID. 401 ''' 402 deadline = None if timeout is None else time.time() + timeout 403 req = AccountAttachmentGetRequest() 404 if self.parent.snapshot_datetime is not None: 405 req.meta.CopyFrom(GetRequestMetadata()) 406 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 407 408 req.id = (id) 409 tries = 0 410 plumbing_response = None 411 while True: 412 t = None if deadline is None else deadline - time.time() 413 try: 414 plumbing_response = self.stub.Get( 415 req, 416 metadata=self.parent.get_metadata('AccountAttachments.Get', 417 req), 418 timeout=t) 419 except Exception as e: 420 if self.parent.shouldRetry(tries, e, deadline): 421 tries += 1 422 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 423 continue 424 raise plumbing.convert_error_to_porcelain(e) from e 425 break 426 427 resp = models.AccountAttachmentGetResponse() 428 resp.account_attachment = plumbing.convert_account_attachment_to_porcelain( 429 plumbing_response.account_attachment) 430 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 431 plumbing_response.meta) 432 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 433 plumbing_response.rate_limit) 434 return resp 435 436 def delete(self, id, timeout=None): 437 ''' 438 Delete removes a AccountAttachment by ID. 439 ''' 440 deadline = None if timeout is None else time.time() + timeout 441 req = AccountAttachmentDeleteRequest() 442 443 req.id = (id) 444 tries = 0 445 plumbing_response = None 446 while True: 447 t = None if deadline is None else deadline - time.time() 448 try: 449 plumbing_response = self.stub.Delete( 450 req, 451 metadata=self.parent.get_metadata( 452 'AccountAttachments.Delete', req), 453 timeout=t) 454 except Exception as e: 455 if self.parent.shouldRetry(tries, e, deadline): 456 tries += 1 457 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 458 continue 459 raise plumbing.convert_error_to_porcelain(e) from e 460 break 461 462 resp = models.AccountAttachmentDeleteResponse() 463 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 464 plumbing_response.meta) 465 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 466 plumbing_response.rate_limit) 467 return resp 468 469 def list(self, filter, *args, timeout=None): 470 ''' 471 List gets a list of AccountAttachments matching a given set of criteria. 472 ''' 473 deadline = None if timeout is None else time.time() + timeout 474 req = AccountAttachmentListRequest() 475 req.meta.CopyFrom(ListRequestMetadata()) 476 if self.parent.page_limit > 0: 477 req.meta.limit = self.parent.page_limit 478 if self.parent.snapshot_datetime is not None: 479 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 480 481 req.filter = plumbing.quote_filter_args(filter, *args) 482 483 def generator(svc, req): 484 tries = 0 485 while True: 486 t = None if deadline is None else deadline - time.time() 487 try: 488 plumbing_response = svc.stub.List( 489 req, 490 metadata=svc.parent.get_metadata( 491 'AccountAttachments.List', req), 492 timeout=t) 493 except Exception as e: 494 if self.parent.shouldRetry(tries, e, deadline): 495 tries += 1 496 time.sleep( 497 self.parent.exponentialBackoff(tries, deadline)) 498 continue 499 raise plumbing.convert_error_to_porcelain(e) from e 500 tries = 0 501 for plumbing_item in plumbing_response.account_attachments: 502 yield plumbing.convert_account_attachment_to_porcelain( 503 plumbing_item) 504 if plumbing_response.meta.next_cursor == '': 505 break 506 req.meta.cursor = plumbing_response.meta.next_cursor 507 508 return generator(self, req)
AccountAttachments assign an account to a role.
See strongdm.models.AccountAttachment.
def
create(self, account_attachment, timeout=None)
360 def create(self, account_attachment, timeout=None): 361 ''' 362 Create registers a new AccountAttachment. 363 ''' 364 deadline = None if timeout is None else time.time() + timeout 365 req = AccountAttachmentCreateRequest() 366 367 if account_attachment is not None: 368 req.account_attachment.CopyFrom( 369 plumbing.convert_account_attachment_to_plumbing( 370 account_attachment)) 371 tries = 0 372 plumbing_response = None 373 while True: 374 t = None if deadline is None else deadline - time.time() 375 try: 376 plumbing_response = self.stub.Create( 377 req, 378 metadata=self.parent.get_metadata( 379 'AccountAttachments.Create', req), 380 timeout=t) 381 except Exception as e: 382 if self.parent.shouldRetry(tries, e, deadline): 383 tries += 1 384 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 385 continue 386 raise plumbing.convert_error_to_porcelain(e) from e 387 break 388 389 resp = models.AccountAttachmentCreateResponse() 390 resp.account_attachment = plumbing.convert_account_attachment_to_porcelain( 391 plumbing_response.account_attachment) 392 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 393 plumbing_response.meta) 394 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 395 plumbing_response.rate_limit) 396 return resp
Create registers a new AccountAttachment.
def
get(self, id, timeout=None)
398 def get(self, id, timeout=None): 399 ''' 400 Get reads one AccountAttachment by ID. 401 ''' 402 deadline = None if timeout is None else time.time() + timeout 403 req = AccountAttachmentGetRequest() 404 if self.parent.snapshot_datetime is not None: 405 req.meta.CopyFrom(GetRequestMetadata()) 406 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 407 408 req.id = (id) 409 tries = 0 410 plumbing_response = None 411 while True: 412 t = None if deadline is None else deadline - time.time() 413 try: 414 plumbing_response = self.stub.Get( 415 req, 416 metadata=self.parent.get_metadata('AccountAttachments.Get', 417 req), 418 timeout=t) 419 except Exception as e: 420 if self.parent.shouldRetry(tries, e, deadline): 421 tries += 1 422 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 423 continue 424 raise plumbing.convert_error_to_porcelain(e) from e 425 break 426 427 resp = models.AccountAttachmentGetResponse() 428 resp.account_attachment = plumbing.convert_account_attachment_to_porcelain( 429 plumbing_response.account_attachment) 430 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 431 plumbing_response.meta) 432 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 433 plumbing_response.rate_limit) 434 return resp
Get reads one AccountAttachment by ID.
def
delete(self, id, timeout=None)
436 def delete(self, id, timeout=None): 437 ''' 438 Delete removes a AccountAttachment by ID. 439 ''' 440 deadline = None if timeout is None else time.time() + timeout 441 req = AccountAttachmentDeleteRequest() 442 443 req.id = (id) 444 tries = 0 445 plumbing_response = None 446 while True: 447 t = None if deadline is None else deadline - time.time() 448 try: 449 plumbing_response = self.stub.Delete( 450 req, 451 metadata=self.parent.get_metadata( 452 'AccountAttachments.Delete', req), 453 timeout=t) 454 except Exception as e: 455 if self.parent.shouldRetry(tries, e, deadline): 456 tries += 1 457 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 458 continue 459 raise plumbing.convert_error_to_porcelain(e) from e 460 break 461 462 resp = models.AccountAttachmentDeleteResponse() 463 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 464 plumbing_response.meta) 465 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 466 plumbing_response.rate_limit) 467 return resp
Delete removes a AccountAttachment by ID.
def
list(self, filter, *args, timeout=None)
469 def list(self, filter, *args, timeout=None): 470 ''' 471 List gets a list of AccountAttachments matching a given set of criteria. 472 ''' 473 deadline = None if timeout is None else time.time() + timeout 474 req = AccountAttachmentListRequest() 475 req.meta.CopyFrom(ListRequestMetadata()) 476 if self.parent.page_limit > 0: 477 req.meta.limit = self.parent.page_limit 478 if self.parent.snapshot_datetime is not None: 479 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 480 481 req.filter = plumbing.quote_filter_args(filter, *args) 482 483 def generator(svc, req): 484 tries = 0 485 while True: 486 t = None if deadline is None else deadline - time.time() 487 try: 488 plumbing_response = svc.stub.List( 489 req, 490 metadata=svc.parent.get_metadata( 491 'AccountAttachments.List', req), 492 timeout=t) 493 except Exception as e: 494 if self.parent.shouldRetry(tries, e, deadline): 495 tries += 1 496 time.sleep( 497 self.parent.exponentialBackoff(tries, deadline)) 498 continue 499 raise plumbing.convert_error_to_porcelain(e) from e 500 tries = 0 501 for plumbing_item in plumbing_response.account_attachments: 502 yield plumbing.convert_account_attachment_to_porcelain( 503 plumbing_item) 504 if plumbing_response.meta.next_cursor == '': 505 break 506 req.meta.cursor = plumbing_response.meta.next_cursor 507 508 return generator(self, req)
List gets a list of AccountAttachments matching a given set of criteria.
class
SnapshotAccountAttachments:
511class SnapshotAccountAttachments: 512 ''' 513 SnapshotAccountAttachments exposes the read only methods of the AccountAttachments 514 service for historical queries. 515 ''' 516 def __init__(self, account_attachments): 517 self.account_attachments = account_attachments 518 519 def get(self, id, timeout=None): 520 ''' 521 Get reads one AccountAttachment by ID. 522 ''' 523 return self.account_attachments.get(id, timeout=timeout) 524 525 def list(self, filter, *args, timeout=None): 526 ''' 527 List gets a list of AccountAttachments matching a given set of criteria. 528 ''' 529 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)
519 def get(self, id, timeout=None): 520 ''' 521 Get reads one AccountAttachment by ID. 522 ''' 523 return self.account_attachments.get(id, timeout=timeout)
Get reads one AccountAttachment by ID.
def
list(self, filter, *args, timeout=None)
525 def list(self, filter, *args, timeout=None): 526 ''' 527 List gets a list of AccountAttachments matching a given set of criteria. 528 ''' 529 return self.account_attachments.list(filter, *args, timeout=timeout)
List gets a list of AccountAttachments matching a given set of criteria.
class
AccountAttachmentsHistory:
532class AccountAttachmentsHistory: 533 ''' 534 AccountAttachmentsHistory records all changes to the state of an AccountAttachment. 535 See `strongdm.models.AccountAttachmentHistory`. 536 ''' 537 def __init__(self, channel, client): 538 self.parent = client 539 self.stub = AccountAttachmentsHistoryStub(channel) 540 541 def list(self, filter, *args, timeout=None): 542 ''' 543 List gets a list of AccountAttachmentHistory records matching a given set of criteria. 544 ''' 545 deadline = None if timeout is None else time.time() + timeout 546 req = AccountAttachmentHistoryListRequest() 547 req.meta.CopyFrom(ListRequestMetadata()) 548 if self.parent.page_limit > 0: 549 req.meta.limit = self.parent.page_limit 550 if self.parent.snapshot_datetime is not None: 551 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 552 553 req.filter = plumbing.quote_filter_args(filter, *args) 554 555 def generator(svc, req): 556 tries = 0 557 while True: 558 t = None if deadline is None else deadline - time.time() 559 try: 560 plumbing_response = svc.stub.List( 561 req, 562 metadata=svc.parent.get_metadata( 563 'AccountAttachmentsHistory.List', req), 564 timeout=t) 565 except Exception as e: 566 if self.parent.shouldRetry(tries, e, deadline): 567 tries += 1 568 time.sleep( 569 self.parent.exponentialBackoff(tries, deadline)) 570 continue 571 raise plumbing.convert_error_to_porcelain(e) from e 572 tries = 0 573 for plumbing_item in plumbing_response.history: 574 yield plumbing.convert_account_attachment_history_to_porcelain( 575 plumbing_item) 576 if plumbing_response.meta.next_cursor == '': 577 break 578 req.meta.cursor = plumbing_response.meta.next_cursor 579 580 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)
541 def list(self, filter, *args, timeout=None): 542 ''' 543 List gets a list of AccountAttachmentHistory records matching a given set of criteria. 544 ''' 545 deadline = None if timeout is None else time.time() + timeout 546 req = AccountAttachmentHistoryListRequest() 547 req.meta.CopyFrom(ListRequestMetadata()) 548 if self.parent.page_limit > 0: 549 req.meta.limit = self.parent.page_limit 550 if self.parent.snapshot_datetime is not None: 551 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 552 553 req.filter = plumbing.quote_filter_args(filter, *args) 554 555 def generator(svc, req): 556 tries = 0 557 while True: 558 t = None if deadline is None else deadline - time.time() 559 try: 560 plumbing_response = svc.stub.List( 561 req, 562 metadata=svc.parent.get_metadata( 563 'AccountAttachmentsHistory.List', req), 564 timeout=t) 565 except Exception as e: 566 if self.parent.shouldRetry(tries, e, deadline): 567 tries += 1 568 time.sleep( 569 self.parent.exponentialBackoff(tries, deadline)) 570 continue 571 raise plumbing.convert_error_to_porcelain(e) from e 572 tries = 0 573 for plumbing_item in plumbing_response.history: 574 yield plumbing.convert_account_attachment_history_to_porcelain( 575 plumbing_item) 576 if plumbing_response.meta.next_cursor == '': 577 break 578 req.meta.cursor = plumbing_response.meta.next_cursor 579 580 return generator(self, req)
List gets a list of AccountAttachmentHistory records matching a given set of criteria.
class
AccountGrants:
583class AccountGrants: 584 ''' 585 AccountGrants assign a resource directly to an account, giving the account the permission to connect to that resource. 586 See `strongdm.models.AccountGrant`. 587 ''' 588 def __init__(self, channel, client): 589 self.parent = client 590 self.stub = AccountGrantsStub(channel) 591 592 def create(self, account_grant, timeout=None): 593 ''' 594 Create registers a new AccountGrant. 595 ''' 596 deadline = None if timeout is None else time.time() + timeout 597 req = AccountGrantCreateRequest() 598 599 if account_grant is not None: 600 req.account_grant.CopyFrom( 601 plumbing.convert_account_grant_to_plumbing(account_grant)) 602 tries = 0 603 plumbing_response = None 604 while True: 605 t = None if deadline is None else deadline - time.time() 606 try: 607 plumbing_response = self.stub.Create( 608 req, 609 metadata=self.parent.get_metadata('AccountGrants.Create', 610 req), 611 timeout=t) 612 except Exception as e: 613 if self.parent.shouldRetry(tries, e, deadline): 614 tries += 1 615 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 616 continue 617 raise plumbing.convert_error_to_porcelain(e) from e 618 break 619 620 resp = models.AccountGrantCreateResponse() 621 resp.account_grant = plumbing.convert_account_grant_to_porcelain( 622 plumbing_response.account_grant) 623 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 624 plumbing_response.meta) 625 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 626 plumbing_response.rate_limit) 627 return resp 628 629 def get(self, id, timeout=None): 630 ''' 631 Get reads one AccountGrant by ID. 632 ''' 633 deadline = None if timeout is None else time.time() + timeout 634 req = AccountGrantGetRequest() 635 if self.parent.snapshot_datetime is not None: 636 req.meta.CopyFrom(GetRequestMetadata()) 637 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 638 639 req.id = (id) 640 tries = 0 641 plumbing_response = None 642 while True: 643 t = None if deadline is None else deadline - time.time() 644 try: 645 plumbing_response = self.stub.Get( 646 req, 647 metadata=self.parent.get_metadata('AccountGrants.Get', 648 req), 649 timeout=t) 650 except Exception as e: 651 if self.parent.shouldRetry(tries, e, deadline): 652 tries += 1 653 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 654 continue 655 raise plumbing.convert_error_to_porcelain(e) from e 656 break 657 658 resp = models.AccountGrantGetResponse() 659 resp.account_grant = plumbing.convert_account_grant_to_porcelain( 660 plumbing_response.account_grant) 661 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 662 plumbing_response.meta) 663 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 664 plumbing_response.rate_limit) 665 return resp 666 667 def delete(self, id, timeout=None): 668 ''' 669 Delete removes a AccountGrant by ID. 670 ''' 671 deadline = None if timeout is None else time.time() + timeout 672 req = AccountGrantDeleteRequest() 673 674 req.id = (id) 675 tries = 0 676 plumbing_response = None 677 while True: 678 t = None if deadline is None else deadline - time.time() 679 try: 680 plumbing_response = self.stub.Delete( 681 req, 682 metadata=self.parent.get_metadata('AccountGrants.Delete', 683 req), 684 timeout=t) 685 except Exception as e: 686 if self.parent.shouldRetry(tries, e, deadline): 687 tries += 1 688 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 689 continue 690 raise plumbing.convert_error_to_porcelain(e) from e 691 break 692 693 resp = models.AccountGrantDeleteResponse() 694 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 695 plumbing_response.meta) 696 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 697 plumbing_response.rate_limit) 698 return resp 699 700 def list(self, filter, *args, timeout=None): 701 ''' 702 List gets a list of AccountGrants matching a given set of criteria. 703 ''' 704 deadline = None if timeout is None else time.time() + timeout 705 req = AccountGrantListRequest() 706 req.meta.CopyFrom(ListRequestMetadata()) 707 if self.parent.page_limit > 0: 708 req.meta.limit = self.parent.page_limit 709 if self.parent.snapshot_datetime is not None: 710 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 711 712 req.filter = plumbing.quote_filter_args(filter, *args) 713 714 def generator(svc, req): 715 tries = 0 716 while True: 717 t = None if deadline is None else deadline - time.time() 718 try: 719 plumbing_response = svc.stub.List( 720 req, 721 metadata=svc.parent.get_metadata( 722 'AccountGrants.List', req), 723 timeout=t) 724 except Exception as e: 725 if self.parent.shouldRetry(tries, e, deadline): 726 tries += 1 727 time.sleep( 728 self.parent.exponentialBackoff(tries, deadline)) 729 continue 730 raise plumbing.convert_error_to_porcelain(e) from e 731 tries = 0 732 for plumbing_item in plumbing_response.account_grants: 733 yield plumbing.convert_account_grant_to_porcelain( 734 plumbing_item) 735 if plumbing_response.meta.next_cursor == '': 736 break 737 req.meta.cursor = plumbing_response.meta.next_cursor 738 739 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)
592 def create(self, account_grant, timeout=None): 593 ''' 594 Create registers a new AccountGrant. 595 ''' 596 deadline = None if timeout is None else time.time() + timeout 597 req = AccountGrantCreateRequest() 598 599 if account_grant is not None: 600 req.account_grant.CopyFrom( 601 plumbing.convert_account_grant_to_plumbing(account_grant)) 602 tries = 0 603 plumbing_response = None 604 while True: 605 t = None if deadline is None else deadline - time.time() 606 try: 607 plumbing_response = self.stub.Create( 608 req, 609 metadata=self.parent.get_metadata('AccountGrants.Create', 610 req), 611 timeout=t) 612 except Exception as e: 613 if self.parent.shouldRetry(tries, e, deadline): 614 tries += 1 615 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 616 continue 617 raise plumbing.convert_error_to_porcelain(e) from e 618 break 619 620 resp = models.AccountGrantCreateResponse() 621 resp.account_grant = plumbing.convert_account_grant_to_porcelain( 622 plumbing_response.account_grant) 623 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 624 plumbing_response.meta) 625 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 626 plumbing_response.rate_limit) 627 return resp
Create registers a new AccountGrant.
def
get(self, id, timeout=None)
629 def get(self, id, timeout=None): 630 ''' 631 Get reads one AccountGrant by ID. 632 ''' 633 deadline = None if timeout is None else time.time() + timeout 634 req = AccountGrantGetRequest() 635 if self.parent.snapshot_datetime is not None: 636 req.meta.CopyFrom(GetRequestMetadata()) 637 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 638 639 req.id = (id) 640 tries = 0 641 plumbing_response = None 642 while True: 643 t = None if deadline is None else deadline - time.time() 644 try: 645 plumbing_response = self.stub.Get( 646 req, 647 metadata=self.parent.get_metadata('AccountGrants.Get', 648 req), 649 timeout=t) 650 except Exception as e: 651 if self.parent.shouldRetry(tries, e, deadline): 652 tries += 1 653 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 654 continue 655 raise plumbing.convert_error_to_porcelain(e) from e 656 break 657 658 resp = models.AccountGrantGetResponse() 659 resp.account_grant = plumbing.convert_account_grant_to_porcelain( 660 plumbing_response.account_grant) 661 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 662 plumbing_response.meta) 663 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 664 plumbing_response.rate_limit) 665 return resp
Get reads one AccountGrant by ID.
def
delete(self, id, timeout=None)
667 def delete(self, id, timeout=None): 668 ''' 669 Delete removes a AccountGrant by ID. 670 ''' 671 deadline = None if timeout is None else time.time() + timeout 672 req = AccountGrantDeleteRequest() 673 674 req.id = (id) 675 tries = 0 676 plumbing_response = None 677 while True: 678 t = None if deadline is None else deadline - time.time() 679 try: 680 plumbing_response = self.stub.Delete( 681 req, 682 metadata=self.parent.get_metadata('AccountGrants.Delete', 683 req), 684 timeout=t) 685 except Exception as e: 686 if self.parent.shouldRetry(tries, e, deadline): 687 tries += 1 688 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 689 continue 690 raise plumbing.convert_error_to_porcelain(e) from e 691 break 692 693 resp = models.AccountGrantDeleteResponse() 694 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 695 plumbing_response.meta) 696 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 697 plumbing_response.rate_limit) 698 return resp
Delete removes a AccountGrant by ID.
def
list(self, filter, *args, timeout=None)
700 def list(self, filter, *args, timeout=None): 701 ''' 702 List gets a list of AccountGrants matching a given set of criteria. 703 ''' 704 deadline = None if timeout is None else time.time() + timeout 705 req = AccountGrantListRequest() 706 req.meta.CopyFrom(ListRequestMetadata()) 707 if self.parent.page_limit > 0: 708 req.meta.limit = self.parent.page_limit 709 if self.parent.snapshot_datetime is not None: 710 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 711 712 req.filter = plumbing.quote_filter_args(filter, *args) 713 714 def generator(svc, req): 715 tries = 0 716 while True: 717 t = None if deadline is None else deadline - time.time() 718 try: 719 plumbing_response = svc.stub.List( 720 req, 721 metadata=svc.parent.get_metadata( 722 'AccountGrants.List', req), 723 timeout=t) 724 except Exception as e: 725 if self.parent.shouldRetry(tries, e, deadline): 726 tries += 1 727 time.sleep( 728 self.parent.exponentialBackoff(tries, deadline)) 729 continue 730 raise plumbing.convert_error_to_porcelain(e) from e 731 tries = 0 732 for plumbing_item in plumbing_response.account_grants: 733 yield plumbing.convert_account_grant_to_porcelain( 734 plumbing_item) 735 if plumbing_response.meta.next_cursor == '': 736 break 737 req.meta.cursor = plumbing_response.meta.next_cursor 738 739 return generator(self, req)
List gets a list of AccountGrants matching a given set of criteria.
class
SnapshotAccountGrants:
742class SnapshotAccountGrants: 743 ''' 744 SnapshotAccountGrants exposes the read only methods of the AccountGrants 745 service for historical queries. 746 ''' 747 def __init__(self, account_grants): 748 self.account_grants = account_grants 749 750 def get(self, id, timeout=None): 751 ''' 752 Get reads one AccountGrant by ID. 753 ''' 754 return self.account_grants.get(id, timeout=timeout) 755 756 def list(self, filter, *args, timeout=None): 757 ''' 758 List gets a list of AccountGrants matching a given set of criteria. 759 ''' 760 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)
750 def get(self, id, timeout=None): 751 ''' 752 Get reads one AccountGrant by ID. 753 ''' 754 return self.account_grants.get(id, timeout=timeout)
Get reads one AccountGrant by ID.
def
list(self, filter, *args, timeout=None)
756 def list(self, filter, *args, timeout=None): 757 ''' 758 List gets a list of AccountGrants matching a given set of criteria. 759 ''' 760 return self.account_grants.list(filter, *args, timeout=timeout)
List gets a list of AccountGrants matching a given set of criteria.
class
AccountGrantsHistory:
763class AccountGrantsHistory: 764 ''' 765 AccountGrantsHistory records all changes to the state of an AccountGrant. 766 See `strongdm.models.AccountGrantHistory`. 767 ''' 768 def __init__(self, channel, client): 769 self.parent = client 770 self.stub = AccountGrantsHistoryStub(channel) 771 772 def list(self, filter, *args, timeout=None): 773 ''' 774 List gets a list of AccountGrantHistory records matching a given set of criteria. 775 ''' 776 deadline = None if timeout is None else time.time() + timeout 777 req = AccountGrantHistoryListRequest() 778 req.meta.CopyFrom(ListRequestMetadata()) 779 if self.parent.page_limit > 0: 780 req.meta.limit = self.parent.page_limit 781 if self.parent.snapshot_datetime is not None: 782 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 783 784 req.filter = plumbing.quote_filter_args(filter, *args) 785 786 def generator(svc, req): 787 tries = 0 788 while True: 789 t = None if deadline is None else deadline - time.time() 790 try: 791 plumbing_response = svc.stub.List( 792 req, 793 metadata=svc.parent.get_metadata( 794 'AccountGrantsHistory.List', req), 795 timeout=t) 796 except Exception as e: 797 if self.parent.shouldRetry(tries, e, deadline): 798 tries += 1 799 time.sleep( 800 self.parent.exponentialBackoff(tries, deadline)) 801 continue 802 raise plumbing.convert_error_to_porcelain(e) from e 803 tries = 0 804 for plumbing_item in plumbing_response.history: 805 yield plumbing.convert_account_grant_history_to_porcelain( 806 plumbing_item) 807 if plumbing_response.meta.next_cursor == '': 808 break 809 req.meta.cursor = plumbing_response.meta.next_cursor 810 811 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)
772 def list(self, filter, *args, timeout=None): 773 ''' 774 List gets a list of AccountGrantHistory records matching a given set of criteria. 775 ''' 776 deadline = None if timeout is None else time.time() + timeout 777 req = AccountGrantHistoryListRequest() 778 req.meta.CopyFrom(ListRequestMetadata()) 779 if self.parent.page_limit > 0: 780 req.meta.limit = self.parent.page_limit 781 if self.parent.snapshot_datetime is not None: 782 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 783 784 req.filter = plumbing.quote_filter_args(filter, *args) 785 786 def generator(svc, req): 787 tries = 0 788 while True: 789 t = None if deadline is None else deadline - time.time() 790 try: 791 plumbing_response = svc.stub.List( 792 req, 793 metadata=svc.parent.get_metadata( 794 'AccountGrantsHistory.List', req), 795 timeout=t) 796 except Exception as e: 797 if self.parent.shouldRetry(tries, e, deadline): 798 tries += 1 799 time.sleep( 800 self.parent.exponentialBackoff(tries, deadline)) 801 continue 802 raise plumbing.convert_error_to_porcelain(e) from e 803 tries = 0 804 for plumbing_item in plumbing_response.history: 805 yield plumbing.convert_account_grant_history_to_porcelain( 806 plumbing_item) 807 if plumbing_response.meta.next_cursor == '': 808 break 809 req.meta.cursor = plumbing_response.meta.next_cursor 810 811 return generator(self, req)
List gets a list of AccountGrantHistory records matching a given set of criteria.
class
AccountPermissions:
814class AccountPermissions: 815 ''' 816 AccountPermissions records the granular permissions accounts have, allowing them to execute 817 relevant commands via StrongDM's APIs. 818 See `strongdm.models.AccountPermission`. 819 ''' 820 def __init__(self, channel, client): 821 self.parent = client 822 self.stub = AccountPermissionsStub(channel) 823 824 def list(self, filter, *args, timeout=None): 825 ''' 826 List gets a list of Permission records matching a given set of criteria. 827 ''' 828 deadline = None if timeout is None else time.time() + timeout 829 req = AccountPermissionListRequest() 830 req.meta.CopyFrom(ListRequestMetadata()) 831 if self.parent.page_limit > 0: 832 req.meta.limit = self.parent.page_limit 833 if self.parent.snapshot_datetime is not None: 834 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 835 836 req.filter = plumbing.quote_filter_args(filter, *args) 837 838 def generator(svc, req): 839 tries = 0 840 while True: 841 t = None if deadline is None else deadline - time.time() 842 try: 843 plumbing_response = svc.stub.List( 844 req, 845 metadata=svc.parent.get_metadata( 846 'AccountPermissions.List', req), 847 timeout=t) 848 except Exception as e: 849 if self.parent.shouldRetry(tries, e, deadline): 850 tries += 1 851 time.sleep( 852 self.parent.exponentialBackoff(tries, deadline)) 853 continue 854 raise plumbing.convert_error_to_porcelain(e) from e 855 tries = 0 856 for plumbing_item in plumbing_response.permissions: 857 yield plumbing.convert_account_permission_to_porcelain( 858 plumbing_item) 859 if plumbing_response.meta.next_cursor == '': 860 break 861 req.meta.cursor = plumbing_response.meta.next_cursor 862 863 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)
824 def list(self, filter, *args, timeout=None): 825 ''' 826 List gets a list of Permission records matching a given set of criteria. 827 ''' 828 deadline = None if timeout is None else time.time() + timeout 829 req = AccountPermissionListRequest() 830 req.meta.CopyFrom(ListRequestMetadata()) 831 if self.parent.page_limit > 0: 832 req.meta.limit = self.parent.page_limit 833 if self.parent.snapshot_datetime is not None: 834 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 835 836 req.filter = plumbing.quote_filter_args(filter, *args) 837 838 def generator(svc, req): 839 tries = 0 840 while True: 841 t = None if deadline is None else deadline - time.time() 842 try: 843 plumbing_response = svc.stub.List( 844 req, 845 metadata=svc.parent.get_metadata( 846 'AccountPermissions.List', req), 847 timeout=t) 848 except Exception as e: 849 if self.parent.shouldRetry(tries, e, deadline): 850 tries += 1 851 time.sleep( 852 self.parent.exponentialBackoff(tries, deadline)) 853 continue 854 raise plumbing.convert_error_to_porcelain(e) from e 855 tries = 0 856 for plumbing_item in plumbing_response.permissions: 857 yield plumbing.convert_account_permission_to_porcelain( 858 plumbing_item) 859 if plumbing_response.meta.next_cursor == '': 860 break 861 req.meta.cursor = plumbing_response.meta.next_cursor 862 863 return generator(self, req)
List gets a list of Permission records matching a given set of criteria.
class
SnapshotAccountPermissions:
866class SnapshotAccountPermissions: 867 ''' 868 SnapshotAccountPermissions exposes the read only methods of the AccountPermissions 869 service for historical queries. 870 ''' 871 def __init__(self, account_permissions): 872 self.account_permissions = account_permissions 873 874 def list(self, filter, *args, timeout=None): 875 ''' 876 List gets a list of Permission records matching a given set of criteria. 877 ''' 878 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)
874 def list(self, filter, *args, timeout=None): 875 ''' 876 List gets a list of Permission records matching a given set of criteria. 877 ''' 878 return self.account_permissions.list(filter, *args, timeout=timeout)
List gets a list of Permission records matching a given set of criteria.
class
AccountResources:
881class AccountResources: 882 ''' 883 AccountResources enumerates the resources to which accounts have access. 884 The AccountResources service is read-only. 885 See `strongdm.models.AccountResource`. 886 ''' 887 def __init__(self, channel, client): 888 self.parent = client 889 self.stub = AccountResourcesStub(channel) 890 891 def list(self, filter, *args, timeout=None): 892 ''' 893 List gets a list of AccountResource records matching a given set of criteria. 894 ''' 895 deadline = None if timeout is None else time.time() + timeout 896 req = AccountResourceListRequest() 897 req.meta.CopyFrom(ListRequestMetadata()) 898 if self.parent.page_limit > 0: 899 req.meta.limit = self.parent.page_limit 900 if self.parent.snapshot_datetime is not None: 901 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 902 903 req.filter = plumbing.quote_filter_args(filter, *args) 904 905 def generator(svc, req): 906 tries = 0 907 while True: 908 t = None if deadline is None else deadline - time.time() 909 try: 910 plumbing_response = svc.stub.List( 911 req, 912 metadata=svc.parent.get_metadata( 913 'AccountResources.List', req), 914 timeout=t) 915 except Exception as e: 916 if self.parent.shouldRetry(tries, e, deadline): 917 tries += 1 918 time.sleep( 919 self.parent.exponentialBackoff(tries, deadline)) 920 continue 921 raise plumbing.convert_error_to_porcelain(e) from e 922 tries = 0 923 for plumbing_item in plumbing_response.account_resources: 924 yield plumbing.convert_account_resource_to_porcelain( 925 plumbing_item) 926 if plumbing_response.meta.next_cursor == '': 927 break 928 req.meta.cursor = plumbing_response.meta.next_cursor 929 930 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)
891 def list(self, filter, *args, timeout=None): 892 ''' 893 List gets a list of AccountResource records matching a given set of criteria. 894 ''' 895 deadline = None if timeout is None else time.time() + timeout 896 req = AccountResourceListRequest() 897 req.meta.CopyFrom(ListRequestMetadata()) 898 if self.parent.page_limit > 0: 899 req.meta.limit = self.parent.page_limit 900 if self.parent.snapshot_datetime is not None: 901 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 902 903 req.filter = plumbing.quote_filter_args(filter, *args) 904 905 def generator(svc, req): 906 tries = 0 907 while True: 908 t = None if deadline is None else deadline - time.time() 909 try: 910 plumbing_response = svc.stub.List( 911 req, 912 metadata=svc.parent.get_metadata( 913 'AccountResources.List', req), 914 timeout=t) 915 except Exception as e: 916 if self.parent.shouldRetry(tries, e, deadline): 917 tries += 1 918 time.sleep( 919 self.parent.exponentialBackoff(tries, deadline)) 920 continue 921 raise plumbing.convert_error_to_porcelain(e) from e 922 tries = 0 923 for plumbing_item in plumbing_response.account_resources: 924 yield plumbing.convert_account_resource_to_porcelain( 925 plumbing_item) 926 if plumbing_response.meta.next_cursor == '': 927 break 928 req.meta.cursor = plumbing_response.meta.next_cursor 929 930 return generator(self, req)
List gets a list of AccountResource records matching a given set of criteria.
class
SnapshotAccountResources:
933class SnapshotAccountResources: 934 ''' 935 SnapshotAccountResources exposes the read only methods of the AccountResources 936 service for historical queries. 937 ''' 938 def __init__(self, account_resources): 939 self.account_resources = account_resources 940 941 def list(self, filter, *args, timeout=None): 942 ''' 943 List gets a list of AccountResource records matching a given set of criteria. 944 ''' 945 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)
941 def list(self, filter, *args, timeout=None): 942 ''' 943 List gets a list of AccountResource records matching a given set of criteria. 944 ''' 945 return self.account_resources.list(filter, *args, timeout=timeout)
List gets a list of AccountResource records matching a given set of criteria.
class
AccountResourcesHistory:
948class AccountResourcesHistory: 949 ''' 950 AccountResourcesHistory records all changes to the state of a AccountResource. 951 See `strongdm.models.AccountResourceHistory`. 952 ''' 953 def __init__(self, channel, client): 954 self.parent = client 955 self.stub = AccountResourcesHistoryStub(channel) 956 957 def list(self, filter, *args, timeout=None): 958 ''' 959 List gets a list of AccountResourceHistory records matching a given set of criteria. 960 ''' 961 deadline = None if timeout is None else time.time() + timeout 962 req = AccountResourceHistoryListRequest() 963 req.meta.CopyFrom(ListRequestMetadata()) 964 if self.parent.page_limit > 0: 965 req.meta.limit = self.parent.page_limit 966 if self.parent.snapshot_datetime is not None: 967 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 968 969 req.filter = plumbing.quote_filter_args(filter, *args) 970 971 def generator(svc, req): 972 tries = 0 973 while True: 974 t = None if deadline is None else deadline - time.time() 975 try: 976 plumbing_response = svc.stub.List( 977 req, 978 metadata=svc.parent.get_metadata( 979 'AccountResourcesHistory.List', req), 980 timeout=t) 981 except Exception as e: 982 if self.parent.shouldRetry(tries, e, deadline): 983 tries += 1 984 time.sleep( 985 self.parent.exponentialBackoff(tries, deadline)) 986 continue 987 raise plumbing.convert_error_to_porcelain(e) from e 988 tries = 0 989 for plumbing_item in plumbing_response.history: 990 yield plumbing.convert_account_resource_history_to_porcelain( 991 plumbing_item) 992 if plumbing_response.meta.next_cursor == '': 993 break 994 req.meta.cursor = plumbing_response.meta.next_cursor 995 996 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)
957 def list(self, filter, *args, timeout=None): 958 ''' 959 List gets a list of AccountResourceHistory records matching a given set of criteria. 960 ''' 961 deadline = None if timeout is None else time.time() + timeout 962 req = AccountResourceHistoryListRequest() 963 req.meta.CopyFrom(ListRequestMetadata()) 964 if self.parent.page_limit > 0: 965 req.meta.limit = self.parent.page_limit 966 if self.parent.snapshot_datetime is not None: 967 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 968 969 req.filter = plumbing.quote_filter_args(filter, *args) 970 971 def generator(svc, req): 972 tries = 0 973 while True: 974 t = None if deadline is None else deadline - time.time() 975 try: 976 plumbing_response = svc.stub.List( 977 req, 978 metadata=svc.parent.get_metadata( 979 'AccountResourcesHistory.List', req), 980 timeout=t) 981 except Exception as e: 982 if self.parent.shouldRetry(tries, e, deadline): 983 tries += 1 984 time.sleep( 985 self.parent.exponentialBackoff(tries, deadline)) 986 continue 987 raise plumbing.convert_error_to_porcelain(e) from e 988 tries = 0 989 for plumbing_item in plumbing_response.history: 990 yield plumbing.convert_account_resource_history_to_porcelain( 991 plumbing_item) 992 if plumbing_response.meta.next_cursor == '': 993 break 994 req.meta.cursor = plumbing_response.meta.next_cursor 995 996 return generator(self, req)
List gets a list of AccountResourceHistory records matching a given set of criteria.
class
Accounts:
999class Accounts: 1000 ''' 1001 Accounts are users that have access to strongDM. There are two types of accounts: 1002 1. **Users:** humans who are authenticated through username and password or SSO. 1003 2. **Service Accounts:** machines that are authenticated using a service token. 1004 3. **Tokens** are access keys with permissions that can be used for authentication. 1005 See: 1006 `strongdm.models.Service` 1007 `strongdm.models.Token` 1008 `strongdm.models.User` 1009 ''' 1010 def __init__(self, channel, client): 1011 self.parent = client 1012 self.stub = AccountsStub(channel) 1013 1014 def create(self, account, timeout=None): 1015 ''' 1016 Create registers a new Account. 1017 ''' 1018 deadline = None if timeout is None else time.time() + timeout 1019 req = AccountCreateRequest() 1020 1021 if account is not None: 1022 req.account.CopyFrom(plumbing.convert_account_to_plumbing(account)) 1023 tries = 0 1024 plumbing_response = None 1025 while True: 1026 t = None if deadline is None else deadline - time.time() 1027 try: 1028 plumbing_response = self.stub.Create( 1029 req, 1030 metadata=self.parent.get_metadata('Accounts.Create', req), 1031 timeout=t) 1032 except Exception as e: 1033 if self.parent.shouldRetry(tries, e, deadline): 1034 tries += 1 1035 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1036 continue 1037 raise plumbing.convert_error_to_porcelain(e) from e 1038 break 1039 1040 resp = models.AccountCreateResponse() 1041 resp.access_key = (plumbing_response.access_key) 1042 resp.account = plumbing.convert_account_to_porcelain( 1043 plumbing_response.account) 1044 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 1045 plumbing_response.meta) 1046 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1047 plumbing_response.rate_limit) 1048 resp.secret_key = (plumbing_response.secret_key) 1049 resp.token = (plumbing_response.token) 1050 return resp 1051 1052 def get(self, id, timeout=None): 1053 ''' 1054 Get reads one Account by ID. 1055 ''' 1056 deadline = None if timeout is None else time.time() + timeout 1057 req = AccountGetRequest() 1058 if self.parent.snapshot_datetime is not None: 1059 req.meta.CopyFrom(GetRequestMetadata()) 1060 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1061 1062 req.id = (id) 1063 tries = 0 1064 plumbing_response = None 1065 while True: 1066 t = None if deadline is None else deadline - time.time() 1067 try: 1068 plumbing_response = self.stub.Get( 1069 req, 1070 metadata=self.parent.get_metadata('Accounts.Get', req), 1071 timeout=t) 1072 except Exception as e: 1073 if self.parent.shouldRetry(tries, e, deadline): 1074 tries += 1 1075 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1076 continue 1077 raise plumbing.convert_error_to_porcelain(e) from e 1078 break 1079 1080 resp = models.AccountGetResponse() 1081 resp.account = plumbing.convert_account_to_porcelain( 1082 plumbing_response.account) 1083 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1084 plumbing_response.meta) 1085 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1086 plumbing_response.rate_limit) 1087 return resp 1088 1089 def update(self, account, timeout=None): 1090 ''' 1091 Update replaces all the fields of an Account by ID. 1092 ''' 1093 deadline = None if timeout is None else time.time() + timeout 1094 req = AccountUpdateRequest() 1095 1096 if account is not None: 1097 req.account.CopyFrom(plumbing.convert_account_to_plumbing(account)) 1098 tries = 0 1099 plumbing_response = None 1100 while True: 1101 t = None if deadline is None else deadline - time.time() 1102 try: 1103 plumbing_response = self.stub.Update( 1104 req, 1105 metadata=self.parent.get_metadata('Accounts.Update', req), 1106 timeout=t) 1107 except Exception as e: 1108 if self.parent.shouldRetry(tries, e, deadline): 1109 tries += 1 1110 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1111 continue 1112 raise plumbing.convert_error_to_porcelain(e) from e 1113 break 1114 1115 resp = models.AccountUpdateResponse() 1116 resp.account = plumbing.convert_account_to_porcelain( 1117 plumbing_response.account) 1118 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 1119 plumbing_response.meta) 1120 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1121 plumbing_response.rate_limit) 1122 return resp 1123 1124 def delete(self, id, timeout=None): 1125 ''' 1126 Delete removes an Account by ID. 1127 ''' 1128 deadline = None if timeout is None else time.time() + timeout 1129 req = AccountDeleteRequest() 1130 1131 req.id = (id) 1132 tries = 0 1133 plumbing_response = None 1134 while True: 1135 t = None if deadline is None else deadline - time.time() 1136 try: 1137 plumbing_response = self.stub.Delete( 1138 req, 1139 metadata=self.parent.get_metadata('Accounts.Delete', req), 1140 timeout=t) 1141 except Exception as e: 1142 if self.parent.shouldRetry(tries, e, deadline): 1143 tries += 1 1144 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1145 continue 1146 raise plumbing.convert_error_to_porcelain(e) from e 1147 break 1148 1149 resp = models.AccountDeleteResponse() 1150 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 1151 plumbing_response.meta) 1152 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1153 plumbing_response.rate_limit) 1154 return resp 1155 1156 def list(self, filter, *args, timeout=None): 1157 ''' 1158 List gets a list of Accounts matching a given set of criteria. 1159 ''' 1160 deadline = None if timeout is None else time.time() + timeout 1161 req = AccountListRequest() 1162 req.meta.CopyFrom(ListRequestMetadata()) 1163 if self.parent.page_limit > 0: 1164 req.meta.limit = self.parent.page_limit 1165 if self.parent.snapshot_datetime is not None: 1166 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1167 1168 req.filter = plumbing.quote_filter_args(filter, *args) 1169 1170 def generator(svc, req): 1171 tries = 0 1172 while True: 1173 t = None if deadline is None else deadline - time.time() 1174 try: 1175 plumbing_response = svc.stub.List( 1176 req, 1177 metadata=svc.parent.get_metadata('Accounts.List', req), 1178 timeout=t) 1179 except Exception as e: 1180 if self.parent.shouldRetry(tries, e, deadline): 1181 tries += 1 1182 time.sleep( 1183 self.parent.exponentialBackoff(tries, deadline)) 1184 continue 1185 raise plumbing.convert_error_to_porcelain(e) from e 1186 tries = 0 1187 for plumbing_item in plumbing_response.accounts: 1188 yield plumbing.convert_account_to_porcelain(plumbing_item) 1189 if plumbing_response.meta.next_cursor == '': 1190 break 1191 req.meta.cursor = plumbing_response.meta.next_cursor 1192 1193 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)
1014 def create(self, account, timeout=None): 1015 ''' 1016 Create registers a new Account. 1017 ''' 1018 deadline = None if timeout is None else time.time() + timeout 1019 req = AccountCreateRequest() 1020 1021 if account is not None: 1022 req.account.CopyFrom(plumbing.convert_account_to_plumbing(account)) 1023 tries = 0 1024 plumbing_response = None 1025 while True: 1026 t = None if deadline is None else deadline - time.time() 1027 try: 1028 plumbing_response = self.stub.Create( 1029 req, 1030 metadata=self.parent.get_metadata('Accounts.Create', req), 1031 timeout=t) 1032 except Exception as e: 1033 if self.parent.shouldRetry(tries, e, deadline): 1034 tries += 1 1035 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1036 continue 1037 raise plumbing.convert_error_to_porcelain(e) from e 1038 break 1039 1040 resp = models.AccountCreateResponse() 1041 resp.access_key = (plumbing_response.access_key) 1042 resp.account = plumbing.convert_account_to_porcelain( 1043 plumbing_response.account) 1044 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 1045 plumbing_response.meta) 1046 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1047 plumbing_response.rate_limit) 1048 resp.secret_key = (plumbing_response.secret_key) 1049 resp.token = (plumbing_response.token) 1050 return resp
Create registers a new Account.
def
get(self, id, timeout=None)
1052 def get(self, id, timeout=None): 1053 ''' 1054 Get reads one Account by ID. 1055 ''' 1056 deadline = None if timeout is None else time.time() + timeout 1057 req = AccountGetRequest() 1058 if self.parent.snapshot_datetime is not None: 1059 req.meta.CopyFrom(GetRequestMetadata()) 1060 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1061 1062 req.id = (id) 1063 tries = 0 1064 plumbing_response = None 1065 while True: 1066 t = None if deadline is None else deadline - time.time() 1067 try: 1068 plumbing_response = self.stub.Get( 1069 req, 1070 metadata=self.parent.get_metadata('Accounts.Get', req), 1071 timeout=t) 1072 except Exception as e: 1073 if self.parent.shouldRetry(tries, e, deadline): 1074 tries += 1 1075 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1076 continue 1077 raise plumbing.convert_error_to_porcelain(e) from e 1078 break 1079 1080 resp = models.AccountGetResponse() 1081 resp.account = plumbing.convert_account_to_porcelain( 1082 plumbing_response.account) 1083 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1084 plumbing_response.meta) 1085 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1086 plumbing_response.rate_limit) 1087 return resp
Get reads one Account by ID.
def
update(self, account, timeout=None)
1089 def update(self, account, timeout=None): 1090 ''' 1091 Update replaces all the fields of an Account by ID. 1092 ''' 1093 deadline = None if timeout is None else time.time() + timeout 1094 req = AccountUpdateRequest() 1095 1096 if account is not None: 1097 req.account.CopyFrom(plumbing.convert_account_to_plumbing(account)) 1098 tries = 0 1099 plumbing_response = None 1100 while True: 1101 t = None if deadline is None else deadline - time.time() 1102 try: 1103 plumbing_response = self.stub.Update( 1104 req, 1105 metadata=self.parent.get_metadata('Accounts.Update', req), 1106 timeout=t) 1107 except Exception as e: 1108 if self.parent.shouldRetry(tries, e, deadline): 1109 tries += 1 1110 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1111 continue 1112 raise plumbing.convert_error_to_porcelain(e) from e 1113 break 1114 1115 resp = models.AccountUpdateResponse() 1116 resp.account = plumbing.convert_account_to_porcelain( 1117 plumbing_response.account) 1118 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 1119 plumbing_response.meta) 1120 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1121 plumbing_response.rate_limit) 1122 return resp
Update replaces all the fields of an Account by ID.
def
delete(self, id, timeout=None)
1124 def delete(self, id, timeout=None): 1125 ''' 1126 Delete removes an Account by ID. 1127 ''' 1128 deadline = None if timeout is None else time.time() + timeout 1129 req = AccountDeleteRequest() 1130 1131 req.id = (id) 1132 tries = 0 1133 plumbing_response = None 1134 while True: 1135 t = None if deadline is None else deadline - time.time() 1136 try: 1137 plumbing_response = self.stub.Delete( 1138 req, 1139 metadata=self.parent.get_metadata('Accounts.Delete', req), 1140 timeout=t) 1141 except Exception as e: 1142 if self.parent.shouldRetry(tries, e, deadline): 1143 tries += 1 1144 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1145 continue 1146 raise plumbing.convert_error_to_porcelain(e) from e 1147 break 1148 1149 resp = models.AccountDeleteResponse() 1150 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 1151 plumbing_response.meta) 1152 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1153 plumbing_response.rate_limit) 1154 return resp
Delete removes an Account by ID.
def
list(self, filter, *args, timeout=None)
1156 def list(self, filter, *args, timeout=None): 1157 ''' 1158 List gets a list of Accounts matching a given set of criteria. 1159 ''' 1160 deadline = None if timeout is None else time.time() + timeout 1161 req = AccountListRequest() 1162 req.meta.CopyFrom(ListRequestMetadata()) 1163 if self.parent.page_limit > 0: 1164 req.meta.limit = self.parent.page_limit 1165 if self.parent.snapshot_datetime is not None: 1166 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1167 1168 req.filter = plumbing.quote_filter_args(filter, *args) 1169 1170 def generator(svc, req): 1171 tries = 0 1172 while True: 1173 t = None if deadline is None else deadline - time.time() 1174 try: 1175 plumbing_response = svc.stub.List( 1176 req, 1177 metadata=svc.parent.get_metadata('Accounts.List', req), 1178 timeout=t) 1179 except Exception as e: 1180 if self.parent.shouldRetry(tries, e, deadline): 1181 tries += 1 1182 time.sleep( 1183 self.parent.exponentialBackoff(tries, deadline)) 1184 continue 1185 raise plumbing.convert_error_to_porcelain(e) from e 1186 tries = 0 1187 for plumbing_item in plumbing_response.accounts: 1188 yield plumbing.convert_account_to_porcelain(plumbing_item) 1189 if plumbing_response.meta.next_cursor == '': 1190 break 1191 req.meta.cursor = plumbing_response.meta.next_cursor 1192 1193 return generator(self, req)
List gets a list of Accounts matching a given set of criteria.
class
SnapshotAccounts:
1196class SnapshotAccounts: 1197 ''' 1198 SnapshotAccounts exposes the read only methods of the Accounts 1199 service for historical queries. 1200 ''' 1201 def __init__(self, accounts): 1202 self.accounts = accounts 1203 1204 def get(self, id, timeout=None): 1205 ''' 1206 Get reads one Account by ID. 1207 ''' 1208 return self.accounts.get(id, timeout=timeout) 1209 1210 def list(self, filter, *args, timeout=None): 1211 ''' 1212 List gets a list of Accounts matching a given set of criteria. 1213 ''' 1214 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)
1204 def get(self, id, timeout=None): 1205 ''' 1206 Get reads one Account by ID. 1207 ''' 1208 return self.accounts.get(id, timeout=timeout)
Get reads one Account by ID.
def
list(self, filter, *args, timeout=None)
1210 def list(self, filter, *args, timeout=None): 1211 ''' 1212 List gets a list of Accounts matching a given set of criteria. 1213 ''' 1214 return self.accounts.list(filter, *args, timeout=timeout)
List gets a list of Accounts matching a given set of criteria.
class
AccountsGroups:
1217class AccountsGroups: 1218 ''' 1219 An AccountGroup links an account and a group. 1220 See `strongdm.models.AccountGroup`. 1221 ''' 1222 def __init__(self, channel, client): 1223 self.parent = client 1224 self.stub = AccountsGroupsStub(channel) 1225 1226 def create(self, account_group, timeout=None): 1227 ''' 1228 Create create a new AccountGroup. 1229 ''' 1230 deadline = None if timeout is None else time.time() + timeout 1231 req = AccountGroupCreateRequest() 1232 1233 if account_group is not None: 1234 req.account_group.CopyFrom( 1235 plumbing.convert_account_group_to_plumbing(account_group)) 1236 tries = 0 1237 plumbing_response = None 1238 while True: 1239 t = None if deadline is None else deadline - time.time() 1240 try: 1241 plumbing_response = self.stub.Create( 1242 req, 1243 metadata=self.parent.get_metadata('AccountsGroups.Create', 1244 req), 1245 timeout=t) 1246 except Exception as e: 1247 if self.parent.shouldRetry(tries, e, deadline): 1248 tries += 1 1249 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1250 continue 1251 raise plumbing.convert_error_to_porcelain(e) from e 1252 break 1253 1254 resp = models.AccountGroupCreateResponse() 1255 resp.account_group = plumbing.convert_account_group_to_porcelain( 1256 plumbing_response.account_group) 1257 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1258 plumbing_response.rate_limit) 1259 return resp 1260 1261 def get(self, id, timeout=None): 1262 ''' 1263 Get reads one AccountGroup by ID. 1264 ''' 1265 deadline = None if timeout is None else time.time() + timeout 1266 req = AccountGroupGetRequest() 1267 if self.parent.snapshot_datetime is not None: 1268 req.meta.CopyFrom(GetRequestMetadata()) 1269 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1270 1271 req.id = (id) 1272 tries = 0 1273 plumbing_response = None 1274 while True: 1275 t = None if deadline is None else deadline - time.time() 1276 try: 1277 plumbing_response = self.stub.Get( 1278 req, 1279 metadata=self.parent.get_metadata('AccountsGroups.Get', 1280 req), 1281 timeout=t) 1282 except Exception as e: 1283 if self.parent.shouldRetry(tries, e, deadline): 1284 tries += 1 1285 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1286 continue 1287 raise plumbing.convert_error_to_porcelain(e) from e 1288 break 1289 1290 resp = models.AccountGroupGetResponse() 1291 resp.account_group = plumbing.convert_account_group_to_porcelain( 1292 plumbing_response.account_group) 1293 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1294 plumbing_response.meta) 1295 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1296 plumbing_response.rate_limit) 1297 return resp 1298 1299 def delete(self, id, timeout=None): 1300 ''' 1301 Delete removes an AccountGroup by ID. 1302 ''' 1303 deadline = None if timeout is None else time.time() + timeout 1304 req = AccountGroupDeleteRequest() 1305 1306 req.id = (id) 1307 tries = 0 1308 plumbing_response = None 1309 while True: 1310 t = None if deadline is None else deadline - time.time() 1311 try: 1312 plumbing_response = self.stub.Delete( 1313 req, 1314 metadata=self.parent.get_metadata('AccountsGroups.Delete', 1315 req), 1316 timeout=t) 1317 except Exception as e: 1318 if self.parent.shouldRetry(tries, e, deadline): 1319 tries += 1 1320 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1321 continue 1322 raise plumbing.convert_error_to_porcelain(e) from e 1323 break 1324 1325 resp = models.AccountGroupDeleteResponse() 1326 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 1327 plumbing_response.meta) 1328 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1329 plumbing_response.rate_limit) 1330 return resp 1331 1332 def list(self, filter, *args, timeout=None): 1333 ''' 1334 List gets a list of AccountGroups matching a given set of criteria. 1335 ''' 1336 deadline = None if timeout is None else time.time() + timeout 1337 req = AccountGroupListRequest() 1338 req.meta.CopyFrom(ListRequestMetadata()) 1339 if self.parent.page_limit > 0: 1340 req.meta.limit = self.parent.page_limit 1341 if self.parent.snapshot_datetime is not None: 1342 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1343 1344 req.filter = plumbing.quote_filter_args(filter, *args) 1345 1346 def generator(svc, req): 1347 tries = 0 1348 while True: 1349 t = None if deadline is None else deadline - time.time() 1350 try: 1351 plumbing_response = svc.stub.List( 1352 req, 1353 metadata=svc.parent.get_metadata( 1354 'AccountsGroups.List', req), 1355 timeout=t) 1356 except Exception as e: 1357 if self.parent.shouldRetry(tries, e, deadline): 1358 tries += 1 1359 time.sleep( 1360 self.parent.exponentialBackoff(tries, deadline)) 1361 continue 1362 raise plumbing.convert_error_to_porcelain(e) from e 1363 tries = 0 1364 for plumbing_item in plumbing_response.account_groups: 1365 yield plumbing.convert_account_group_to_porcelain( 1366 plumbing_item) 1367 if plumbing_response.meta.next_cursor == '': 1368 break 1369 req.meta.cursor = plumbing_response.meta.next_cursor 1370 1371 return generator(self, req)
An AccountGroup links an account and a group.
See strongdm.models.AccountGroup.
def
create(self, account_group, timeout=None)
1226 def create(self, account_group, timeout=None): 1227 ''' 1228 Create create a new AccountGroup. 1229 ''' 1230 deadline = None if timeout is None else time.time() + timeout 1231 req = AccountGroupCreateRequest() 1232 1233 if account_group is not None: 1234 req.account_group.CopyFrom( 1235 plumbing.convert_account_group_to_plumbing(account_group)) 1236 tries = 0 1237 plumbing_response = None 1238 while True: 1239 t = None if deadline is None else deadline - time.time() 1240 try: 1241 plumbing_response = self.stub.Create( 1242 req, 1243 metadata=self.parent.get_metadata('AccountsGroups.Create', 1244 req), 1245 timeout=t) 1246 except Exception as e: 1247 if self.parent.shouldRetry(tries, e, deadline): 1248 tries += 1 1249 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1250 continue 1251 raise plumbing.convert_error_to_porcelain(e) from e 1252 break 1253 1254 resp = models.AccountGroupCreateResponse() 1255 resp.account_group = plumbing.convert_account_group_to_porcelain( 1256 plumbing_response.account_group) 1257 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1258 plumbing_response.rate_limit) 1259 return resp
Create create a new AccountGroup.
def
get(self, id, timeout=None)
1261 def get(self, id, timeout=None): 1262 ''' 1263 Get reads one AccountGroup by ID. 1264 ''' 1265 deadline = None if timeout is None else time.time() + timeout 1266 req = AccountGroupGetRequest() 1267 if self.parent.snapshot_datetime is not None: 1268 req.meta.CopyFrom(GetRequestMetadata()) 1269 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1270 1271 req.id = (id) 1272 tries = 0 1273 plumbing_response = None 1274 while True: 1275 t = None if deadline is None else deadline - time.time() 1276 try: 1277 plumbing_response = self.stub.Get( 1278 req, 1279 metadata=self.parent.get_metadata('AccountsGroups.Get', 1280 req), 1281 timeout=t) 1282 except Exception as e: 1283 if self.parent.shouldRetry(tries, e, deadline): 1284 tries += 1 1285 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1286 continue 1287 raise plumbing.convert_error_to_porcelain(e) from e 1288 break 1289 1290 resp = models.AccountGroupGetResponse() 1291 resp.account_group = plumbing.convert_account_group_to_porcelain( 1292 plumbing_response.account_group) 1293 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1294 plumbing_response.meta) 1295 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1296 plumbing_response.rate_limit) 1297 return resp
Get reads one AccountGroup by ID.
def
delete(self, id, timeout=None)
1299 def delete(self, id, timeout=None): 1300 ''' 1301 Delete removes an AccountGroup by ID. 1302 ''' 1303 deadline = None if timeout is None else time.time() + timeout 1304 req = AccountGroupDeleteRequest() 1305 1306 req.id = (id) 1307 tries = 0 1308 plumbing_response = None 1309 while True: 1310 t = None if deadline is None else deadline - time.time() 1311 try: 1312 plumbing_response = self.stub.Delete( 1313 req, 1314 metadata=self.parent.get_metadata('AccountsGroups.Delete', 1315 req), 1316 timeout=t) 1317 except Exception as e: 1318 if self.parent.shouldRetry(tries, e, deadline): 1319 tries += 1 1320 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1321 continue 1322 raise plumbing.convert_error_to_porcelain(e) from e 1323 break 1324 1325 resp = models.AccountGroupDeleteResponse() 1326 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 1327 plumbing_response.meta) 1328 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1329 plumbing_response.rate_limit) 1330 return resp
Delete removes an AccountGroup by ID.
def
list(self, filter, *args, timeout=None)
1332 def list(self, filter, *args, timeout=None): 1333 ''' 1334 List gets a list of AccountGroups matching a given set of criteria. 1335 ''' 1336 deadline = None if timeout is None else time.time() + timeout 1337 req = AccountGroupListRequest() 1338 req.meta.CopyFrom(ListRequestMetadata()) 1339 if self.parent.page_limit > 0: 1340 req.meta.limit = self.parent.page_limit 1341 if self.parent.snapshot_datetime is not None: 1342 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1343 1344 req.filter = plumbing.quote_filter_args(filter, *args) 1345 1346 def generator(svc, req): 1347 tries = 0 1348 while True: 1349 t = None if deadline is None else deadline - time.time() 1350 try: 1351 plumbing_response = svc.stub.List( 1352 req, 1353 metadata=svc.parent.get_metadata( 1354 'AccountsGroups.List', req), 1355 timeout=t) 1356 except Exception as e: 1357 if self.parent.shouldRetry(tries, e, deadline): 1358 tries += 1 1359 time.sleep( 1360 self.parent.exponentialBackoff(tries, deadline)) 1361 continue 1362 raise plumbing.convert_error_to_porcelain(e) from e 1363 tries = 0 1364 for plumbing_item in plumbing_response.account_groups: 1365 yield plumbing.convert_account_group_to_porcelain( 1366 plumbing_item) 1367 if plumbing_response.meta.next_cursor == '': 1368 break 1369 req.meta.cursor = plumbing_response.meta.next_cursor 1370 1371 return generator(self, req)
List gets a list of AccountGroups matching a given set of criteria.
class
SnapshotAccountsGroups:
1374class SnapshotAccountsGroups: 1375 ''' 1376 SnapshotAccountsGroups exposes the read only methods of the AccountsGroups 1377 service for historical queries. 1378 ''' 1379 def __init__(self, accounts_groups): 1380 self.accounts_groups = accounts_groups 1381 1382 def get(self, id, timeout=None): 1383 ''' 1384 Get reads one AccountGroup by ID. 1385 ''' 1386 return self.accounts_groups.get(id, timeout=timeout) 1387 1388 def list(self, filter, *args, timeout=None): 1389 ''' 1390 List gets a list of AccountGroups matching a given set of criteria. 1391 ''' 1392 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)
1382 def get(self, id, timeout=None): 1383 ''' 1384 Get reads one AccountGroup by ID. 1385 ''' 1386 return self.accounts_groups.get(id, timeout=timeout)
Get reads one AccountGroup by ID.
def
list(self, filter, *args, timeout=None)
1388 def list(self, filter, *args, timeout=None): 1389 ''' 1390 List gets a list of AccountGroups matching a given set of criteria. 1391 ''' 1392 return self.accounts_groups.list(filter, *args, timeout=timeout)
List gets a list of AccountGroups matching a given set of criteria.
class
AccountsGroupsHistory:
1395class AccountsGroupsHistory: 1396 ''' 1397 AccountsGroupsHistory records all changes to the state of an AccountGroup. 1398 See `strongdm.models.AccountGroupHistory`. 1399 ''' 1400 def __init__(self, channel, client): 1401 self.parent = client 1402 self.stub = AccountsGroupsHistoryStub(channel) 1403 1404 def list(self, filter, *args, timeout=None): 1405 ''' 1406 List gets a list of AccountGroupHistory records matching a given set of criteria. 1407 ''' 1408 deadline = None if timeout is None else time.time() + timeout 1409 req = AccountGroupHistoryListRequest() 1410 req.meta.CopyFrom(ListRequestMetadata()) 1411 if self.parent.page_limit > 0: 1412 req.meta.limit = self.parent.page_limit 1413 if self.parent.snapshot_datetime is not None: 1414 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1415 1416 req.filter = plumbing.quote_filter_args(filter, *args) 1417 1418 def generator(svc, req): 1419 tries = 0 1420 while True: 1421 t = None if deadline is None else deadline - time.time() 1422 try: 1423 plumbing_response = svc.stub.List( 1424 req, 1425 metadata=svc.parent.get_metadata( 1426 'AccountsGroupsHistory.List', req), 1427 timeout=t) 1428 except Exception as e: 1429 if self.parent.shouldRetry(tries, e, deadline): 1430 tries += 1 1431 time.sleep( 1432 self.parent.exponentialBackoff(tries, deadline)) 1433 continue 1434 raise plumbing.convert_error_to_porcelain(e) from e 1435 tries = 0 1436 for plumbing_item in plumbing_response.history: 1437 yield plumbing.convert_account_group_history_to_porcelain( 1438 plumbing_item) 1439 if plumbing_response.meta.next_cursor == '': 1440 break 1441 req.meta.cursor = plumbing_response.meta.next_cursor 1442 1443 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)
1404 def list(self, filter, *args, timeout=None): 1405 ''' 1406 List gets a list of AccountGroupHistory records matching a given set of criteria. 1407 ''' 1408 deadline = None if timeout is None else time.time() + timeout 1409 req = AccountGroupHistoryListRequest() 1410 req.meta.CopyFrom(ListRequestMetadata()) 1411 if self.parent.page_limit > 0: 1412 req.meta.limit = self.parent.page_limit 1413 if self.parent.snapshot_datetime is not None: 1414 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1415 1416 req.filter = plumbing.quote_filter_args(filter, *args) 1417 1418 def generator(svc, req): 1419 tries = 0 1420 while True: 1421 t = None if deadline is None else deadline - time.time() 1422 try: 1423 plumbing_response = svc.stub.List( 1424 req, 1425 metadata=svc.parent.get_metadata( 1426 'AccountsGroupsHistory.List', req), 1427 timeout=t) 1428 except Exception as e: 1429 if self.parent.shouldRetry(tries, e, deadline): 1430 tries += 1 1431 time.sleep( 1432 self.parent.exponentialBackoff(tries, deadline)) 1433 continue 1434 raise plumbing.convert_error_to_porcelain(e) from e 1435 tries = 0 1436 for plumbing_item in plumbing_response.history: 1437 yield plumbing.convert_account_group_history_to_porcelain( 1438 plumbing_item) 1439 if plumbing_response.meta.next_cursor == '': 1440 break 1441 req.meta.cursor = plumbing_response.meta.next_cursor 1442 1443 return generator(self, req)
List gets a list of AccountGroupHistory records matching a given set of criteria.
class
AccountsHistory:
1446class AccountsHistory: 1447 ''' 1448 AccountsHistory records all changes to the state of an Account. 1449 See `strongdm.models.AccountHistory`. 1450 ''' 1451 def __init__(self, channel, client): 1452 self.parent = client 1453 self.stub = AccountsHistoryStub(channel) 1454 1455 def list(self, filter, *args, timeout=None): 1456 ''' 1457 List gets a list of AccountHistory records matching a given set of criteria. 1458 ''' 1459 deadline = None if timeout is None else time.time() + timeout 1460 req = AccountHistoryListRequest() 1461 req.meta.CopyFrom(ListRequestMetadata()) 1462 if self.parent.page_limit > 0: 1463 req.meta.limit = self.parent.page_limit 1464 if self.parent.snapshot_datetime is not None: 1465 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1466 1467 req.filter = plumbing.quote_filter_args(filter, *args) 1468 1469 def generator(svc, req): 1470 tries = 0 1471 while True: 1472 t = None if deadline is None else deadline - time.time() 1473 try: 1474 plumbing_response = svc.stub.List( 1475 req, 1476 metadata=svc.parent.get_metadata( 1477 'AccountsHistory.List', req), 1478 timeout=t) 1479 except Exception as e: 1480 if self.parent.shouldRetry(tries, e, deadline): 1481 tries += 1 1482 time.sleep( 1483 self.parent.exponentialBackoff(tries, deadline)) 1484 continue 1485 raise plumbing.convert_error_to_porcelain(e) from e 1486 tries = 0 1487 for plumbing_item in plumbing_response.history: 1488 yield plumbing.convert_account_history_to_porcelain( 1489 plumbing_item) 1490 if plumbing_response.meta.next_cursor == '': 1491 break 1492 req.meta.cursor = plumbing_response.meta.next_cursor 1493 1494 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)
1455 def list(self, filter, *args, timeout=None): 1456 ''' 1457 List gets a list of AccountHistory records matching a given set of criteria. 1458 ''' 1459 deadline = None if timeout is None else time.time() + timeout 1460 req = AccountHistoryListRequest() 1461 req.meta.CopyFrom(ListRequestMetadata()) 1462 if self.parent.page_limit > 0: 1463 req.meta.limit = self.parent.page_limit 1464 if self.parent.snapshot_datetime is not None: 1465 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1466 1467 req.filter = plumbing.quote_filter_args(filter, *args) 1468 1469 def generator(svc, req): 1470 tries = 0 1471 while True: 1472 t = None if deadline is None else deadline - time.time() 1473 try: 1474 plumbing_response = svc.stub.List( 1475 req, 1476 metadata=svc.parent.get_metadata( 1477 'AccountsHistory.List', req), 1478 timeout=t) 1479 except Exception as e: 1480 if self.parent.shouldRetry(tries, e, deadline): 1481 tries += 1 1482 time.sleep( 1483 self.parent.exponentialBackoff(tries, deadline)) 1484 continue 1485 raise plumbing.convert_error_to_porcelain(e) from e 1486 tries = 0 1487 for plumbing_item in plumbing_response.history: 1488 yield plumbing.convert_account_history_to_porcelain( 1489 plumbing_item) 1490 if plumbing_response.meta.next_cursor == '': 1491 break 1492 req.meta.cursor = plumbing_response.meta.next_cursor 1493 1494 return generator(self, req)
List gets a list of AccountHistory records matching a given set of criteria.
class
Activities:
1497class Activities: 1498 ''' 1499 An Activity is a record of an action taken against a strongDM deployment, e.g. 1500 a user creation, resource deletion, sso configuration change, etc. The Activities 1501 service is read-only. 1502 See `strongdm.models.Activity`. 1503 ''' 1504 def __init__(self, channel, client): 1505 self.parent = client 1506 self.stub = ActivitiesStub(channel) 1507 1508 def get(self, id, timeout=None): 1509 ''' 1510 Get reads one Activity by ID. 1511 ''' 1512 deadline = None if timeout is None else time.time() + timeout 1513 req = ActivityGetRequest() 1514 if self.parent.snapshot_datetime is not None: 1515 req.meta.CopyFrom(GetRequestMetadata()) 1516 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1517 1518 req.id = (id) 1519 tries = 0 1520 plumbing_response = None 1521 while True: 1522 t = None if deadline is None else deadline - time.time() 1523 try: 1524 plumbing_response = self.stub.Get( 1525 req, 1526 metadata=self.parent.get_metadata('Activities.Get', req), 1527 timeout=t) 1528 except Exception as e: 1529 if self.parent.shouldRetry(tries, e, deadline): 1530 tries += 1 1531 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1532 continue 1533 raise plumbing.convert_error_to_porcelain(e) from e 1534 break 1535 1536 resp = models.ActivityGetResponse() 1537 resp.activity = plumbing.convert_activity_to_porcelain( 1538 plumbing_response.activity) 1539 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1540 plumbing_response.meta) 1541 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1542 plumbing_response.rate_limit) 1543 return resp 1544 1545 def list(self, filter, *args, timeout=None): 1546 ''' 1547 List gets a list of Activities matching a given set of criteria. 1548 The 'before' and 'after' filters can be used to control the time 1549 range of the output activities. If not provided, one week of back 1550 of activities will be returned. 1551 ''' 1552 deadline = None if timeout is None else time.time() + timeout 1553 req = ActivityListRequest() 1554 req.meta.CopyFrom(ListRequestMetadata()) 1555 if self.parent.page_limit > 0: 1556 req.meta.limit = self.parent.page_limit 1557 if self.parent.snapshot_datetime is not None: 1558 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1559 1560 req.filter = plumbing.quote_filter_args(filter, *args) 1561 1562 def generator(svc, req): 1563 tries = 0 1564 while True: 1565 t = None if deadline is None else deadline - time.time() 1566 try: 1567 plumbing_response = svc.stub.List( 1568 req, 1569 metadata=svc.parent.get_metadata( 1570 'Activities.List', req), 1571 timeout=t) 1572 except Exception as e: 1573 if self.parent.shouldRetry(tries, e, deadline): 1574 tries += 1 1575 time.sleep( 1576 self.parent.exponentialBackoff(tries, deadline)) 1577 continue 1578 raise plumbing.convert_error_to_porcelain(e) from e 1579 tries = 0 1580 for plumbing_item in plumbing_response.activities: 1581 yield plumbing.convert_activity_to_porcelain(plumbing_item) 1582 if plumbing_response.meta.next_cursor == '': 1583 break 1584 req.meta.cursor = plumbing_response.meta.next_cursor 1585 1586 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)
1508 def get(self, id, timeout=None): 1509 ''' 1510 Get reads one Activity by ID. 1511 ''' 1512 deadline = None if timeout is None else time.time() + timeout 1513 req = ActivityGetRequest() 1514 if self.parent.snapshot_datetime is not None: 1515 req.meta.CopyFrom(GetRequestMetadata()) 1516 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1517 1518 req.id = (id) 1519 tries = 0 1520 plumbing_response = None 1521 while True: 1522 t = None if deadline is None else deadline - time.time() 1523 try: 1524 plumbing_response = self.stub.Get( 1525 req, 1526 metadata=self.parent.get_metadata('Activities.Get', req), 1527 timeout=t) 1528 except Exception as e: 1529 if self.parent.shouldRetry(tries, e, deadline): 1530 tries += 1 1531 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1532 continue 1533 raise plumbing.convert_error_to_porcelain(e) from e 1534 break 1535 1536 resp = models.ActivityGetResponse() 1537 resp.activity = plumbing.convert_activity_to_porcelain( 1538 plumbing_response.activity) 1539 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1540 plumbing_response.meta) 1541 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1542 plumbing_response.rate_limit) 1543 return resp
Get reads one Activity by ID.
def
list(self, filter, *args, timeout=None)
1545 def list(self, filter, *args, timeout=None): 1546 ''' 1547 List gets a list of Activities matching a given set of criteria. 1548 The 'before' and 'after' filters can be used to control the time 1549 range of the output activities. If not provided, one week of back 1550 of activities will be returned. 1551 ''' 1552 deadline = None if timeout is None else time.time() + timeout 1553 req = ActivityListRequest() 1554 req.meta.CopyFrom(ListRequestMetadata()) 1555 if self.parent.page_limit > 0: 1556 req.meta.limit = self.parent.page_limit 1557 if self.parent.snapshot_datetime is not None: 1558 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1559 1560 req.filter = plumbing.quote_filter_args(filter, *args) 1561 1562 def generator(svc, req): 1563 tries = 0 1564 while True: 1565 t = None if deadline is None else deadline - time.time() 1566 try: 1567 plumbing_response = svc.stub.List( 1568 req, 1569 metadata=svc.parent.get_metadata( 1570 'Activities.List', req), 1571 timeout=t) 1572 except Exception as e: 1573 if self.parent.shouldRetry(tries, e, deadline): 1574 tries += 1 1575 time.sleep( 1576 self.parent.exponentialBackoff(tries, deadline)) 1577 continue 1578 raise plumbing.convert_error_to_porcelain(e) from e 1579 tries = 0 1580 for plumbing_item in plumbing_response.activities: 1581 yield plumbing.convert_activity_to_porcelain(plumbing_item) 1582 if plumbing_response.meta.next_cursor == '': 1583 break 1584 req.meta.cursor = plumbing_response.meta.next_cursor 1585 1586 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:
1589class ApprovalWorkflowApprovers: 1590 ''' 1591 ApprovalWorkflowApprovers link approval workflow approvers to an ApprovalWorkflowStep 1592 See `strongdm.models.ApprovalWorkflowApprover`. 1593 ''' 1594 def __init__(self, channel, client): 1595 self.parent = client 1596 self.stub = ApprovalWorkflowApproversStub(channel) 1597 1598 def create(self, approval_workflow_approver, timeout=None): 1599 ''' 1600 Deprecated: Create creates a new approval workflow approver. 1601 ''' 1602 deadline = None if timeout is None else time.time() + timeout 1603 req = ApprovalWorkflowApproverCreateRequest() 1604 1605 if approval_workflow_approver is not None: 1606 req.approval_workflow_approver.CopyFrom( 1607 plumbing.convert_approval_workflow_approver_to_plumbing( 1608 approval_workflow_approver)) 1609 tries = 0 1610 plumbing_response = None 1611 while True: 1612 t = None if deadline is None else deadline - time.time() 1613 try: 1614 plumbing_response = self.stub.Create( 1615 req, 1616 metadata=self.parent.get_metadata( 1617 'ApprovalWorkflowApprovers.Create', req), 1618 timeout=t) 1619 except Exception as e: 1620 if self.parent.shouldRetry(tries, e, deadline): 1621 tries += 1 1622 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1623 continue 1624 raise plumbing.convert_error_to_porcelain(e) from e 1625 break 1626 1627 resp = models.ApprovalWorkflowApproverCreateResponse() 1628 resp.approval_workflow_approver = plumbing.convert_approval_workflow_approver_to_porcelain( 1629 plumbing_response.approval_workflow_approver) 1630 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1631 plumbing_response.rate_limit) 1632 return resp 1633 1634 def get(self, id, timeout=None): 1635 ''' 1636 Deprecated: Get reads one approval workflow approver by ID. 1637 ''' 1638 deadline = None if timeout is None else time.time() + timeout 1639 req = ApprovalWorkflowApproverGetRequest() 1640 if self.parent.snapshot_datetime is not None: 1641 req.meta.CopyFrom(GetRequestMetadata()) 1642 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1643 1644 req.id = (id) 1645 tries = 0 1646 plumbing_response = None 1647 while True: 1648 t = None if deadline is None else deadline - time.time() 1649 try: 1650 plumbing_response = self.stub.Get( 1651 req, 1652 metadata=self.parent.get_metadata( 1653 'ApprovalWorkflowApprovers.Get', req), 1654 timeout=t) 1655 except Exception as e: 1656 if self.parent.shouldRetry(tries, e, deadline): 1657 tries += 1 1658 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1659 continue 1660 raise plumbing.convert_error_to_porcelain(e) from e 1661 break 1662 1663 resp = models.ApprovalWorkflowApproverGetResponse() 1664 resp.approval_workflow_approver = plumbing.convert_approval_workflow_approver_to_porcelain( 1665 plumbing_response.approval_workflow_approver) 1666 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1667 plumbing_response.meta) 1668 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1669 plumbing_response.rate_limit) 1670 return resp 1671 1672 def delete(self, id, timeout=None): 1673 ''' 1674 Deprecated: Delete deletes an existing approval workflow approver. 1675 ''' 1676 deadline = None if timeout is None else time.time() + timeout 1677 req = ApprovalWorkflowApproverDeleteRequest() 1678 1679 req.id = (id) 1680 tries = 0 1681 plumbing_response = None 1682 while True: 1683 t = None if deadline is None else deadline - time.time() 1684 try: 1685 plumbing_response = self.stub.Delete( 1686 req, 1687 metadata=self.parent.get_metadata( 1688 'ApprovalWorkflowApprovers.Delete', req), 1689 timeout=t) 1690 except Exception as e: 1691 if self.parent.shouldRetry(tries, e, deadline): 1692 tries += 1 1693 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1694 continue 1695 raise plumbing.convert_error_to_porcelain(e) from e 1696 break 1697 1698 resp = models.ApprovalWorkflowApproverDeleteResponse() 1699 resp.id = (plumbing_response.id) 1700 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1701 plumbing_response.rate_limit) 1702 return resp 1703 1704 def list(self, filter, *args, timeout=None): 1705 ''' 1706 Deprecated: Lists existing approval workflow approvers. 1707 ''' 1708 deadline = None if timeout is None else time.time() + timeout 1709 req = ApprovalWorkflowApproverListRequest() 1710 req.meta.CopyFrom(ListRequestMetadata()) 1711 if self.parent.page_limit > 0: 1712 req.meta.limit = self.parent.page_limit 1713 if self.parent.snapshot_datetime is not None: 1714 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1715 1716 req.filter = plumbing.quote_filter_args(filter, *args) 1717 1718 def generator(svc, req): 1719 tries = 0 1720 while True: 1721 t = None if deadline is None else deadline - time.time() 1722 try: 1723 plumbing_response = svc.stub.List( 1724 req, 1725 metadata=svc.parent.get_metadata( 1726 'ApprovalWorkflowApprovers.List', req), 1727 timeout=t) 1728 except Exception as e: 1729 if self.parent.shouldRetry(tries, e, deadline): 1730 tries += 1 1731 time.sleep( 1732 self.parent.exponentialBackoff(tries, deadline)) 1733 continue 1734 raise plumbing.convert_error_to_porcelain(e) from e 1735 tries = 0 1736 for plumbing_item in plumbing_response.approval_workflow_approvers: 1737 yield plumbing.convert_approval_workflow_approver_to_porcelain( 1738 plumbing_item) 1739 if plumbing_response.meta.next_cursor == '': 1740 break 1741 req.meta.cursor = plumbing_response.meta.next_cursor 1742 1743 return generator(self, req)
ApprovalWorkflowApprovers link approval workflow approvers to an ApprovalWorkflowStep
See strongdm.models.ApprovalWorkflowApprover.
def
create(self, approval_workflow_approver, timeout=None)
1598 def create(self, approval_workflow_approver, timeout=None): 1599 ''' 1600 Deprecated: Create creates a new approval workflow approver. 1601 ''' 1602 deadline = None if timeout is None else time.time() + timeout 1603 req = ApprovalWorkflowApproverCreateRequest() 1604 1605 if approval_workflow_approver is not None: 1606 req.approval_workflow_approver.CopyFrom( 1607 plumbing.convert_approval_workflow_approver_to_plumbing( 1608 approval_workflow_approver)) 1609 tries = 0 1610 plumbing_response = None 1611 while True: 1612 t = None if deadline is None else deadline - time.time() 1613 try: 1614 plumbing_response = self.stub.Create( 1615 req, 1616 metadata=self.parent.get_metadata( 1617 'ApprovalWorkflowApprovers.Create', req), 1618 timeout=t) 1619 except Exception as e: 1620 if self.parent.shouldRetry(tries, e, deadline): 1621 tries += 1 1622 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1623 continue 1624 raise plumbing.convert_error_to_porcelain(e) from e 1625 break 1626 1627 resp = models.ApprovalWorkflowApproverCreateResponse() 1628 resp.approval_workflow_approver = plumbing.convert_approval_workflow_approver_to_porcelain( 1629 plumbing_response.approval_workflow_approver) 1630 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1631 plumbing_response.rate_limit) 1632 return resp
Deprecated: Create creates a new approval workflow approver.
def
get(self, id, timeout=None)
1634 def get(self, id, timeout=None): 1635 ''' 1636 Deprecated: Get reads one approval workflow approver by ID. 1637 ''' 1638 deadline = None if timeout is None else time.time() + timeout 1639 req = ApprovalWorkflowApproverGetRequest() 1640 if self.parent.snapshot_datetime is not None: 1641 req.meta.CopyFrom(GetRequestMetadata()) 1642 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1643 1644 req.id = (id) 1645 tries = 0 1646 plumbing_response = None 1647 while True: 1648 t = None if deadline is None else deadline - time.time() 1649 try: 1650 plumbing_response = self.stub.Get( 1651 req, 1652 metadata=self.parent.get_metadata( 1653 'ApprovalWorkflowApprovers.Get', req), 1654 timeout=t) 1655 except Exception as e: 1656 if self.parent.shouldRetry(tries, e, deadline): 1657 tries += 1 1658 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1659 continue 1660 raise plumbing.convert_error_to_porcelain(e) from e 1661 break 1662 1663 resp = models.ApprovalWorkflowApproverGetResponse() 1664 resp.approval_workflow_approver = plumbing.convert_approval_workflow_approver_to_porcelain( 1665 plumbing_response.approval_workflow_approver) 1666 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1667 plumbing_response.meta) 1668 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1669 plumbing_response.rate_limit) 1670 return resp
Deprecated: Get reads one approval workflow approver by ID.
def
delete(self, id, timeout=None)
1672 def delete(self, id, timeout=None): 1673 ''' 1674 Deprecated: Delete deletes an existing approval workflow approver. 1675 ''' 1676 deadline = None if timeout is None else time.time() + timeout 1677 req = ApprovalWorkflowApproverDeleteRequest() 1678 1679 req.id = (id) 1680 tries = 0 1681 plumbing_response = None 1682 while True: 1683 t = None if deadline is None else deadline - time.time() 1684 try: 1685 plumbing_response = self.stub.Delete( 1686 req, 1687 metadata=self.parent.get_metadata( 1688 'ApprovalWorkflowApprovers.Delete', req), 1689 timeout=t) 1690 except Exception as e: 1691 if self.parent.shouldRetry(tries, e, deadline): 1692 tries += 1 1693 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1694 continue 1695 raise plumbing.convert_error_to_porcelain(e) from e 1696 break 1697 1698 resp = models.ApprovalWorkflowApproverDeleteResponse() 1699 resp.id = (plumbing_response.id) 1700 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1701 plumbing_response.rate_limit) 1702 return resp
Deprecated: Delete deletes an existing approval workflow approver.
def
list(self, filter, *args, timeout=None)
1704 def list(self, filter, *args, timeout=None): 1705 ''' 1706 Deprecated: Lists existing approval workflow approvers. 1707 ''' 1708 deadline = None if timeout is None else time.time() + timeout 1709 req = ApprovalWorkflowApproverListRequest() 1710 req.meta.CopyFrom(ListRequestMetadata()) 1711 if self.parent.page_limit > 0: 1712 req.meta.limit = self.parent.page_limit 1713 if self.parent.snapshot_datetime is not None: 1714 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1715 1716 req.filter = plumbing.quote_filter_args(filter, *args) 1717 1718 def generator(svc, req): 1719 tries = 0 1720 while True: 1721 t = None if deadline is None else deadline - time.time() 1722 try: 1723 plumbing_response = svc.stub.List( 1724 req, 1725 metadata=svc.parent.get_metadata( 1726 'ApprovalWorkflowApprovers.List', req), 1727 timeout=t) 1728 except Exception as e: 1729 if self.parent.shouldRetry(tries, e, deadline): 1730 tries += 1 1731 time.sleep( 1732 self.parent.exponentialBackoff(tries, deadline)) 1733 continue 1734 raise plumbing.convert_error_to_porcelain(e) from e 1735 tries = 0 1736 for plumbing_item in plumbing_response.approval_workflow_approvers: 1737 yield plumbing.convert_approval_workflow_approver_to_porcelain( 1738 plumbing_item) 1739 if plumbing_response.meta.next_cursor == '': 1740 break 1741 req.meta.cursor = plumbing_response.meta.next_cursor 1742 1743 return generator(self, req)
Deprecated: Lists existing approval workflow approvers.
class
SnapshotApprovalWorkflowApprovers:
1746class SnapshotApprovalWorkflowApprovers: 1747 ''' 1748 SnapshotApprovalWorkflowApprovers exposes the read only methods of the ApprovalWorkflowApprovers 1749 service for historical queries. 1750 ''' 1751 def __init__(self, approval_workflow_approvers): 1752 self.approval_workflow_approvers = approval_workflow_approvers 1753 1754 def get(self, id, timeout=None): 1755 ''' 1756 Deprecated: Get reads one approval workflow approver by ID. 1757 ''' 1758 return self.approval_workflow_approvers.get(id, timeout=timeout) 1759 1760 def list(self, filter, *args, timeout=None): 1761 ''' 1762 Deprecated: Lists existing approval workflow approvers. 1763 ''' 1764 return self.approval_workflow_approvers.list(filter, 1765 *args, 1766 timeout=timeout)
SnapshotApprovalWorkflowApprovers exposes the read only methods of the ApprovalWorkflowApprovers service for historical queries.
def
get(self, id, timeout=None)
1754 def get(self, id, timeout=None): 1755 ''' 1756 Deprecated: Get reads one approval workflow approver by ID. 1757 ''' 1758 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)
1760 def list(self, filter, *args, timeout=None): 1761 ''' 1762 Deprecated: Lists existing approval workflow approvers. 1763 ''' 1764 return self.approval_workflow_approvers.list(filter, 1765 *args, 1766 timeout=timeout)
Deprecated: Lists existing approval workflow approvers.
class
ApprovalWorkflowApproversHistory:
1769class ApprovalWorkflowApproversHistory: 1770 ''' 1771 ApprovalWorkflowApproversHistory records all changes to the state of an ApprovalWorkflowApprover. 1772 See `strongdm.models.ApprovalWorkflowApproverHistory`. 1773 ''' 1774 def __init__(self, channel, client): 1775 self.parent = client 1776 self.stub = ApprovalWorkflowApproversHistoryStub(channel) 1777 1778 def list(self, filter, *args, timeout=None): 1779 ''' 1780 List gets a list of ApprovalWorkflowApproverHistory records matching a given set of criteria. 1781 ''' 1782 deadline = None if timeout is None else time.time() + timeout 1783 req = ApprovalWorkflowApproverHistoryListRequest() 1784 req.meta.CopyFrom(ListRequestMetadata()) 1785 if self.parent.page_limit > 0: 1786 req.meta.limit = self.parent.page_limit 1787 if self.parent.snapshot_datetime is not None: 1788 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1789 1790 req.filter = plumbing.quote_filter_args(filter, *args) 1791 1792 def generator(svc, req): 1793 tries = 0 1794 while True: 1795 t = None if deadline is None else deadline - time.time() 1796 try: 1797 plumbing_response = svc.stub.List( 1798 req, 1799 metadata=svc.parent.get_metadata( 1800 'ApprovalWorkflowApproversHistory.List', req), 1801 timeout=t) 1802 except Exception as e: 1803 if self.parent.shouldRetry(tries, e, deadline): 1804 tries += 1 1805 time.sleep( 1806 self.parent.exponentialBackoff(tries, deadline)) 1807 continue 1808 raise plumbing.convert_error_to_porcelain(e) from e 1809 tries = 0 1810 for plumbing_item in plumbing_response.history: 1811 yield plumbing.convert_approval_workflow_approver_history_to_porcelain( 1812 plumbing_item) 1813 if plumbing_response.meta.next_cursor == '': 1814 break 1815 req.meta.cursor = plumbing_response.meta.next_cursor 1816 1817 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)
1778 def list(self, filter, *args, timeout=None): 1779 ''' 1780 List gets a list of ApprovalWorkflowApproverHistory records matching a given set of criteria. 1781 ''' 1782 deadline = None if timeout is None else time.time() + timeout 1783 req = ApprovalWorkflowApproverHistoryListRequest() 1784 req.meta.CopyFrom(ListRequestMetadata()) 1785 if self.parent.page_limit > 0: 1786 req.meta.limit = self.parent.page_limit 1787 if self.parent.snapshot_datetime is not None: 1788 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1789 1790 req.filter = plumbing.quote_filter_args(filter, *args) 1791 1792 def generator(svc, req): 1793 tries = 0 1794 while True: 1795 t = None if deadline is None else deadline - time.time() 1796 try: 1797 plumbing_response = svc.stub.List( 1798 req, 1799 metadata=svc.parent.get_metadata( 1800 'ApprovalWorkflowApproversHistory.List', req), 1801 timeout=t) 1802 except Exception as e: 1803 if self.parent.shouldRetry(tries, e, deadline): 1804 tries += 1 1805 time.sleep( 1806 self.parent.exponentialBackoff(tries, deadline)) 1807 continue 1808 raise plumbing.convert_error_to_porcelain(e) from e 1809 tries = 0 1810 for plumbing_item in plumbing_response.history: 1811 yield plumbing.convert_approval_workflow_approver_history_to_porcelain( 1812 plumbing_item) 1813 if plumbing_response.meta.next_cursor == '': 1814 break 1815 req.meta.cursor = plumbing_response.meta.next_cursor 1816 1817 return generator(self, req)
List gets a list of ApprovalWorkflowApproverHistory records matching a given set of criteria.
class
ApprovalWorkflowSteps:
1820class ApprovalWorkflowSteps: 1821 ''' 1822 ApprovalWorkflowSteps link approval workflow steps to an ApprovalWorkflow 1823 See `strongdm.models.ApprovalWorkflowStep`. 1824 ''' 1825 def __init__(self, channel, client): 1826 self.parent = client 1827 self.stub = ApprovalWorkflowStepsStub(channel) 1828 1829 def create(self, approval_workflow_step, timeout=None): 1830 ''' 1831 Deprecated: Create creates a new approval workflow step. 1832 ''' 1833 deadline = None if timeout is None else time.time() + timeout 1834 req = ApprovalWorkflowStepCreateRequest() 1835 1836 if approval_workflow_step is not None: 1837 req.approval_workflow_step.CopyFrom( 1838 plumbing.convert_approval_workflow_step_to_plumbing( 1839 approval_workflow_step)) 1840 tries = 0 1841 plumbing_response = None 1842 while True: 1843 t = None if deadline is None else deadline - time.time() 1844 try: 1845 plumbing_response = self.stub.Create( 1846 req, 1847 metadata=self.parent.get_metadata( 1848 'ApprovalWorkflowSteps.Create', req), 1849 timeout=t) 1850 except Exception as e: 1851 if self.parent.shouldRetry(tries, e, deadline): 1852 tries += 1 1853 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1854 continue 1855 raise plumbing.convert_error_to_porcelain(e) from e 1856 break 1857 1858 resp = models.ApprovalWorkflowStepCreateResponse() 1859 resp.approval_workflow_step = plumbing.convert_approval_workflow_step_to_porcelain( 1860 plumbing_response.approval_workflow_step) 1861 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1862 plumbing_response.rate_limit) 1863 return resp 1864 1865 def get(self, id, timeout=None): 1866 ''' 1867 Deprecated: Get reads one approval workflow step by ID. 1868 ''' 1869 deadline = None if timeout is None else time.time() + timeout 1870 req = ApprovalWorkflowStepGetRequest() 1871 if self.parent.snapshot_datetime is not None: 1872 req.meta.CopyFrom(GetRequestMetadata()) 1873 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1874 1875 req.id = (id) 1876 tries = 0 1877 plumbing_response = None 1878 while True: 1879 t = None if deadline is None else deadline - time.time() 1880 try: 1881 plumbing_response = self.stub.Get( 1882 req, 1883 metadata=self.parent.get_metadata( 1884 'ApprovalWorkflowSteps.Get', req), 1885 timeout=t) 1886 except Exception as e: 1887 if self.parent.shouldRetry(tries, e, deadline): 1888 tries += 1 1889 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1890 continue 1891 raise plumbing.convert_error_to_porcelain(e) from e 1892 break 1893 1894 resp = models.ApprovalWorkflowStepGetResponse() 1895 resp.approval_workflow_step = plumbing.convert_approval_workflow_step_to_porcelain( 1896 plumbing_response.approval_workflow_step) 1897 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1898 plumbing_response.meta) 1899 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1900 plumbing_response.rate_limit) 1901 return resp 1902 1903 def delete(self, id, timeout=None): 1904 ''' 1905 Deprecated: Delete deletes an existing approval workflow step. 1906 ''' 1907 deadline = None if timeout is None else time.time() + timeout 1908 req = ApprovalWorkflowStepDeleteRequest() 1909 1910 req.id = (id) 1911 tries = 0 1912 plumbing_response = None 1913 while True: 1914 t = None if deadline is None else deadline - time.time() 1915 try: 1916 plumbing_response = self.stub.Delete( 1917 req, 1918 metadata=self.parent.get_metadata( 1919 'ApprovalWorkflowSteps.Delete', req), 1920 timeout=t) 1921 except Exception as e: 1922 if self.parent.shouldRetry(tries, e, deadline): 1923 tries += 1 1924 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1925 continue 1926 raise plumbing.convert_error_to_porcelain(e) from e 1927 break 1928 1929 resp = models.ApprovalWorkflowStepDeleteResponse() 1930 resp.id = (plumbing_response.id) 1931 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1932 plumbing_response.rate_limit) 1933 return resp 1934 1935 def list(self, filter, *args, timeout=None): 1936 ''' 1937 Deprecated: Lists existing approval workflow steps. 1938 ''' 1939 deadline = None if timeout is None else time.time() + timeout 1940 req = ApprovalWorkflowStepListRequest() 1941 req.meta.CopyFrom(ListRequestMetadata()) 1942 if self.parent.page_limit > 0: 1943 req.meta.limit = self.parent.page_limit 1944 if self.parent.snapshot_datetime is not None: 1945 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1946 1947 req.filter = plumbing.quote_filter_args(filter, *args) 1948 1949 def generator(svc, req): 1950 tries = 0 1951 while True: 1952 t = None if deadline is None else deadline - time.time() 1953 try: 1954 plumbing_response = svc.stub.List( 1955 req, 1956 metadata=svc.parent.get_metadata( 1957 'ApprovalWorkflowSteps.List', req), 1958 timeout=t) 1959 except Exception as e: 1960 if self.parent.shouldRetry(tries, e, deadline): 1961 tries += 1 1962 time.sleep( 1963 self.parent.exponentialBackoff(tries, deadline)) 1964 continue 1965 raise plumbing.convert_error_to_porcelain(e) from e 1966 tries = 0 1967 for plumbing_item in plumbing_response.approval_workflow_steps: 1968 yield plumbing.convert_approval_workflow_step_to_porcelain( 1969 plumbing_item) 1970 if plumbing_response.meta.next_cursor == '': 1971 break 1972 req.meta.cursor = plumbing_response.meta.next_cursor 1973 1974 return generator(self, req)
ApprovalWorkflowSteps link approval workflow steps to an ApprovalWorkflow
See strongdm.models.ApprovalWorkflowStep.
def
create(self, approval_workflow_step, timeout=None)
1829 def create(self, approval_workflow_step, timeout=None): 1830 ''' 1831 Deprecated: Create creates a new approval workflow step. 1832 ''' 1833 deadline = None if timeout is None else time.time() + timeout 1834 req = ApprovalWorkflowStepCreateRequest() 1835 1836 if approval_workflow_step is not None: 1837 req.approval_workflow_step.CopyFrom( 1838 plumbing.convert_approval_workflow_step_to_plumbing( 1839 approval_workflow_step)) 1840 tries = 0 1841 plumbing_response = None 1842 while True: 1843 t = None if deadline is None else deadline - time.time() 1844 try: 1845 plumbing_response = self.stub.Create( 1846 req, 1847 metadata=self.parent.get_metadata( 1848 'ApprovalWorkflowSteps.Create', req), 1849 timeout=t) 1850 except Exception as e: 1851 if self.parent.shouldRetry(tries, e, deadline): 1852 tries += 1 1853 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1854 continue 1855 raise plumbing.convert_error_to_porcelain(e) from e 1856 break 1857 1858 resp = models.ApprovalWorkflowStepCreateResponse() 1859 resp.approval_workflow_step = plumbing.convert_approval_workflow_step_to_porcelain( 1860 plumbing_response.approval_workflow_step) 1861 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1862 plumbing_response.rate_limit) 1863 return resp
Deprecated: Create creates a new approval workflow step.
def
get(self, id, timeout=None)
1865 def get(self, id, timeout=None): 1866 ''' 1867 Deprecated: Get reads one approval workflow step by ID. 1868 ''' 1869 deadline = None if timeout is None else time.time() + timeout 1870 req = ApprovalWorkflowStepGetRequest() 1871 if self.parent.snapshot_datetime is not None: 1872 req.meta.CopyFrom(GetRequestMetadata()) 1873 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1874 1875 req.id = (id) 1876 tries = 0 1877 plumbing_response = None 1878 while True: 1879 t = None if deadline is None else deadline - time.time() 1880 try: 1881 plumbing_response = self.stub.Get( 1882 req, 1883 metadata=self.parent.get_metadata( 1884 'ApprovalWorkflowSteps.Get', req), 1885 timeout=t) 1886 except Exception as e: 1887 if self.parent.shouldRetry(tries, e, deadline): 1888 tries += 1 1889 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1890 continue 1891 raise plumbing.convert_error_to_porcelain(e) from e 1892 break 1893 1894 resp = models.ApprovalWorkflowStepGetResponse() 1895 resp.approval_workflow_step = plumbing.convert_approval_workflow_step_to_porcelain( 1896 plumbing_response.approval_workflow_step) 1897 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 1898 plumbing_response.meta) 1899 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1900 plumbing_response.rate_limit) 1901 return resp
Deprecated: Get reads one approval workflow step by ID.
def
delete(self, id, timeout=None)
1903 def delete(self, id, timeout=None): 1904 ''' 1905 Deprecated: Delete deletes an existing approval workflow step. 1906 ''' 1907 deadline = None if timeout is None else time.time() + timeout 1908 req = ApprovalWorkflowStepDeleteRequest() 1909 1910 req.id = (id) 1911 tries = 0 1912 plumbing_response = None 1913 while True: 1914 t = None if deadline is None else deadline - time.time() 1915 try: 1916 plumbing_response = self.stub.Delete( 1917 req, 1918 metadata=self.parent.get_metadata( 1919 'ApprovalWorkflowSteps.Delete', req), 1920 timeout=t) 1921 except Exception as e: 1922 if self.parent.shouldRetry(tries, e, deadline): 1923 tries += 1 1924 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 1925 continue 1926 raise plumbing.convert_error_to_porcelain(e) from e 1927 break 1928 1929 resp = models.ApprovalWorkflowStepDeleteResponse() 1930 resp.id = (plumbing_response.id) 1931 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 1932 plumbing_response.rate_limit) 1933 return resp
Deprecated: Delete deletes an existing approval workflow step.
def
list(self, filter, *args, timeout=None)
1935 def list(self, filter, *args, timeout=None): 1936 ''' 1937 Deprecated: Lists existing approval workflow steps. 1938 ''' 1939 deadline = None if timeout is None else time.time() + timeout 1940 req = ApprovalWorkflowStepListRequest() 1941 req.meta.CopyFrom(ListRequestMetadata()) 1942 if self.parent.page_limit > 0: 1943 req.meta.limit = self.parent.page_limit 1944 if self.parent.snapshot_datetime is not None: 1945 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 1946 1947 req.filter = plumbing.quote_filter_args(filter, *args) 1948 1949 def generator(svc, req): 1950 tries = 0 1951 while True: 1952 t = None if deadline is None else deadline - time.time() 1953 try: 1954 plumbing_response = svc.stub.List( 1955 req, 1956 metadata=svc.parent.get_metadata( 1957 'ApprovalWorkflowSteps.List', req), 1958 timeout=t) 1959 except Exception as e: 1960 if self.parent.shouldRetry(tries, e, deadline): 1961 tries += 1 1962 time.sleep( 1963 self.parent.exponentialBackoff(tries, deadline)) 1964 continue 1965 raise plumbing.convert_error_to_porcelain(e) from e 1966 tries = 0 1967 for plumbing_item in plumbing_response.approval_workflow_steps: 1968 yield plumbing.convert_approval_workflow_step_to_porcelain( 1969 plumbing_item) 1970 if plumbing_response.meta.next_cursor == '': 1971 break 1972 req.meta.cursor = plumbing_response.meta.next_cursor 1973 1974 return generator(self, req)
Deprecated: Lists existing approval workflow steps.
class
SnapshotApprovalWorkflowSteps:
1977class SnapshotApprovalWorkflowSteps: 1978 ''' 1979 SnapshotApprovalWorkflowSteps exposes the read only methods of the ApprovalWorkflowSteps 1980 service for historical queries. 1981 ''' 1982 def __init__(self, approval_workflow_steps): 1983 self.approval_workflow_steps = approval_workflow_steps 1984 1985 def get(self, id, timeout=None): 1986 ''' 1987 Deprecated: Get reads one approval workflow step by ID. 1988 ''' 1989 return self.approval_workflow_steps.get(id, timeout=timeout) 1990 1991 def list(self, filter, *args, timeout=None): 1992 ''' 1993 Deprecated: Lists existing approval workflow steps. 1994 ''' 1995 return self.approval_workflow_steps.list(filter, 1996 *args, 1997 timeout=timeout)
SnapshotApprovalWorkflowSteps exposes the read only methods of the ApprovalWorkflowSteps service for historical queries.
def
get(self, id, timeout=None)
1985 def get(self, id, timeout=None): 1986 ''' 1987 Deprecated: Get reads one approval workflow step by ID. 1988 ''' 1989 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)
1991 def list(self, filter, *args, timeout=None): 1992 ''' 1993 Deprecated: Lists existing approval workflow steps. 1994 ''' 1995 return self.approval_workflow_steps.list(filter, 1996 *args, 1997 timeout=timeout)
Deprecated: Lists existing approval workflow steps.
class
ApprovalWorkflowStepsHistory:
2000class ApprovalWorkflowStepsHistory: 2001 ''' 2002 ApprovalWorkflowStepsHistory records all changes to the state of an ApprovalWorkflowStep. 2003 See `strongdm.models.ApprovalWorkflowStepHistory`. 2004 ''' 2005 def __init__(self, channel, client): 2006 self.parent = client 2007 self.stub = ApprovalWorkflowStepsHistoryStub(channel) 2008 2009 def list(self, filter, *args, timeout=None): 2010 ''' 2011 List gets a list of ApprovalWorkflowStepHistory records matching a given set of criteria. 2012 ''' 2013 deadline = None if timeout is None else time.time() + timeout 2014 req = ApprovalWorkflowStepHistoryListRequest() 2015 req.meta.CopyFrom(ListRequestMetadata()) 2016 if self.parent.page_limit > 0: 2017 req.meta.limit = self.parent.page_limit 2018 if self.parent.snapshot_datetime is not None: 2019 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2020 2021 req.filter = plumbing.quote_filter_args(filter, *args) 2022 2023 def generator(svc, req): 2024 tries = 0 2025 while True: 2026 t = None if deadline is None else deadline - time.time() 2027 try: 2028 plumbing_response = svc.stub.List( 2029 req, 2030 metadata=svc.parent.get_metadata( 2031 'ApprovalWorkflowStepsHistory.List', req), 2032 timeout=t) 2033 except Exception as e: 2034 if self.parent.shouldRetry(tries, e, deadline): 2035 tries += 1 2036 time.sleep( 2037 self.parent.exponentialBackoff(tries, deadline)) 2038 continue 2039 raise plumbing.convert_error_to_porcelain(e) from e 2040 tries = 0 2041 for plumbing_item in plumbing_response.history: 2042 yield plumbing.convert_approval_workflow_step_history_to_porcelain( 2043 plumbing_item) 2044 if plumbing_response.meta.next_cursor == '': 2045 break 2046 req.meta.cursor = plumbing_response.meta.next_cursor 2047 2048 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)
2009 def list(self, filter, *args, timeout=None): 2010 ''' 2011 List gets a list of ApprovalWorkflowStepHistory records matching a given set of criteria. 2012 ''' 2013 deadline = None if timeout is None else time.time() + timeout 2014 req = ApprovalWorkflowStepHistoryListRequest() 2015 req.meta.CopyFrom(ListRequestMetadata()) 2016 if self.parent.page_limit > 0: 2017 req.meta.limit = self.parent.page_limit 2018 if self.parent.snapshot_datetime is not None: 2019 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2020 2021 req.filter = plumbing.quote_filter_args(filter, *args) 2022 2023 def generator(svc, req): 2024 tries = 0 2025 while True: 2026 t = None if deadline is None else deadline - time.time() 2027 try: 2028 plumbing_response = svc.stub.List( 2029 req, 2030 metadata=svc.parent.get_metadata( 2031 'ApprovalWorkflowStepsHistory.List', req), 2032 timeout=t) 2033 except Exception as e: 2034 if self.parent.shouldRetry(tries, e, deadline): 2035 tries += 1 2036 time.sleep( 2037 self.parent.exponentialBackoff(tries, deadline)) 2038 continue 2039 raise plumbing.convert_error_to_porcelain(e) from e 2040 tries = 0 2041 for plumbing_item in plumbing_response.history: 2042 yield plumbing.convert_approval_workflow_step_history_to_porcelain( 2043 plumbing_item) 2044 if plumbing_response.meta.next_cursor == '': 2045 break 2046 req.meta.cursor = plumbing_response.meta.next_cursor 2047 2048 return generator(self, req)
List gets a list of ApprovalWorkflowStepHistory records matching a given set of criteria.
class
ApprovalWorkflows:
2051class ApprovalWorkflows: 2052 ''' 2053 ApprovalWorkflows are the mechanism by which requests for access can be viewed by authorized 2054 approvers and be approved or denied. 2055 See `strongdm.models.ApprovalWorkflow`. 2056 ''' 2057 def __init__(self, channel, client): 2058 self.parent = client 2059 self.stub = ApprovalWorkflowsStub(channel) 2060 2061 def create(self, approval_workflow, timeout=None): 2062 ''' 2063 Create creates a new approval workflow and requires a name and approval mode for the approval workflow. 2064 ''' 2065 deadline = None if timeout is None else time.time() + timeout 2066 req = ApprovalWorkflowCreateRequest() 2067 2068 if approval_workflow is not None: 2069 req.approval_workflow.CopyFrom( 2070 plumbing.convert_approval_workflow_to_plumbing( 2071 approval_workflow)) 2072 tries = 0 2073 plumbing_response = None 2074 while True: 2075 t = None if deadline is None else deadline - time.time() 2076 try: 2077 plumbing_response = self.stub.Create( 2078 req, 2079 metadata=self.parent.get_metadata( 2080 'ApprovalWorkflows.Create', req), 2081 timeout=t) 2082 except Exception as e: 2083 if self.parent.shouldRetry(tries, e, deadline): 2084 tries += 1 2085 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2086 continue 2087 raise plumbing.convert_error_to_porcelain(e) from e 2088 break 2089 2090 resp = models.ApprovalWorkflowCreateResponse() 2091 resp.approval_workflow = plumbing.convert_approval_workflow_to_porcelain( 2092 plumbing_response.approval_workflow) 2093 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2094 plumbing_response.rate_limit) 2095 return resp 2096 2097 def get(self, id, timeout=None): 2098 ''' 2099 Get reads one approval workflow by ID. 2100 ''' 2101 deadline = None if timeout is None else time.time() + timeout 2102 req = ApprovalWorkflowGetRequest() 2103 if self.parent.snapshot_datetime is not None: 2104 req.meta.CopyFrom(GetRequestMetadata()) 2105 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2106 2107 req.id = (id) 2108 tries = 0 2109 plumbing_response = None 2110 while True: 2111 t = None if deadline is None else deadline - time.time() 2112 try: 2113 plumbing_response = self.stub.Get( 2114 req, 2115 metadata=self.parent.get_metadata('ApprovalWorkflows.Get', 2116 req), 2117 timeout=t) 2118 except Exception as e: 2119 if self.parent.shouldRetry(tries, e, deadline): 2120 tries += 1 2121 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2122 continue 2123 raise plumbing.convert_error_to_porcelain(e) from e 2124 break 2125 2126 resp = models.ApprovalWorkflowGetResponse() 2127 resp.approval_workflow = plumbing.convert_approval_workflow_to_porcelain( 2128 plumbing_response.approval_workflow) 2129 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2130 plumbing_response.meta) 2131 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2132 plumbing_response.rate_limit) 2133 return resp 2134 2135 def delete(self, id, timeout=None): 2136 ''' 2137 Delete deletes an existing approval workflow. 2138 ''' 2139 deadline = None if timeout is None else time.time() + timeout 2140 req = ApprovalWorkflowDeleteRequest() 2141 2142 req.id = (id) 2143 tries = 0 2144 plumbing_response = None 2145 while True: 2146 t = None if deadline is None else deadline - time.time() 2147 try: 2148 plumbing_response = self.stub.Delete( 2149 req, 2150 metadata=self.parent.get_metadata( 2151 'ApprovalWorkflows.Delete', req), 2152 timeout=t) 2153 except Exception as e: 2154 if self.parent.shouldRetry(tries, e, deadline): 2155 tries += 1 2156 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2157 continue 2158 raise plumbing.convert_error_to_porcelain(e) from e 2159 break 2160 2161 resp = models.ApprovalWorkflowDeleteResponse() 2162 resp.id = (plumbing_response.id) 2163 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2164 plumbing_response.rate_limit) 2165 return resp 2166 2167 def update(self, approval_workflow, timeout=None): 2168 ''' 2169 Update updates an existing approval workflow. 2170 ''' 2171 deadline = None if timeout is None else time.time() + timeout 2172 req = ApprovalWorkflowUpdateRequest() 2173 2174 if approval_workflow is not None: 2175 req.approval_workflow.CopyFrom( 2176 plumbing.convert_approval_workflow_to_plumbing( 2177 approval_workflow)) 2178 tries = 0 2179 plumbing_response = None 2180 while True: 2181 t = None if deadline is None else deadline - time.time() 2182 try: 2183 plumbing_response = self.stub.Update( 2184 req, 2185 metadata=self.parent.get_metadata( 2186 'ApprovalWorkflows.Update', req), 2187 timeout=t) 2188 except Exception as e: 2189 if self.parent.shouldRetry(tries, e, deadline): 2190 tries += 1 2191 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2192 continue 2193 raise plumbing.convert_error_to_porcelain(e) from e 2194 break 2195 2196 resp = models.ApprovalWorkflowUpdateResponse() 2197 resp.approval_workflow = plumbing.convert_approval_workflow_to_porcelain( 2198 plumbing_response.approval_workflow) 2199 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2200 plumbing_response.rate_limit) 2201 return resp 2202 2203 def list(self, filter, *args, timeout=None): 2204 ''' 2205 Lists existing approval workflows. 2206 ''' 2207 deadline = None if timeout is None else time.time() + timeout 2208 req = ApprovalWorkflowListRequest() 2209 req.meta.CopyFrom(ListRequestMetadata()) 2210 if self.parent.page_limit > 0: 2211 req.meta.limit = self.parent.page_limit 2212 if self.parent.snapshot_datetime is not None: 2213 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2214 2215 req.filter = plumbing.quote_filter_args(filter, *args) 2216 2217 def generator(svc, req): 2218 tries = 0 2219 while True: 2220 t = None if deadline is None else deadline - time.time() 2221 try: 2222 plumbing_response = svc.stub.List( 2223 req, 2224 metadata=svc.parent.get_metadata( 2225 'ApprovalWorkflows.List', req), 2226 timeout=t) 2227 except Exception as e: 2228 if self.parent.shouldRetry(tries, e, deadline): 2229 tries += 1 2230 time.sleep( 2231 self.parent.exponentialBackoff(tries, deadline)) 2232 continue 2233 raise plumbing.convert_error_to_porcelain(e) from e 2234 tries = 0 2235 for plumbing_item in plumbing_response.approval_workflows: 2236 yield plumbing.convert_approval_workflow_to_porcelain( 2237 plumbing_item) 2238 if plumbing_response.meta.next_cursor == '': 2239 break 2240 req.meta.cursor = plumbing_response.meta.next_cursor 2241 2242 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)
2061 def create(self, approval_workflow, timeout=None): 2062 ''' 2063 Create creates a new approval workflow and requires a name and approval mode for the approval workflow. 2064 ''' 2065 deadline = None if timeout is None else time.time() + timeout 2066 req = ApprovalWorkflowCreateRequest() 2067 2068 if approval_workflow is not None: 2069 req.approval_workflow.CopyFrom( 2070 plumbing.convert_approval_workflow_to_plumbing( 2071 approval_workflow)) 2072 tries = 0 2073 plumbing_response = None 2074 while True: 2075 t = None if deadline is None else deadline - time.time() 2076 try: 2077 plumbing_response = self.stub.Create( 2078 req, 2079 metadata=self.parent.get_metadata( 2080 'ApprovalWorkflows.Create', req), 2081 timeout=t) 2082 except Exception as e: 2083 if self.parent.shouldRetry(tries, e, deadline): 2084 tries += 1 2085 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2086 continue 2087 raise plumbing.convert_error_to_porcelain(e) from e 2088 break 2089 2090 resp = models.ApprovalWorkflowCreateResponse() 2091 resp.approval_workflow = plumbing.convert_approval_workflow_to_porcelain( 2092 plumbing_response.approval_workflow) 2093 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2094 plumbing_response.rate_limit) 2095 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)
2097 def get(self, id, timeout=None): 2098 ''' 2099 Get reads one approval workflow by ID. 2100 ''' 2101 deadline = None if timeout is None else time.time() + timeout 2102 req = ApprovalWorkflowGetRequest() 2103 if self.parent.snapshot_datetime is not None: 2104 req.meta.CopyFrom(GetRequestMetadata()) 2105 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2106 2107 req.id = (id) 2108 tries = 0 2109 plumbing_response = None 2110 while True: 2111 t = None if deadline is None else deadline - time.time() 2112 try: 2113 plumbing_response = self.stub.Get( 2114 req, 2115 metadata=self.parent.get_metadata('ApprovalWorkflows.Get', 2116 req), 2117 timeout=t) 2118 except Exception as e: 2119 if self.parent.shouldRetry(tries, e, deadline): 2120 tries += 1 2121 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2122 continue 2123 raise plumbing.convert_error_to_porcelain(e) from e 2124 break 2125 2126 resp = models.ApprovalWorkflowGetResponse() 2127 resp.approval_workflow = plumbing.convert_approval_workflow_to_porcelain( 2128 plumbing_response.approval_workflow) 2129 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2130 plumbing_response.meta) 2131 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2132 plumbing_response.rate_limit) 2133 return resp
Get reads one approval workflow by ID.
def
delete(self, id, timeout=None)
2135 def delete(self, id, timeout=None): 2136 ''' 2137 Delete deletes an existing approval workflow. 2138 ''' 2139 deadline = None if timeout is None else time.time() + timeout 2140 req = ApprovalWorkflowDeleteRequest() 2141 2142 req.id = (id) 2143 tries = 0 2144 plumbing_response = None 2145 while True: 2146 t = None if deadline is None else deadline - time.time() 2147 try: 2148 plumbing_response = self.stub.Delete( 2149 req, 2150 metadata=self.parent.get_metadata( 2151 'ApprovalWorkflows.Delete', req), 2152 timeout=t) 2153 except Exception as e: 2154 if self.parent.shouldRetry(tries, e, deadline): 2155 tries += 1 2156 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2157 continue 2158 raise plumbing.convert_error_to_porcelain(e) from e 2159 break 2160 2161 resp = models.ApprovalWorkflowDeleteResponse() 2162 resp.id = (plumbing_response.id) 2163 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2164 plumbing_response.rate_limit) 2165 return resp
Delete deletes an existing approval workflow.
def
update(self, approval_workflow, timeout=None)
2167 def update(self, approval_workflow, timeout=None): 2168 ''' 2169 Update updates an existing approval workflow. 2170 ''' 2171 deadline = None if timeout is None else time.time() + timeout 2172 req = ApprovalWorkflowUpdateRequest() 2173 2174 if approval_workflow is not None: 2175 req.approval_workflow.CopyFrom( 2176 plumbing.convert_approval_workflow_to_plumbing( 2177 approval_workflow)) 2178 tries = 0 2179 plumbing_response = None 2180 while True: 2181 t = None if deadline is None else deadline - time.time() 2182 try: 2183 plumbing_response = self.stub.Update( 2184 req, 2185 metadata=self.parent.get_metadata( 2186 'ApprovalWorkflows.Update', req), 2187 timeout=t) 2188 except Exception as e: 2189 if self.parent.shouldRetry(tries, e, deadline): 2190 tries += 1 2191 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2192 continue 2193 raise plumbing.convert_error_to_porcelain(e) from e 2194 break 2195 2196 resp = models.ApprovalWorkflowUpdateResponse() 2197 resp.approval_workflow = plumbing.convert_approval_workflow_to_porcelain( 2198 plumbing_response.approval_workflow) 2199 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2200 plumbing_response.rate_limit) 2201 return resp
Update updates an existing approval workflow.
def
list(self, filter, *args, timeout=None)
2203 def list(self, filter, *args, timeout=None): 2204 ''' 2205 Lists existing approval workflows. 2206 ''' 2207 deadline = None if timeout is None else time.time() + timeout 2208 req = ApprovalWorkflowListRequest() 2209 req.meta.CopyFrom(ListRequestMetadata()) 2210 if self.parent.page_limit > 0: 2211 req.meta.limit = self.parent.page_limit 2212 if self.parent.snapshot_datetime is not None: 2213 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2214 2215 req.filter = plumbing.quote_filter_args(filter, *args) 2216 2217 def generator(svc, req): 2218 tries = 0 2219 while True: 2220 t = None if deadline is None else deadline - time.time() 2221 try: 2222 plumbing_response = svc.stub.List( 2223 req, 2224 metadata=svc.parent.get_metadata( 2225 'ApprovalWorkflows.List', req), 2226 timeout=t) 2227 except Exception as e: 2228 if self.parent.shouldRetry(tries, e, deadline): 2229 tries += 1 2230 time.sleep( 2231 self.parent.exponentialBackoff(tries, deadline)) 2232 continue 2233 raise plumbing.convert_error_to_porcelain(e) from e 2234 tries = 0 2235 for plumbing_item in plumbing_response.approval_workflows: 2236 yield plumbing.convert_approval_workflow_to_porcelain( 2237 plumbing_item) 2238 if plumbing_response.meta.next_cursor == '': 2239 break 2240 req.meta.cursor = plumbing_response.meta.next_cursor 2241 2242 return generator(self, req)
Lists existing approval workflows.
class
SnapshotApprovalWorkflows:
2245class SnapshotApprovalWorkflows: 2246 ''' 2247 SnapshotApprovalWorkflows exposes the read only methods of the ApprovalWorkflows 2248 service for historical queries. 2249 ''' 2250 def __init__(self, approval_workflows): 2251 self.approval_workflows = approval_workflows 2252 2253 def get(self, id, timeout=None): 2254 ''' 2255 Get reads one approval workflow by ID. 2256 ''' 2257 return self.approval_workflows.get(id, timeout=timeout) 2258 2259 def list(self, filter, *args, timeout=None): 2260 ''' 2261 Lists existing approval workflows. 2262 ''' 2263 return self.approval_workflows.list(filter, *args, timeout=timeout)
SnapshotApprovalWorkflows exposes the read only methods of the ApprovalWorkflows service for historical queries.
class
ApprovalWorkflowsHistory:
2266class ApprovalWorkflowsHistory: 2267 ''' 2268 ApprovalWorkflowsHistory records all changes to the state of an ApprovalWorkflow. 2269 See `strongdm.models.ApprovalWorkflowHistory`. 2270 ''' 2271 def __init__(self, channel, client): 2272 self.parent = client 2273 self.stub = ApprovalWorkflowsHistoryStub(channel) 2274 2275 def list(self, filter, *args, timeout=None): 2276 ''' 2277 List gets a list of ApprovalWorkflowHistory records matching a given set of criteria. 2278 ''' 2279 deadline = None if timeout is None else time.time() + timeout 2280 req = ApprovalWorkflowHistoryListRequest() 2281 req.meta.CopyFrom(ListRequestMetadata()) 2282 if self.parent.page_limit > 0: 2283 req.meta.limit = self.parent.page_limit 2284 if self.parent.snapshot_datetime is not None: 2285 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2286 2287 req.filter = plumbing.quote_filter_args(filter, *args) 2288 2289 def generator(svc, req): 2290 tries = 0 2291 while True: 2292 t = None if deadline is None else deadline - time.time() 2293 try: 2294 plumbing_response = svc.stub.List( 2295 req, 2296 metadata=svc.parent.get_metadata( 2297 'ApprovalWorkflowsHistory.List', req), 2298 timeout=t) 2299 except Exception as e: 2300 if self.parent.shouldRetry(tries, e, deadline): 2301 tries += 1 2302 time.sleep( 2303 self.parent.exponentialBackoff(tries, deadline)) 2304 continue 2305 raise plumbing.convert_error_to_porcelain(e) from e 2306 tries = 0 2307 for plumbing_item in plumbing_response.history: 2308 yield plumbing.convert_approval_workflow_history_to_porcelain( 2309 plumbing_item) 2310 if plumbing_response.meta.next_cursor == '': 2311 break 2312 req.meta.cursor = plumbing_response.meta.next_cursor 2313 2314 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)
2275 def list(self, filter, *args, timeout=None): 2276 ''' 2277 List gets a list of ApprovalWorkflowHistory records matching a given set of criteria. 2278 ''' 2279 deadline = None if timeout is None else time.time() + timeout 2280 req = ApprovalWorkflowHistoryListRequest() 2281 req.meta.CopyFrom(ListRequestMetadata()) 2282 if self.parent.page_limit > 0: 2283 req.meta.limit = self.parent.page_limit 2284 if self.parent.snapshot_datetime is not None: 2285 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2286 2287 req.filter = plumbing.quote_filter_args(filter, *args) 2288 2289 def generator(svc, req): 2290 tries = 0 2291 while True: 2292 t = None if deadline is None else deadline - time.time() 2293 try: 2294 plumbing_response = svc.stub.List( 2295 req, 2296 metadata=svc.parent.get_metadata( 2297 'ApprovalWorkflowsHistory.List', req), 2298 timeout=t) 2299 except Exception as e: 2300 if self.parent.shouldRetry(tries, e, deadline): 2301 tries += 1 2302 time.sleep( 2303 self.parent.exponentialBackoff(tries, deadline)) 2304 continue 2305 raise plumbing.convert_error_to_porcelain(e) from e 2306 tries = 0 2307 for plumbing_item in plumbing_response.history: 2308 yield plumbing.convert_approval_workflow_history_to_porcelain( 2309 plumbing_item) 2310 if plumbing_response.meta.next_cursor == '': 2311 break 2312 req.meta.cursor = plumbing_response.meta.next_cursor 2313 2314 return generator(self, req)
List gets a list of ApprovalWorkflowHistory records matching a given set of criteria.
class
ControlPanel:
2317class ControlPanel: 2318 ''' 2319 ControlPanel contains all administrative controls. 2320 ''' 2321 def __init__(self, channel, client): 2322 self.parent = client 2323 self.stub = ControlPanelStub(channel) 2324 2325 def get_sshca_public_key(self, timeout=None): 2326 ''' 2327 GetSSHCAPublicKey retrieves the SSH CA public key. 2328 ''' 2329 deadline = None if timeout is None else time.time() + timeout 2330 req = ControlPanelGetSSHCAPublicKeyRequest() 2331 2332 tries = 0 2333 plumbing_response = None 2334 while True: 2335 t = None if deadline is None else deadline - time.time() 2336 try: 2337 plumbing_response = self.stub.GetSSHCAPublicKey( 2338 req, 2339 metadata=self.parent.get_metadata( 2340 'ControlPanel.GetSSHCAPublicKey', req), 2341 timeout=t) 2342 except Exception as e: 2343 if self.parent.shouldRetry(tries, e, deadline): 2344 tries += 1 2345 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2346 continue 2347 raise plumbing.convert_error_to_porcelain(e) from e 2348 break 2349 2350 resp = models.ControlPanelGetSSHCAPublicKeyResponse() 2351 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2352 plumbing_response.meta) 2353 resp.public_key = (plumbing_response.public_key) 2354 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2355 plumbing_response.rate_limit) 2356 return resp 2357 2358 def get_rdpca_public_key(self, timeout=None): 2359 ''' 2360 GetRDPCAPublicKey retrieves the RDP CA public key. 2361 ''' 2362 deadline = None if timeout is None else time.time() + timeout 2363 req = ControlPanelGetRDPCAPublicKeyRequest() 2364 2365 tries = 0 2366 plumbing_response = None 2367 while True: 2368 t = None if deadline is None else deadline - time.time() 2369 try: 2370 plumbing_response = self.stub.GetRDPCAPublicKey( 2371 req, 2372 metadata=self.parent.get_metadata( 2373 'ControlPanel.GetRDPCAPublicKey', req), 2374 timeout=t) 2375 except Exception as e: 2376 if self.parent.shouldRetry(tries, e, deadline): 2377 tries += 1 2378 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2379 continue 2380 raise plumbing.convert_error_to_porcelain(e) from e 2381 break 2382 2383 resp = models.ControlPanelGetRDPCAPublicKeyResponse() 2384 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2385 plumbing_response.meta) 2386 resp.public_key = (plumbing_response.public_key) 2387 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2388 plumbing_response.rate_limit) 2389 return resp 2390 2391 def verify_jwt(self, token, timeout=None): 2392 ''' 2393 VerifyJWT reports whether the given JWT token (x-sdm-token) is valid. 2394 ''' 2395 deadline = None if timeout is None else time.time() + timeout 2396 req = ControlPanelVerifyJWTRequest() 2397 2398 req.token = (token) 2399 tries = 0 2400 plumbing_response = None 2401 while True: 2402 t = None if deadline is None else deadline - time.time() 2403 try: 2404 plumbing_response = self.stub.VerifyJWT( 2405 req, 2406 metadata=self.parent.get_metadata('ControlPanel.VerifyJWT', 2407 req), 2408 timeout=t) 2409 except Exception as e: 2410 if self.parent.shouldRetry(tries, e, deadline): 2411 tries += 1 2412 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2413 continue 2414 raise plumbing.convert_error_to_porcelain(e) from e 2415 break 2416 2417 resp = models.ControlPanelVerifyJWTResponse() 2418 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2419 plumbing_response.meta) 2420 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2421 plumbing_response.rate_limit) 2422 resp.valid = (plumbing_response.valid) 2423 return resp
ControlPanel contains all administrative controls.
def
get_sshca_public_key(self, timeout=None)
2325 def get_sshca_public_key(self, timeout=None): 2326 ''' 2327 GetSSHCAPublicKey retrieves the SSH CA public key. 2328 ''' 2329 deadline = None if timeout is None else time.time() + timeout 2330 req = ControlPanelGetSSHCAPublicKeyRequest() 2331 2332 tries = 0 2333 plumbing_response = None 2334 while True: 2335 t = None if deadline is None else deadline - time.time() 2336 try: 2337 plumbing_response = self.stub.GetSSHCAPublicKey( 2338 req, 2339 metadata=self.parent.get_metadata( 2340 'ControlPanel.GetSSHCAPublicKey', req), 2341 timeout=t) 2342 except Exception as e: 2343 if self.parent.shouldRetry(tries, e, deadline): 2344 tries += 1 2345 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2346 continue 2347 raise plumbing.convert_error_to_porcelain(e) from e 2348 break 2349 2350 resp = models.ControlPanelGetSSHCAPublicKeyResponse() 2351 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2352 plumbing_response.meta) 2353 resp.public_key = (plumbing_response.public_key) 2354 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2355 plumbing_response.rate_limit) 2356 return resp
GetSSHCAPublicKey retrieves the SSH CA public key.
def
get_rdpca_public_key(self, timeout=None)
2358 def get_rdpca_public_key(self, timeout=None): 2359 ''' 2360 GetRDPCAPublicKey retrieves the RDP CA public key. 2361 ''' 2362 deadline = None if timeout is None else time.time() + timeout 2363 req = ControlPanelGetRDPCAPublicKeyRequest() 2364 2365 tries = 0 2366 plumbing_response = None 2367 while True: 2368 t = None if deadline is None else deadline - time.time() 2369 try: 2370 plumbing_response = self.stub.GetRDPCAPublicKey( 2371 req, 2372 metadata=self.parent.get_metadata( 2373 'ControlPanel.GetRDPCAPublicKey', req), 2374 timeout=t) 2375 except Exception as e: 2376 if self.parent.shouldRetry(tries, e, deadline): 2377 tries += 1 2378 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2379 continue 2380 raise plumbing.convert_error_to_porcelain(e) from e 2381 break 2382 2383 resp = models.ControlPanelGetRDPCAPublicKeyResponse() 2384 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2385 plumbing_response.meta) 2386 resp.public_key = (plumbing_response.public_key) 2387 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2388 plumbing_response.rate_limit) 2389 return resp
GetRDPCAPublicKey retrieves the RDP CA public key.
def
verify_jwt(self, token, timeout=None)
2391 def verify_jwt(self, token, timeout=None): 2392 ''' 2393 VerifyJWT reports whether the given JWT token (x-sdm-token) is valid. 2394 ''' 2395 deadline = None if timeout is None else time.time() + timeout 2396 req = ControlPanelVerifyJWTRequest() 2397 2398 req.token = (token) 2399 tries = 0 2400 plumbing_response = None 2401 while True: 2402 t = None if deadline is None else deadline - time.time() 2403 try: 2404 plumbing_response = self.stub.VerifyJWT( 2405 req, 2406 metadata=self.parent.get_metadata('ControlPanel.VerifyJWT', 2407 req), 2408 timeout=t) 2409 except Exception as e: 2410 if self.parent.shouldRetry(tries, e, deadline): 2411 tries += 1 2412 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2413 continue 2414 raise plumbing.convert_error_to_porcelain(e) from e 2415 break 2416 2417 resp = models.ControlPanelVerifyJWTResponse() 2418 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2419 plumbing_response.meta) 2420 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2421 plumbing_response.rate_limit) 2422 resp.valid = (plumbing_response.valid) 2423 return resp
VerifyJWT reports whether the given JWT token (x-sdm-token) is valid.
class
Roles:
2426class Roles: 2427 ''' 2428 A Role has a list of access rules which determine which Resources the members 2429 of the Role have access to. An Account can be a member of multiple Roles via 2430 AccountAttachments. 2431 See `strongdm.models.Role`. 2432 ''' 2433 def __init__(self, channel, client): 2434 self.parent = client 2435 self.stub = RolesStub(channel) 2436 2437 def create(self, role, timeout=None): 2438 ''' 2439 Create registers a new Role. 2440 ''' 2441 deadline = None if timeout is None else time.time() + timeout 2442 req = RoleCreateRequest() 2443 2444 if role is not None: 2445 req.role.CopyFrom(plumbing.convert_role_to_plumbing(role)) 2446 tries = 0 2447 plumbing_response = None 2448 while True: 2449 t = None if deadline is None else deadline - time.time() 2450 try: 2451 plumbing_response = self.stub.Create( 2452 req, 2453 metadata=self.parent.get_metadata('Roles.Create', req), 2454 timeout=t) 2455 except Exception as e: 2456 if self.parent.shouldRetry(tries, e, deadline): 2457 tries += 1 2458 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2459 continue 2460 raise plumbing.convert_error_to_porcelain(e) from e 2461 break 2462 2463 resp = models.RoleCreateResponse() 2464 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 2465 plumbing_response.meta) 2466 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2467 plumbing_response.rate_limit) 2468 resp.role = plumbing.convert_role_to_porcelain(plumbing_response.role) 2469 return resp 2470 2471 def get(self, id, timeout=None): 2472 ''' 2473 Get reads one Role by ID. 2474 ''' 2475 deadline = None if timeout is None else time.time() + timeout 2476 req = RoleGetRequest() 2477 if self.parent.snapshot_datetime is not None: 2478 req.meta.CopyFrom(GetRequestMetadata()) 2479 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2480 2481 req.id = (id) 2482 tries = 0 2483 plumbing_response = None 2484 while True: 2485 t = None if deadline is None else deadline - time.time() 2486 try: 2487 plumbing_response = self.stub.Get( 2488 req, 2489 metadata=self.parent.get_metadata('Roles.Get', req), 2490 timeout=t) 2491 except Exception as e: 2492 if self.parent.shouldRetry(tries, e, deadline): 2493 tries += 1 2494 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2495 continue 2496 raise plumbing.convert_error_to_porcelain(e) from e 2497 break 2498 2499 resp = models.RoleGetResponse() 2500 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2501 plumbing_response.meta) 2502 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2503 plumbing_response.rate_limit) 2504 resp.role = plumbing.convert_role_to_porcelain(plumbing_response.role) 2505 return resp 2506 2507 def update(self, role, timeout=None): 2508 ''' 2509 Update replaces all the fields of a Role by ID. 2510 ''' 2511 deadline = None if timeout is None else time.time() + timeout 2512 req = RoleUpdateRequest() 2513 2514 if role is not None: 2515 req.role.CopyFrom(plumbing.convert_role_to_plumbing(role)) 2516 tries = 0 2517 plumbing_response = None 2518 while True: 2519 t = None if deadline is None else deadline - time.time() 2520 try: 2521 plumbing_response = self.stub.Update( 2522 req, 2523 metadata=self.parent.get_metadata('Roles.Update', req), 2524 timeout=t) 2525 except Exception as e: 2526 if self.parent.shouldRetry(tries, e, deadline): 2527 tries += 1 2528 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2529 continue 2530 raise plumbing.convert_error_to_porcelain(e) from e 2531 break 2532 2533 resp = models.RoleUpdateResponse() 2534 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 2535 plumbing_response.meta) 2536 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2537 plumbing_response.rate_limit) 2538 resp.role = plumbing.convert_role_to_porcelain(plumbing_response.role) 2539 return resp 2540 2541 def delete(self, id, timeout=None): 2542 ''' 2543 Delete removes a Role by ID. 2544 ''' 2545 deadline = None if timeout is None else time.time() + timeout 2546 req = RoleDeleteRequest() 2547 2548 req.id = (id) 2549 tries = 0 2550 plumbing_response = None 2551 while True: 2552 t = None if deadline is None else deadline - time.time() 2553 try: 2554 plumbing_response = self.stub.Delete( 2555 req, 2556 metadata=self.parent.get_metadata('Roles.Delete', req), 2557 timeout=t) 2558 except Exception as e: 2559 if self.parent.shouldRetry(tries, e, deadline): 2560 tries += 1 2561 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2562 continue 2563 raise plumbing.convert_error_to_porcelain(e) from e 2564 break 2565 2566 resp = models.RoleDeleteResponse() 2567 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 2568 plumbing_response.meta) 2569 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2570 plumbing_response.rate_limit) 2571 return resp 2572 2573 def list(self, filter, *args, timeout=None): 2574 ''' 2575 List gets a list of Roles matching a given set of criteria. 2576 ''' 2577 deadline = None if timeout is None else time.time() + timeout 2578 req = RoleListRequest() 2579 req.meta.CopyFrom(ListRequestMetadata()) 2580 if self.parent.page_limit > 0: 2581 req.meta.limit = self.parent.page_limit 2582 if self.parent.snapshot_datetime is not None: 2583 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2584 2585 req.filter = plumbing.quote_filter_args(filter, *args) 2586 2587 def generator(svc, req): 2588 tries = 0 2589 while True: 2590 t = None if deadline is None else deadline - time.time() 2591 try: 2592 plumbing_response = svc.stub.List( 2593 req, 2594 metadata=svc.parent.get_metadata('Roles.List', req), 2595 timeout=t) 2596 except Exception as e: 2597 if self.parent.shouldRetry(tries, e, deadline): 2598 tries += 1 2599 time.sleep( 2600 self.parent.exponentialBackoff(tries, deadline)) 2601 continue 2602 raise plumbing.convert_error_to_porcelain(e) from e 2603 tries = 0 2604 for plumbing_item in plumbing_response.roles: 2605 yield plumbing.convert_role_to_porcelain(plumbing_item) 2606 if plumbing_response.meta.next_cursor == '': 2607 break 2608 req.meta.cursor = plumbing_response.meta.next_cursor 2609 2610 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)
2437 def create(self, role, timeout=None): 2438 ''' 2439 Create registers a new Role. 2440 ''' 2441 deadline = None if timeout is None else time.time() + timeout 2442 req = RoleCreateRequest() 2443 2444 if role is not None: 2445 req.role.CopyFrom(plumbing.convert_role_to_plumbing(role)) 2446 tries = 0 2447 plumbing_response = None 2448 while True: 2449 t = None if deadline is None else deadline - time.time() 2450 try: 2451 plumbing_response = self.stub.Create( 2452 req, 2453 metadata=self.parent.get_metadata('Roles.Create', req), 2454 timeout=t) 2455 except Exception as e: 2456 if self.parent.shouldRetry(tries, e, deadline): 2457 tries += 1 2458 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2459 continue 2460 raise plumbing.convert_error_to_porcelain(e) from e 2461 break 2462 2463 resp = models.RoleCreateResponse() 2464 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 2465 plumbing_response.meta) 2466 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2467 plumbing_response.rate_limit) 2468 resp.role = plumbing.convert_role_to_porcelain(plumbing_response.role) 2469 return resp
Create registers a new Role.
def
get(self, id, timeout=None)
2471 def get(self, id, timeout=None): 2472 ''' 2473 Get reads one Role by ID. 2474 ''' 2475 deadline = None if timeout is None else time.time() + timeout 2476 req = RoleGetRequest() 2477 if self.parent.snapshot_datetime is not None: 2478 req.meta.CopyFrom(GetRequestMetadata()) 2479 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2480 2481 req.id = (id) 2482 tries = 0 2483 plumbing_response = None 2484 while True: 2485 t = None if deadline is None else deadline - time.time() 2486 try: 2487 plumbing_response = self.stub.Get( 2488 req, 2489 metadata=self.parent.get_metadata('Roles.Get', req), 2490 timeout=t) 2491 except Exception as e: 2492 if self.parent.shouldRetry(tries, e, deadline): 2493 tries += 1 2494 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2495 continue 2496 raise plumbing.convert_error_to_porcelain(e) from e 2497 break 2498 2499 resp = models.RoleGetResponse() 2500 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2501 plumbing_response.meta) 2502 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2503 plumbing_response.rate_limit) 2504 resp.role = plumbing.convert_role_to_porcelain(plumbing_response.role) 2505 return resp
Get reads one Role by ID.
def
update(self, role, timeout=None)
2507 def update(self, role, timeout=None): 2508 ''' 2509 Update replaces all the fields of a Role by ID. 2510 ''' 2511 deadline = None if timeout is None else time.time() + timeout 2512 req = RoleUpdateRequest() 2513 2514 if role is not None: 2515 req.role.CopyFrom(plumbing.convert_role_to_plumbing(role)) 2516 tries = 0 2517 plumbing_response = None 2518 while True: 2519 t = None if deadline is None else deadline - time.time() 2520 try: 2521 plumbing_response = self.stub.Update( 2522 req, 2523 metadata=self.parent.get_metadata('Roles.Update', req), 2524 timeout=t) 2525 except Exception as e: 2526 if self.parent.shouldRetry(tries, e, deadline): 2527 tries += 1 2528 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2529 continue 2530 raise plumbing.convert_error_to_porcelain(e) from e 2531 break 2532 2533 resp = models.RoleUpdateResponse() 2534 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 2535 plumbing_response.meta) 2536 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2537 plumbing_response.rate_limit) 2538 resp.role = plumbing.convert_role_to_porcelain(plumbing_response.role) 2539 return resp
Update replaces all the fields of a Role by ID.
def
delete(self, id, timeout=None)
2541 def delete(self, id, timeout=None): 2542 ''' 2543 Delete removes a Role by ID. 2544 ''' 2545 deadline = None if timeout is None else time.time() + timeout 2546 req = RoleDeleteRequest() 2547 2548 req.id = (id) 2549 tries = 0 2550 plumbing_response = None 2551 while True: 2552 t = None if deadline is None else deadline - time.time() 2553 try: 2554 plumbing_response = self.stub.Delete( 2555 req, 2556 metadata=self.parent.get_metadata('Roles.Delete', req), 2557 timeout=t) 2558 except Exception as e: 2559 if self.parent.shouldRetry(tries, e, deadline): 2560 tries += 1 2561 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2562 continue 2563 raise plumbing.convert_error_to_porcelain(e) from e 2564 break 2565 2566 resp = models.RoleDeleteResponse() 2567 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 2568 plumbing_response.meta) 2569 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2570 plumbing_response.rate_limit) 2571 return resp
Delete removes a Role by ID.
def
list(self, filter, *args, timeout=None)
2573 def list(self, filter, *args, timeout=None): 2574 ''' 2575 List gets a list of Roles matching a given set of criteria. 2576 ''' 2577 deadline = None if timeout is None else time.time() + timeout 2578 req = RoleListRequest() 2579 req.meta.CopyFrom(ListRequestMetadata()) 2580 if self.parent.page_limit > 0: 2581 req.meta.limit = self.parent.page_limit 2582 if self.parent.snapshot_datetime is not None: 2583 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2584 2585 req.filter = plumbing.quote_filter_args(filter, *args) 2586 2587 def generator(svc, req): 2588 tries = 0 2589 while True: 2590 t = None if deadline is None else deadline - time.time() 2591 try: 2592 plumbing_response = svc.stub.List( 2593 req, 2594 metadata=svc.parent.get_metadata('Roles.List', req), 2595 timeout=t) 2596 except Exception as e: 2597 if self.parent.shouldRetry(tries, e, deadline): 2598 tries += 1 2599 time.sleep( 2600 self.parent.exponentialBackoff(tries, deadline)) 2601 continue 2602 raise plumbing.convert_error_to_porcelain(e) from e 2603 tries = 0 2604 for plumbing_item in plumbing_response.roles: 2605 yield plumbing.convert_role_to_porcelain(plumbing_item) 2606 if plumbing_response.meta.next_cursor == '': 2607 break 2608 req.meta.cursor = plumbing_response.meta.next_cursor 2609 2610 return generator(self, req)
List gets a list of Roles matching a given set of criteria.
class
SnapshotRoles:
2613class SnapshotRoles: 2614 ''' 2615 SnapshotRoles exposes the read only methods of the Roles 2616 service for historical queries. 2617 ''' 2618 def __init__(self, roles): 2619 self.roles = roles 2620 2621 def get(self, id, timeout=None): 2622 ''' 2623 Get reads one Role by ID. 2624 ''' 2625 return self.roles.get(id, timeout=timeout) 2626 2627 def list(self, filter, *args, timeout=None): 2628 ''' 2629 List gets a list of Roles matching a given set of criteria. 2630 ''' 2631 return self.roles.list(filter, *args, timeout=timeout)
SnapshotRoles exposes the read only methods of the Roles service for historical queries.
class
Groups:
2634class Groups: 2635 ''' 2636 A Group is a set of principals. 2637 See `strongdm.models.Group`. 2638 ''' 2639 def __init__(self, channel, client): 2640 self.parent = client 2641 self.stub = GroupsStub(channel) 2642 2643 def create(self, group, timeout=None): 2644 ''' 2645 Create registers a new Group. 2646 ''' 2647 deadline = None if timeout is None else time.time() + timeout 2648 req = GroupCreateRequest() 2649 2650 if group is not None: 2651 req.group.CopyFrom(plumbing.convert_group_to_plumbing(group)) 2652 tries = 0 2653 plumbing_response = None 2654 while True: 2655 t = None if deadline is None else deadline - time.time() 2656 try: 2657 plumbing_response = self.stub.Create( 2658 req, 2659 metadata=self.parent.get_metadata('Groups.Create', req), 2660 timeout=t) 2661 except Exception as e: 2662 if self.parent.shouldRetry(tries, e, deadline): 2663 tries += 1 2664 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2665 continue 2666 raise plumbing.convert_error_to_porcelain(e) from e 2667 break 2668 2669 resp = models.GroupCreateResponse() 2670 resp.group = plumbing.convert_group_to_porcelain( 2671 plumbing_response.group) 2672 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2673 plumbing_response.rate_limit) 2674 return resp 2675 2676 def create_from_roles(self, role_ids, commit, timeout=None): 2677 deadline = None if timeout is None else time.time() + timeout 2678 req = GroupCreateFromRolesRequest() 2679 2680 req.role_ids.extend((role_ids)) 2681 req.commit = (commit) 2682 tries = 0 2683 plumbing_response = None 2684 while True: 2685 t = None if deadline is None else deadline - time.time() 2686 try: 2687 plumbing_response = self.stub.CreateFromRoles( 2688 req, 2689 metadata=self.parent.get_metadata('Groups.CreateFromRoles', 2690 req), 2691 timeout=t) 2692 except Exception as e: 2693 if self.parent.shouldRetry(tries, e, deadline): 2694 tries += 1 2695 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2696 continue 2697 raise plumbing.convert_error_to_porcelain(e) from e 2698 break 2699 2700 resp = models.GroupCreateFromRolesResponse() 2701 resp.group_from_role = plumbing.convert_repeated_group_from_role_to_porcelain( 2702 plumbing_response.group_from_role) 2703 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2704 plumbing_response.rate_limit) 2705 return resp 2706 2707 def get(self, id, timeout=None): 2708 ''' 2709 Get reads one Group by ID. 2710 ''' 2711 deadline = None if timeout is None else time.time() + timeout 2712 req = GroupGetRequest() 2713 if self.parent.snapshot_datetime is not None: 2714 req.meta.CopyFrom(GetRequestMetadata()) 2715 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2716 2717 req.id = (id) 2718 tries = 0 2719 plumbing_response = None 2720 while True: 2721 t = None if deadline is None else deadline - time.time() 2722 try: 2723 plumbing_response = self.stub.Get( 2724 req, 2725 metadata=self.parent.get_metadata('Groups.Get', req), 2726 timeout=t) 2727 except Exception as e: 2728 if self.parent.shouldRetry(tries, e, deadline): 2729 tries += 1 2730 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2731 continue 2732 raise plumbing.convert_error_to_porcelain(e) from e 2733 break 2734 2735 resp = models.GroupGetResponse() 2736 resp.group = plumbing.convert_group_to_porcelain( 2737 plumbing_response.group) 2738 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2739 plumbing_response.meta) 2740 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2741 plumbing_response.rate_limit) 2742 return resp 2743 2744 def update(self, group, timeout=None): 2745 ''' 2746 Update replaces all the fields of a Group by ID. 2747 ''' 2748 deadline = None if timeout is None else time.time() + timeout 2749 req = GroupUpdateRequest() 2750 2751 if group is not None: 2752 req.group.CopyFrom(plumbing.convert_group_to_plumbing(group)) 2753 tries = 0 2754 plumbing_response = None 2755 while True: 2756 t = None if deadline is None else deadline - time.time() 2757 try: 2758 plumbing_response = self.stub.Update( 2759 req, 2760 metadata=self.parent.get_metadata('Groups.Update', req), 2761 timeout=t) 2762 except Exception as e: 2763 if self.parent.shouldRetry(tries, e, deadline): 2764 tries += 1 2765 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2766 continue 2767 raise plumbing.convert_error_to_porcelain(e) from e 2768 break 2769 2770 resp = models.GroupUpdateResponse() 2771 resp.group = plumbing.convert_group_to_porcelain( 2772 plumbing_response.group) 2773 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2774 plumbing_response.rate_limit) 2775 return resp 2776 2777 def delete(self, id, timeout=None): 2778 ''' 2779 Delete removes a Group by ID. 2780 ''' 2781 deadline = None if timeout is None else time.time() + timeout 2782 req = GroupDeleteRequest() 2783 2784 req.id = (id) 2785 tries = 0 2786 plumbing_response = None 2787 while True: 2788 t = None if deadline is None else deadline - time.time() 2789 try: 2790 plumbing_response = self.stub.Delete( 2791 req, 2792 metadata=self.parent.get_metadata('Groups.Delete', req), 2793 timeout=t) 2794 except Exception as e: 2795 if self.parent.shouldRetry(tries, e, deadline): 2796 tries += 1 2797 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2798 continue 2799 raise plumbing.convert_error_to_porcelain(e) from e 2800 break 2801 2802 resp = models.GroupDeleteResponse() 2803 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 2804 plumbing_response.meta) 2805 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2806 plumbing_response.rate_limit) 2807 return resp 2808 2809 def list(self, filter, *args, timeout=None): 2810 ''' 2811 List gets a list of Groups matching a given set of criteria. 2812 ''' 2813 deadline = None if timeout is None else time.time() + timeout 2814 req = GroupListRequest() 2815 req.meta.CopyFrom(ListRequestMetadata()) 2816 if self.parent.page_limit > 0: 2817 req.meta.limit = self.parent.page_limit 2818 if self.parent.snapshot_datetime is not None: 2819 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2820 2821 req.filter = plumbing.quote_filter_args(filter, *args) 2822 2823 def generator(svc, req): 2824 tries = 0 2825 while True: 2826 t = None if deadline is None else deadline - time.time() 2827 try: 2828 plumbing_response = svc.stub.List( 2829 req, 2830 metadata=svc.parent.get_metadata('Groups.List', req), 2831 timeout=t) 2832 except Exception as e: 2833 if self.parent.shouldRetry(tries, e, deadline): 2834 tries += 1 2835 time.sleep( 2836 self.parent.exponentialBackoff(tries, deadline)) 2837 continue 2838 raise plumbing.convert_error_to_porcelain(e) from e 2839 tries = 0 2840 for plumbing_item in plumbing_response.groups: 2841 yield plumbing.convert_group_to_porcelain(plumbing_item) 2842 if plumbing_response.meta.next_cursor == '': 2843 break 2844 req.meta.cursor = plumbing_response.meta.next_cursor 2845 2846 return generator(self, req)
A Group is a set of principals.
See strongdm.models.Group.
def
create(self, group, timeout=None)
2643 def create(self, group, timeout=None): 2644 ''' 2645 Create registers a new Group. 2646 ''' 2647 deadline = None if timeout is None else time.time() + timeout 2648 req = GroupCreateRequest() 2649 2650 if group is not None: 2651 req.group.CopyFrom(plumbing.convert_group_to_plumbing(group)) 2652 tries = 0 2653 plumbing_response = None 2654 while True: 2655 t = None if deadline is None else deadline - time.time() 2656 try: 2657 plumbing_response = self.stub.Create( 2658 req, 2659 metadata=self.parent.get_metadata('Groups.Create', req), 2660 timeout=t) 2661 except Exception as e: 2662 if self.parent.shouldRetry(tries, e, deadline): 2663 tries += 1 2664 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2665 continue 2666 raise plumbing.convert_error_to_porcelain(e) from e 2667 break 2668 2669 resp = models.GroupCreateResponse() 2670 resp.group = plumbing.convert_group_to_porcelain( 2671 plumbing_response.group) 2672 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2673 plumbing_response.rate_limit) 2674 return resp
Create registers a new Group.
def
create_from_roles(self, role_ids, commit, timeout=None)
2676 def create_from_roles(self, role_ids, commit, timeout=None): 2677 deadline = None if timeout is None else time.time() + timeout 2678 req = GroupCreateFromRolesRequest() 2679 2680 req.role_ids.extend((role_ids)) 2681 req.commit = (commit) 2682 tries = 0 2683 plumbing_response = None 2684 while True: 2685 t = None if deadline is None else deadline - time.time() 2686 try: 2687 plumbing_response = self.stub.CreateFromRoles( 2688 req, 2689 metadata=self.parent.get_metadata('Groups.CreateFromRoles', 2690 req), 2691 timeout=t) 2692 except Exception as e: 2693 if self.parent.shouldRetry(tries, e, deadline): 2694 tries += 1 2695 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2696 continue 2697 raise plumbing.convert_error_to_porcelain(e) from e 2698 break 2699 2700 resp = models.GroupCreateFromRolesResponse() 2701 resp.group_from_role = plumbing.convert_repeated_group_from_role_to_porcelain( 2702 plumbing_response.group_from_role) 2703 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2704 plumbing_response.rate_limit) 2705 return resp
def
get(self, id, timeout=None)
2707 def get(self, id, timeout=None): 2708 ''' 2709 Get reads one Group by ID. 2710 ''' 2711 deadline = None if timeout is None else time.time() + timeout 2712 req = GroupGetRequest() 2713 if self.parent.snapshot_datetime is not None: 2714 req.meta.CopyFrom(GetRequestMetadata()) 2715 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2716 2717 req.id = (id) 2718 tries = 0 2719 plumbing_response = None 2720 while True: 2721 t = None if deadline is None else deadline - time.time() 2722 try: 2723 plumbing_response = self.stub.Get( 2724 req, 2725 metadata=self.parent.get_metadata('Groups.Get', req), 2726 timeout=t) 2727 except Exception as e: 2728 if self.parent.shouldRetry(tries, e, deadline): 2729 tries += 1 2730 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2731 continue 2732 raise plumbing.convert_error_to_porcelain(e) from e 2733 break 2734 2735 resp = models.GroupGetResponse() 2736 resp.group = plumbing.convert_group_to_porcelain( 2737 plumbing_response.group) 2738 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2739 plumbing_response.meta) 2740 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2741 plumbing_response.rate_limit) 2742 return resp
Get reads one Group by ID.
def
update(self, group, timeout=None)
2744 def update(self, group, timeout=None): 2745 ''' 2746 Update replaces all the fields of a Group by ID. 2747 ''' 2748 deadline = None if timeout is None else time.time() + timeout 2749 req = GroupUpdateRequest() 2750 2751 if group is not None: 2752 req.group.CopyFrom(plumbing.convert_group_to_plumbing(group)) 2753 tries = 0 2754 plumbing_response = None 2755 while True: 2756 t = None if deadline is None else deadline - time.time() 2757 try: 2758 plumbing_response = self.stub.Update( 2759 req, 2760 metadata=self.parent.get_metadata('Groups.Update', req), 2761 timeout=t) 2762 except Exception as e: 2763 if self.parent.shouldRetry(tries, e, deadline): 2764 tries += 1 2765 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2766 continue 2767 raise plumbing.convert_error_to_porcelain(e) from e 2768 break 2769 2770 resp = models.GroupUpdateResponse() 2771 resp.group = plumbing.convert_group_to_porcelain( 2772 plumbing_response.group) 2773 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2774 plumbing_response.rate_limit) 2775 return resp
Update replaces all the fields of a Group by ID.
def
delete(self, id, timeout=None)
2777 def delete(self, id, timeout=None): 2778 ''' 2779 Delete removes a Group by ID. 2780 ''' 2781 deadline = None if timeout is None else time.time() + timeout 2782 req = GroupDeleteRequest() 2783 2784 req.id = (id) 2785 tries = 0 2786 plumbing_response = None 2787 while True: 2788 t = None if deadline is None else deadline - time.time() 2789 try: 2790 plumbing_response = self.stub.Delete( 2791 req, 2792 metadata=self.parent.get_metadata('Groups.Delete', req), 2793 timeout=t) 2794 except Exception as e: 2795 if self.parent.shouldRetry(tries, e, deadline): 2796 tries += 1 2797 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2798 continue 2799 raise plumbing.convert_error_to_porcelain(e) from e 2800 break 2801 2802 resp = models.GroupDeleteResponse() 2803 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 2804 plumbing_response.meta) 2805 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2806 plumbing_response.rate_limit) 2807 return resp
Delete removes a Group by ID.
def
list(self, filter, *args, timeout=None)
2809 def list(self, filter, *args, timeout=None): 2810 ''' 2811 List gets a list of Groups matching a given set of criteria. 2812 ''' 2813 deadline = None if timeout is None else time.time() + timeout 2814 req = GroupListRequest() 2815 req.meta.CopyFrom(ListRequestMetadata()) 2816 if self.parent.page_limit > 0: 2817 req.meta.limit = self.parent.page_limit 2818 if self.parent.snapshot_datetime is not None: 2819 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2820 2821 req.filter = plumbing.quote_filter_args(filter, *args) 2822 2823 def generator(svc, req): 2824 tries = 0 2825 while True: 2826 t = None if deadline is None else deadline - time.time() 2827 try: 2828 plumbing_response = svc.stub.List( 2829 req, 2830 metadata=svc.parent.get_metadata('Groups.List', req), 2831 timeout=t) 2832 except Exception as e: 2833 if self.parent.shouldRetry(tries, e, deadline): 2834 tries += 1 2835 time.sleep( 2836 self.parent.exponentialBackoff(tries, deadline)) 2837 continue 2838 raise plumbing.convert_error_to_porcelain(e) from e 2839 tries = 0 2840 for plumbing_item in plumbing_response.groups: 2841 yield plumbing.convert_group_to_porcelain(plumbing_item) 2842 if plumbing_response.meta.next_cursor == '': 2843 break 2844 req.meta.cursor = plumbing_response.meta.next_cursor 2845 2846 return generator(self, req)
List gets a list of Groups matching a given set of criteria.
class
SnapshotGroups:
2849class SnapshotGroups: 2850 ''' 2851 SnapshotGroups exposes the read only methods of the Groups 2852 service for historical queries. 2853 ''' 2854 def __init__(self, groups): 2855 self.groups = groups 2856 2857 def get(self, id, timeout=None): 2858 ''' 2859 Get reads one Group by ID. 2860 ''' 2861 return self.groups.get(id, timeout=timeout) 2862 2863 def list(self, filter, *args, timeout=None): 2864 ''' 2865 List gets a list of Groups matching a given set of criteria. 2866 ''' 2867 return self.groups.list(filter, *args, timeout=timeout)
SnapshotGroups exposes the read only methods of the Groups service for historical queries.
class
GroupsHistory:
2870class GroupsHistory: 2871 ''' 2872 GroupsHistory records all changes to the state of a Group. 2873 See `strongdm.models.GroupHistory`. 2874 ''' 2875 def __init__(self, channel, client): 2876 self.parent = client 2877 self.stub = GroupsHistoryStub(channel) 2878 2879 def list(self, filter, *args, timeout=None): 2880 ''' 2881 List gets a list of GroupHistory records matching a given set of criteria. 2882 ''' 2883 deadline = None if timeout is None else time.time() + timeout 2884 req = GroupHistoryListRequest() 2885 req.meta.CopyFrom(ListRequestMetadata()) 2886 if self.parent.page_limit > 0: 2887 req.meta.limit = self.parent.page_limit 2888 if self.parent.snapshot_datetime is not None: 2889 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2890 2891 req.filter = plumbing.quote_filter_args(filter, *args) 2892 2893 def generator(svc, req): 2894 tries = 0 2895 while True: 2896 t = None if deadline is None else deadline - time.time() 2897 try: 2898 plumbing_response = svc.stub.List( 2899 req, 2900 metadata=svc.parent.get_metadata( 2901 'GroupsHistory.List', req), 2902 timeout=t) 2903 except Exception as e: 2904 if self.parent.shouldRetry(tries, e, deadline): 2905 tries += 1 2906 time.sleep( 2907 self.parent.exponentialBackoff(tries, deadline)) 2908 continue 2909 raise plumbing.convert_error_to_porcelain(e) from e 2910 tries = 0 2911 for plumbing_item in plumbing_response.history: 2912 yield plumbing.convert_group_history_to_porcelain( 2913 plumbing_item) 2914 if plumbing_response.meta.next_cursor == '': 2915 break 2916 req.meta.cursor = plumbing_response.meta.next_cursor 2917 2918 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)
2879 def list(self, filter, *args, timeout=None): 2880 ''' 2881 List gets a list of GroupHistory records matching a given set of criteria. 2882 ''' 2883 deadline = None if timeout is None else time.time() + timeout 2884 req = GroupHistoryListRequest() 2885 req.meta.CopyFrom(ListRequestMetadata()) 2886 if self.parent.page_limit > 0: 2887 req.meta.limit = self.parent.page_limit 2888 if self.parent.snapshot_datetime is not None: 2889 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2890 2891 req.filter = plumbing.quote_filter_args(filter, *args) 2892 2893 def generator(svc, req): 2894 tries = 0 2895 while True: 2896 t = None if deadline is None else deadline - time.time() 2897 try: 2898 plumbing_response = svc.stub.List( 2899 req, 2900 metadata=svc.parent.get_metadata( 2901 'GroupsHistory.List', req), 2902 timeout=t) 2903 except Exception as e: 2904 if self.parent.shouldRetry(tries, e, deadline): 2905 tries += 1 2906 time.sleep( 2907 self.parent.exponentialBackoff(tries, deadline)) 2908 continue 2909 raise plumbing.convert_error_to_porcelain(e) from e 2910 tries = 0 2911 for plumbing_item in plumbing_response.history: 2912 yield plumbing.convert_group_history_to_porcelain( 2913 plumbing_item) 2914 if plumbing_response.meta.next_cursor == '': 2915 break 2916 req.meta.cursor = plumbing_response.meta.next_cursor 2917 2918 return generator(self, req)
List gets a list of GroupHistory records matching a given set of criteria.
class
GroupsRoles:
2921class GroupsRoles: 2922 ''' 2923 A GroupRole is an assignment of a Group to a Role. 2924 See `strongdm.models.GroupRole`. 2925 ''' 2926 def __init__(self, channel, client): 2927 self.parent = client 2928 self.stub = GroupsRolesStub(channel) 2929 2930 def create(self, group_role, timeout=None): 2931 ''' 2932 Create registers a new GroupRole. 2933 ''' 2934 deadline = None if timeout is None else time.time() + timeout 2935 req = GroupRoleCreateRequest() 2936 2937 if group_role is not None: 2938 req.group_role.CopyFrom( 2939 plumbing.convert_group_role_to_plumbing(group_role)) 2940 tries = 0 2941 plumbing_response = None 2942 while True: 2943 t = None if deadline is None else deadline - time.time() 2944 try: 2945 plumbing_response = self.stub.Create( 2946 req, 2947 metadata=self.parent.get_metadata('GroupsRoles.Create', 2948 req), 2949 timeout=t) 2950 except Exception as e: 2951 if self.parent.shouldRetry(tries, e, deadline): 2952 tries += 1 2953 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2954 continue 2955 raise plumbing.convert_error_to_porcelain(e) from e 2956 break 2957 2958 resp = models.GroupRoleCreateResponse() 2959 resp.group_role = plumbing.convert_group_role_to_porcelain( 2960 plumbing_response.group_role) 2961 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2962 plumbing_response.rate_limit) 2963 return resp 2964 2965 def get(self, id, timeout=None): 2966 ''' 2967 Get reads one GroupRole by ID. 2968 ''' 2969 deadline = None if timeout is None else time.time() + timeout 2970 req = GroupRoleGetRequest() 2971 if self.parent.snapshot_datetime is not None: 2972 req.meta.CopyFrom(GetRequestMetadata()) 2973 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2974 2975 req.id = (id) 2976 tries = 0 2977 plumbing_response = None 2978 while True: 2979 t = None if deadline is None else deadline - time.time() 2980 try: 2981 plumbing_response = self.stub.Get( 2982 req, 2983 metadata=self.parent.get_metadata('GroupsRoles.Get', req), 2984 timeout=t) 2985 except Exception as e: 2986 if self.parent.shouldRetry(tries, e, deadline): 2987 tries += 1 2988 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2989 continue 2990 raise plumbing.convert_error_to_porcelain(e) from e 2991 break 2992 2993 resp = models.GroupRoleGetResponse() 2994 resp.group_role = plumbing.convert_group_role_to_porcelain( 2995 plumbing_response.group_role) 2996 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2997 plumbing_response.meta) 2998 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2999 plumbing_response.rate_limit) 3000 return resp 3001 3002 def delete(self, id, timeout=None): 3003 ''' 3004 Delete removes a GroupRole by ID. 3005 ''' 3006 deadline = None if timeout is None else time.time() + timeout 3007 req = GroupRoleDeleteRequest() 3008 3009 req.id = (id) 3010 tries = 0 3011 plumbing_response = None 3012 while True: 3013 t = None if deadline is None else deadline - time.time() 3014 try: 3015 plumbing_response = self.stub.Delete( 3016 req, 3017 metadata=self.parent.get_metadata('GroupsRoles.Delete', 3018 req), 3019 timeout=t) 3020 except Exception as e: 3021 if self.parent.shouldRetry(tries, e, deadline): 3022 tries += 1 3023 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3024 continue 3025 raise plumbing.convert_error_to_porcelain(e) from e 3026 break 3027 3028 resp = models.GroupRoleDeleteResponse() 3029 resp.group_role = plumbing.convert_group_role_to_porcelain( 3030 plumbing_response.group_role) 3031 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3032 plumbing_response.meta) 3033 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3034 plumbing_response.rate_limit) 3035 return resp 3036 3037 def list(self, filter, *args, timeout=None): 3038 ''' 3039 List gets a list of GroupRoles matching a given set of criteria. 3040 ''' 3041 deadline = None if timeout is None else time.time() + timeout 3042 req = GroupRoleListRequest() 3043 req.meta.CopyFrom(ListRequestMetadata()) 3044 if self.parent.page_limit > 0: 3045 req.meta.limit = self.parent.page_limit 3046 if self.parent.snapshot_datetime is not None: 3047 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3048 3049 req.filter = plumbing.quote_filter_args(filter, *args) 3050 3051 def generator(svc, req): 3052 tries = 0 3053 while True: 3054 t = None if deadline is None else deadline - time.time() 3055 try: 3056 plumbing_response = svc.stub.List( 3057 req, 3058 metadata=svc.parent.get_metadata( 3059 'GroupsRoles.List', req), 3060 timeout=t) 3061 except Exception as e: 3062 if self.parent.shouldRetry(tries, e, deadline): 3063 tries += 1 3064 time.sleep( 3065 self.parent.exponentialBackoff(tries, deadline)) 3066 continue 3067 raise plumbing.convert_error_to_porcelain(e) from e 3068 tries = 0 3069 for plumbing_item in plumbing_response.groups_roles: 3070 yield plumbing.convert_group_role_to_porcelain( 3071 plumbing_item) 3072 if plumbing_response.meta.next_cursor == '': 3073 break 3074 req.meta.cursor = plumbing_response.meta.next_cursor 3075 3076 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)
2930 def create(self, group_role, timeout=None): 2931 ''' 2932 Create registers a new GroupRole. 2933 ''' 2934 deadline = None if timeout is None else time.time() + timeout 2935 req = GroupRoleCreateRequest() 2936 2937 if group_role is not None: 2938 req.group_role.CopyFrom( 2939 plumbing.convert_group_role_to_plumbing(group_role)) 2940 tries = 0 2941 plumbing_response = None 2942 while True: 2943 t = None if deadline is None else deadline - time.time() 2944 try: 2945 plumbing_response = self.stub.Create( 2946 req, 2947 metadata=self.parent.get_metadata('GroupsRoles.Create', 2948 req), 2949 timeout=t) 2950 except Exception as e: 2951 if self.parent.shouldRetry(tries, e, deadline): 2952 tries += 1 2953 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2954 continue 2955 raise plumbing.convert_error_to_porcelain(e) from e 2956 break 2957 2958 resp = models.GroupRoleCreateResponse() 2959 resp.group_role = plumbing.convert_group_role_to_porcelain( 2960 plumbing_response.group_role) 2961 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2962 plumbing_response.rate_limit) 2963 return resp
Create registers a new GroupRole.
def
get(self, id, timeout=None)
2965 def get(self, id, timeout=None): 2966 ''' 2967 Get reads one GroupRole by ID. 2968 ''' 2969 deadline = None if timeout is None else time.time() + timeout 2970 req = GroupRoleGetRequest() 2971 if self.parent.snapshot_datetime is not None: 2972 req.meta.CopyFrom(GetRequestMetadata()) 2973 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 2974 2975 req.id = (id) 2976 tries = 0 2977 plumbing_response = None 2978 while True: 2979 t = None if deadline is None else deadline - time.time() 2980 try: 2981 plumbing_response = self.stub.Get( 2982 req, 2983 metadata=self.parent.get_metadata('GroupsRoles.Get', req), 2984 timeout=t) 2985 except Exception as e: 2986 if self.parent.shouldRetry(tries, e, deadline): 2987 tries += 1 2988 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 2989 continue 2990 raise plumbing.convert_error_to_porcelain(e) from e 2991 break 2992 2993 resp = models.GroupRoleGetResponse() 2994 resp.group_role = plumbing.convert_group_role_to_porcelain( 2995 plumbing_response.group_role) 2996 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 2997 plumbing_response.meta) 2998 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 2999 plumbing_response.rate_limit) 3000 return resp
Get reads one GroupRole by ID.
def
delete(self, id, timeout=None)
3002 def delete(self, id, timeout=None): 3003 ''' 3004 Delete removes a GroupRole by ID. 3005 ''' 3006 deadline = None if timeout is None else time.time() + timeout 3007 req = GroupRoleDeleteRequest() 3008 3009 req.id = (id) 3010 tries = 0 3011 plumbing_response = None 3012 while True: 3013 t = None if deadline is None else deadline - time.time() 3014 try: 3015 plumbing_response = self.stub.Delete( 3016 req, 3017 metadata=self.parent.get_metadata('GroupsRoles.Delete', 3018 req), 3019 timeout=t) 3020 except Exception as e: 3021 if self.parent.shouldRetry(tries, e, deadline): 3022 tries += 1 3023 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3024 continue 3025 raise plumbing.convert_error_to_porcelain(e) from e 3026 break 3027 3028 resp = models.GroupRoleDeleteResponse() 3029 resp.group_role = plumbing.convert_group_role_to_porcelain( 3030 plumbing_response.group_role) 3031 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3032 plumbing_response.meta) 3033 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3034 plumbing_response.rate_limit) 3035 return resp
Delete removes a GroupRole by ID.
def
list(self, filter, *args, timeout=None)
3037 def list(self, filter, *args, timeout=None): 3038 ''' 3039 List gets a list of GroupRoles matching a given set of criteria. 3040 ''' 3041 deadline = None if timeout is None else time.time() + timeout 3042 req = GroupRoleListRequest() 3043 req.meta.CopyFrom(ListRequestMetadata()) 3044 if self.parent.page_limit > 0: 3045 req.meta.limit = self.parent.page_limit 3046 if self.parent.snapshot_datetime is not None: 3047 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3048 3049 req.filter = plumbing.quote_filter_args(filter, *args) 3050 3051 def generator(svc, req): 3052 tries = 0 3053 while True: 3054 t = None if deadline is None else deadline - time.time() 3055 try: 3056 plumbing_response = svc.stub.List( 3057 req, 3058 metadata=svc.parent.get_metadata( 3059 'GroupsRoles.List', req), 3060 timeout=t) 3061 except Exception as e: 3062 if self.parent.shouldRetry(tries, e, deadline): 3063 tries += 1 3064 time.sleep( 3065 self.parent.exponentialBackoff(tries, deadline)) 3066 continue 3067 raise plumbing.convert_error_to_porcelain(e) from e 3068 tries = 0 3069 for plumbing_item in plumbing_response.groups_roles: 3070 yield plumbing.convert_group_role_to_porcelain( 3071 plumbing_item) 3072 if plumbing_response.meta.next_cursor == '': 3073 break 3074 req.meta.cursor = plumbing_response.meta.next_cursor 3075 3076 return generator(self, req)
List gets a list of GroupRoles matching a given set of criteria.
class
SnapshotGroupsRoles:
3079class SnapshotGroupsRoles: 3080 ''' 3081 SnapshotGroupsRoles exposes the read only methods of the GroupsRoles 3082 service for historical queries. 3083 ''' 3084 def __init__(self, groups_roles): 3085 self.groups_roles = groups_roles 3086 3087 def get(self, id, timeout=None): 3088 ''' 3089 Get reads one GroupRole by ID. 3090 ''' 3091 return self.groups_roles.get(id, timeout=timeout) 3092 3093 def list(self, filter, *args, timeout=None): 3094 ''' 3095 List gets a list of GroupRoles matching a given set of criteria. 3096 ''' 3097 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)
3087 def get(self, id, timeout=None): 3088 ''' 3089 Get reads one GroupRole by ID. 3090 ''' 3091 return self.groups_roles.get(id, timeout=timeout)
Get reads one GroupRole by ID.
def
list(self, filter, *args, timeout=None)
3093 def list(self, filter, *args, timeout=None): 3094 ''' 3095 List gets a list of GroupRoles matching a given set of criteria. 3096 ''' 3097 return self.groups_roles.list(filter, *args, timeout=timeout)
List gets a list of GroupRoles matching a given set of criteria.
class
GroupsRolesHistory:
3100class GroupsRolesHistory: 3101 ''' 3102 GroupsRolesHistory records all changes to the state of a GroupRole. 3103 See `strongdm.models.GroupRoleHistory`. 3104 ''' 3105 def __init__(self, channel, client): 3106 self.parent = client 3107 self.stub = GroupsRolesHistoryStub(channel) 3108 3109 def list(self, filter, *args, timeout=None): 3110 ''' 3111 List gets a list of GroupRoleHistory records matching a given set of criteria. 3112 ''' 3113 deadline = None if timeout is None else time.time() + timeout 3114 req = GroupRoleHistoryListRequest() 3115 req.meta.CopyFrom(ListRequestMetadata()) 3116 if self.parent.page_limit > 0: 3117 req.meta.limit = self.parent.page_limit 3118 if self.parent.snapshot_datetime is not None: 3119 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3120 3121 req.filter = plumbing.quote_filter_args(filter, *args) 3122 3123 def generator(svc, req): 3124 tries = 0 3125 while True: 3126 t = None if deadline is None else deadline - time.time() 3127 try: 3128 plumbing_response = svc.stub.List( 3129 req, 3130 metadata=svc.parent.get_metadata( 3131 'GroupsRolesHistory.List', req), 3132 timeout=t) 3133 except Exception as e: 3134 if self.parent.shouldRetry(tries, e, deadline): 3135 tries += 1 3136 time.sleep( 3137 self.parent.exponentialBackoff(tries, deadline)) 3138 continue 3139 raise plumbing.convert_error_to_porcelain(e) from e 3140 tries = 0 3141 for plumbing_item in plumbing_response.history: 3142 yield plumbing.convert_group_role_history_to_porcelain( 3143 plumbing_item) 3144 if plumbing_response.meta.next_cursor == '': 3145 break 3146 req.meta.cursor = plumbing_response.meta.next_cursor 3147 3148 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)
3109 def list(self, filter, *args, timeout=None): 3110 ''' 3111 List gets a list of GroupRoleHistory records matching a given set of criteria. 3112 ''' 3113 deadline = None if timeout is None else time.time() + timeout 3114 req = GroupRoleHistoryListRequest() 3115 req.meta.CopyFrom(ListRequestMetadata()) 3116 if self.parent.page_limit > 0: 3117 req.meta.limit = self.parent.page_limit 3118 if self.parent.snapshot_datetime is not None: 3119 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3120 3121 req.filter = plumbing.quote_filter_args(filter, *args) 3122 3123 def generator(svc, req): 3124 tries = 0 3125 while True: 3126 t = None if deadline is None else deadline - time.time() 3127 try: 3128 plumbing_response = svc.stub.List( 3129 req, 3130 metadata=svc.parent.get_metadata( 3131 'GroupsRolesHistory.List', req), 3132 timeout=t) 3133 except Exception as e: 3134 if self.parent.shouldRetry(tries, e, deadline): 3135 tries += 1 3136 time.sleep( 3137 self.parent.exponentialBackoff(tries, deadline)) 3138 continue 3139 raise plumbing.convert_error_to_porcelain(e) from e 3140 tries = 0 3141 for plumbing_item in plumbing_response.history: 3142 yield plumbing.convert_group_role_history_to_porcelain( 3143 plumbing_item) 3144 if plumbing_response.meta.next_cursor == '': 3145 break 3146 req.meta.cursor = plumbing_response.meta.next_cursor 3147 3148 return generator(self, req)
List gets a list of GroupRoleHistory records matching a given set of criteria.
class
HealthChecks:
3151class HealthChecks: 3152 ''' 3153 HealthChecks lists the last healthcheck between each node and resource. 3154 Note the unconventional capitalization here is to prevent having a collision with GRPC 3155 See `strongdm.models.Healthcheck`. 3156 ''' 3157 def __init__(self, channel, client): 3158 self.parent = client 3159 self.stub = HealthChecksStub(channel) 3160 3161 def list(self, filter, *args, timeout=None): 3162 ''' 3163 List gets a list of Healthchecks matching a given set of criteria. 3164 ''' 3165 deadline = None if timeout is None else time.time() + timeout 3166 req = HealthcheckListRequest() 3167 req.meta.CopyFrom(ListRequestMetadata()) 3168 if self.parent.page_limit > 0: 3169 req.meta.limit = self.parent.page_limit 3170 if self.parent.snapshot_datetime is not None: 3171 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3172 3173 req.filter = plumbing.quote_filter_args(filter, *args) 3174 3175 def generator(svc, req): 3176 tries = 0 3177 while True: 3178 t = None if deadline is None else deadline - time.time() 3179 try: 3180 plumbing_response = svc.stub.List( 3181 req, 3182 metadata=svc.parent.get_metadata( 3183 'HealthChecks.List', req), 3184 timeout=t) 3185 except Exception as e: 3186 if self.parent.shouldRetry(tries, e, deadline): 3187 tries += 1 3188 time.sleep( 3189 self.parent.exponentialBackoff(tries, deadline)) 3190 continue 3191 raise plumbing.convert_error_to_porcelain(e) from e 3192 tries = 0 3193 for plumbing_item in plumbing_response.healthchecks: 3194 yield plumbing.convert_healthcheck_to_porcelain( 3195 plumbing_item) 3196 if plumbing_response.meta.next_cursor == '': 3197 break 3198 req.meta.cursor = plumbing_response.meta.next_cursor 3199 3200 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)
3161 def list(self, filter, *args, timeout=None): 3162 ''' 3163 List gets a list of Healthchecks matching a given set of criteria. 3164 ''' 3165 deadline = None if timeout is None else time.time() + timeout 3166 req = HealthcheckListRequest() 3167 req.meta.CopyFrom(ListRequestMetadata()) 3168 if self.parent.page_limit > 0: 3169 req.meta.limit = self.parent.page_limit 3170 if self.parent.snapshot_datetime is not None: 3171 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3172 3173 req.filter = plumbing.quote_filter_args(filter, *args) 3174 3175 def generator(svc, req): 3176 tries = 0 3177 while True: 3178 t = None if deadline is None else deadline - time.time() 3179 try: 3180 plumbing_response = svc.stub.List( 3181 req, 3182 metadata=svc.parent.get_metadata( 3183 'HealthChecks.List', req), 3184 timeout=t) 3185 except Exception as e: 3186 if self.parent.shouldRetry(tries, e, deadline): 3187 tries += 1 3188 time.sleep( 3189 self.parent.exponentialBackoff(tries, deadline)) 3190 continue 3191 raise plumbing.convert_error_to_porcelain(e) from e 3192 tries = 0 3193 for plumbing_item in plumbing_response.healthchecks: 3194 yield plumbing.convert_healthcheck_to_porcelain( 3195 plumbing_item) 3196 if plumbing_response.meta.next_cursor == '': 3197 break 3198 req.meta.cursor = plumbing_response.meta.next_cursor 3199 3200 return generator(self, req)
List gets a list of Healthchecks matching a given set of criteria.
class
IdentityAliases:
3203class IdentityAliases: 3204 ''' 3205 IdentityAliases assign an alias to an account within an IdentitySet. 3206 The alias is used as the username when connecting to a identity supported resource. 3207 See `strongdm.models.IdentityAlias`. 3208 ''' 3209 def __init__(self, channel, client): 3210 self.parent = client 3211 self.stub = IdentityAliasesStub(channel) 3212 3213 def create(self, identity_alias, timeout=None): 3214 ''' 3215 Create registers a new IdentityAlias. 3216 ''' 3217 deadline = None if timeout is None else time.time() + timeout 3218 req = IdentityAliasCreateRequest() 3219 3220 if identity_alias is not None: 3221 req.identity_alias.CopyFrom( 3222 plumbing.convert_identity_alias_to_plumbing(identity_alias)) 3223 tries = 0 3224 plumbing_response = None 3225 while True: 3226 t = None if deadline is None else deadline - time.time() 3227 try: 3228 plumbing_response = self.stub.Create( 3229 req, 3230 metadata=self.parent.get_metadata('IdentityAliases.Create', 3231 req), 3232 timeout=t) 3233 except Exception as e: 3234 if self.parent.shouldRetry(tries, e, deadline): 3235 tries += 1 3236 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3237 continue 3238 raise plumbing.convert_error_to_porcelain(e) from e 3239 break 3240 3241 resp = models.IdentityAliasCreateResponse() 3242 resp.identity_alias = plumbing.convert_identity_alias_to_porcelain( 3243 plumbing_response.identity_alias) 3244 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 3245 plumbing_response.meta) 3246 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3247 plumbing_response.rate_limit) 3248 return resp 3249 3250 def get(self, id, timeout=None): 3251 ''' 3252 Get reads one IdentityAlias by ID. 3253 ''' 3254 deadline = None if timeout is None else time.time() + timeout 3255 req = IdentityAliasGetRequest() 3256 if self.parent.snapshot_datetime is not None: 3257 req.meta.CopyFrom(GetRequestMetadata()) 3258 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3259 3260 req.id = (id) 3261 tries = 0 3262 plumbing_response = None 3263 while True: 3264 t = None if deadline is None else deadline - time.time() 3265 try: 3266 plumbing_response = self.stub.Get( 3267 req, 3268 metadata=self.parent.get_metadata('IdentityAliases.Get', 3269 req), 3270 timeout=t) 3271 except Exception as e: 3272 if self.parent.shouldRetry(tries, e, deadline): 3273 tries += 1 3274 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3275 continue 3276 raise plumbing.convert_error_to_porcelain(e) from e 3277 break 3278 3279 resp = models.IdentityAliasGetResponse() 3280 resp.identity_alias = plumbing.convert_identity_alias_to_porcelain( 3281 plumbing_response.identity_alias) 3282 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3283 plumbing_response.meta) 3284 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3285 plumbing_response.rate_limit) 3286 return resp 3287 3288 def update(self, identity_alias, timeout=None): 3289 ''' 3290 Update replaces all the fields of a IdentityAlias by ID. 3291 ''' 3292 deadline = None if timeout is None else time.time() + timeout 3293 req = IdentityAliasUpdateRequest() 3294 3295 if identity_alias is not None: 3296 req.identity_alias.CopyFrom( 3297 plumbing.convert_identity_alias_to_plumbing(identity_alias)) 3298 tries = 0 3299 plumbing_response = None 3300 while True: 3301 t = None if deadline is None else deadline - time.time() 3302 try: 3303 plumbing_response = self.stub.Update( 3304 req, 3305 metadata=self.parent.get_metadata('IdentityAliases.Update', 3306 req), 3307 timeout=t) 3308 except Exception as e: 3309 if self.parent.shouldRetry(tries, e, deadline): 3310 tries += 1 3311 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3312 continue 3313 raise plumbing.convert_error_to_porcelain(e) from e 3314 break 3315 3316 resp = models.IdentityAliasUpdateResponse() 3317 resp.identity_alias = plumbing.convert_identity_alias_to_porcelain( 3318 plumbing_response.identity_alias) 3319 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 3320 plumbing_response.meta) 3321 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3322 plumbing_response.rate_limit) 3323 return resp 3324 3325 def delete(self, id, timeout=None): 3326 ''' 3327 Delete removes a IdentityAlias by ID. 3328 ''' 3329 deadline = None if timeout is None else time.time() + timeout 3330 req = IdentityAliasDeleteRequest() 3331 3332 req.id = (id) 3333 tries = 0 3334 plumbing_response = None 3335 while True: 3336 t = None if deadline is None else deadline - time.time() 3337 try: 3338 plumbing_response = self.stub.Delete( 3339 req, 3340 metadata=self.parent.get_metadata('IdentityAliases.Delete', 3341 req), 3342 timeout=t) 3343 except Exception as e: 3344 if self.parent.shouldRetry(tries, e, deadline): 3345 tries += 1 3346 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3347 continue 3348 raise plumbing.convert_error_to_porcelain(e) from e 3349 break 3350 3351 resp = models.IdentityAliasDeleteResponse() 3352 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3353 plumbing_response.meta) 3354 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3355 plumbing_response.rate_limit) 3356 return resp 3357 3358 def list(self, filter, *args, timeout=None): 3359 ''' 3360 List gets a list of IdentityAliases matching a given set of criteria. 3361 ''' 3362 deadline = None if timeout is None else time.time() + timeout 3363 req = IdentityAliasListRequest() 3364 req.meta.CopyFrom(ListRequestMetadata()) 3365 if self.parent.page_limit > 0: 3366 req.meta.limit = self.parent.page_limit 3367 if self.parent.snapshot_datetime is not None: 3368 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3369 3370 req.filter = plumbing.quote_filter_args(filter, *args) 3371 3372 def generator(svc, req): 3373 tries = 0 3374 while True: 3375 t = None if deadline is None else deadline - time.time() 3376 try: 3377 plumbing_response = svc.stub.List( 3378 req, 3379 metadata=svc.parent.get_metadata( 3380 'IdentityAliases.List', req), 3381 timeout=t) 3382 except Exception as e: 3383 if self.parent.shouldRetry(tries, e, deadline): 3384 tries += 1 3385 time.sleep( 3386 self.parent.exponentialBackoff(tries, deadline)) 3387 continue 3388 raise plumbing.convert_error_to_porcelain(e) from e 3389 tries = 0 3390 for plumbing_item in plumbing_response.identity_aliases: 3391 yield plumbing.convert_identity_alias_to_porcelain( 3392 plumbing_item) 3393 if plumbing_response.meta.next_cursor == '': 3394 break 3395 req.meta.cursor = plumbing_response.meta.next_cursor 3396 3397 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)
3213 def create(self, identity_alias, timeout=None): 3214 ''' 3215 Create registers a new IdentityAlias. 3216 ''' 3217 deadline = None if timeout is None else time.time() + timeout 3218 req = IdentityAliasCreateRequest() 3219 3220 if identity_alias is not None: 3221 req.identity_alias.CopyFrom( 3222 plumbing.convert_identity_alias_to_plumbing(identity_alias)) 3223 tries = 0 3224 plumbing_response = None 3225 while True: 3226 t = None if deadline is None else deadline - time.time() 3227 try: 3228 plumbing_response = self.stub.Create( 3229 req, 3230 metadata=self.parent.get_metadata('IdentityAliases.Create', 3231 req), 3232 timeout=t) 3233 except Exception as e: 3234 if self.parent.shouldRetry(tries, e, deadline): 3235 tries += 1 3236 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3237 continue 3238 raise plumbing.convert_error_to_porcelain(e) from e 3239 break 3240 3241 resp = models.IdentityAliasCreateResponse() 3242 resp.identity_alias = plumbing.convert_identity_alias_to_porcelain( 3243 plumbing_response.identity_alias) 3244 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 3245 plumbing_response.meta) 3246 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3247 plumbing_response.rate_limit) 3248 return resp
Create registers a new IdentityAlias.
def
get(self, id, timeout=None)
3250 def get(self, id, timeout=None): 3251 ''' 3252 Get reads one IdentityAlias by ID. 3253 ''' 3254 deadline = None if timeout is None else time.time() + timeout 3255 req = IdentityAliasGetRequest() 3256 if self.parent.snapshot_datetime is not None: 3257 req.meta.CopyFrom(GetRequestMetadata()) 3258 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3259 3260 req.id = (id) 3261 tries = 0 3262 plumbing_response = None 3263 while True: 3264 t = None if deadline is None else deadline - time.time() 3265 try: 3266 plumbing_response = self.stub.Get( 3267 req, 3268 metadata=self.parent.get_metadata('IdentityAliases.Get', 3269 req), 3270 timeout=t) 3271 except Exception as e: 3272 if self.parent.shouldRetry(tries, e, deadline): 3273 tries += 1 3274 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3275 continue 3276 raise plumbing.convert_error_to_porcelain(e) from e 3277 break 3278 3279 resp = models.IdentityAliasGetResponse() 3280 resp.identity_alias = plumbing.convert_identity_alias_to_porcelain( 3281 plumbing_response.identity_alias) 3282 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3283 plumbing_response.meta) 3284 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3285 plumbing_response.rate_limit) 3286 return resp
Get reads one IdentityAlias by ID.
def
update(self, identity_alias, timeout=None)
3288 def update(self, identity_alias, timeout=None): 3289 ''' 3290 Update replaces all the fields of a IdentityAlias by ID. 3291 ''' 3292 deadline = None if timeout is None else time.time() + timeout 3293 req = IdentityAliasUpdateRequest() 3294 3295 if identity_alias is not None: 3296 req.identity_alias.CopyFrom( 3297 plumbing.convert_identity_alias_to_plumbing(identity_alias)) 3298 tries = 0 3299 plumbing_response = None 3300 while True: 3301 t = None if deadline is None else deadline - time.time() 3302 try: 3303 plumbing_response = self.stub.Update( 3304 req, 3305 metadata=self.parent.get_metadata('IdentityAliases.Update', 3306 req), 3307 timeout=t) 3308 except Exception as e: 3309 if self.parent.shouldRetry(tries, e, deadline): 3310 tries += 1 3311 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3312 continue 3313 raise plumbing.convert_error_to_porcelain(e) from e 3314 break 3315 3316 resp = models.IdentityAliasUpdateResponse() 3317 resp.identity_alias = plumbing.convert_identity_alias_to_porcelain( 3318 plumbing_response.identity_alias) 3319 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 3320 plumbing_response.meta) 3321 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3322 plumbing_response.rate_limit) 3323 return resp
Update replaces all the fields of a IdentityAlias by ID.
def
delete(self, id, timeout=None)
3325 def delete(self, id, timeout=None): 3326 ''' 3327 Delete removes a IdentityAlias by ID. 3328 ''' 3329 deadline = None if timeout is None else time.time() + timeout 3330 req = IdentityAliasDeleteRequest() 3331 3332 req.id = (id) 3333 tries = 0 3334 plumbing_response = None 3335 while True: 3336 t = None if deadline is None else deadline - time.time() 3337 try: 3338 plumbing_response = self.stub.Delete( 3339 req, 3340 metadata=self.parent.get_metadata('IdentityAliases.Delete', 3341 req), 3342 timeout=t) 3343 except Exception as e: 3344 if self.parent.shouldRetry(tries, e, deadline): 3345 tries += 1 3346 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3347 continue 3348 raise plumbing.convert_error_to_porcelain(e) from e 3349 break 3350 3351 resp = models.IdentityAliasDeleteResponse() 3352 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3353 plumbing_response.meta) 3354 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3355 plumbing_response.rate_limit) 3356 return resp
Delete removes a IdentityAlias by ID.
def
list(self, filter, *args, timeout=None)
3358 def list(self, filter, *args, timeout=None): 3359 ''' 3360 List gets a list of IdentityAliases matching a given set of criteria. 3361 ''' 3362 deadline = None if timeout is None else time.time() + timeout 3363 req = IdentityAliasListRequest() 3364 req.meta.CopyFrom(ListRequestMetadata()) 3365 if self.parent.page_limit > 0: 3366 req.meta.limit = self.parent.page_limit 3367 if self.parent.snapshot_datetime is not None: 3368 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3369 3370 req.filter = plumbing.quote_filter_args(filter, *args) 3371 3372 def generator(svc, req): 3373 tries = 0 3374 while True: 3375 t = None if deadline is None else deadline - time.time() 3376 try: 3377 plumbing_response = svc.stub.List( 3378 req, 3379 metadata=svc.parent.get_metadata( 3380 'IdentityAliases.List', req), 3381 timeout=t) 3382 except Exception as e: 3383 if self.parent.shouldRetry(tries, e, deadline): 3384 tries += 1 3385 time.sleep( 3386 self.parent.exponentialBackoff(tries, deadline)) 3387 continue 3388 raise plumbing.convert_error_to_porcelain(e) from e 3389 tries = 0 3390 for plumbing_item in plumbing_response.identity_aliases: 3391 yield plumbing.convert_identity_alias_to_porcelain( 3392 plumbing_item) 3393 if plumbing_response.meta.next_cursor == '': 3394 break 3395 req.meta.cursor = plumbing_response.meta.next_cursor 3396 3397 return generator(self, req)
List gets a list of IdentityAliases matching a given set of criteria.
class
SnapshotIdentityAliases:
3400class SnapshotIdentityAliases: 3401 ''' 3402 SnapshotIdentityAliases exposes the read only methods of the IdentityAliases 3403 service for historical queries. 3404 ''' 3405 def __init__(self, identity_aliases): 3406 self.identity_aliases = identity_aliases 3407 3408 def get(self, id, timeout=None): 3409 ''' 3410 Get reads one IdentityAlias by ID. 3411 ''' 3412 return self.identity_aliases.get(id, timeout=timeout) 3413 3414 def list(self, filter, *args, timeout=None): 3415 ''' 3416 List gets a list of IdentityAliases matching a given set of criteria. 3417 ''' 3418 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)
3408 def get(self, id, timeout=None): 3409 ''' 3410 Get reads one IdentityAlias by ID. 3411 ''' 3412 return self.identity_aliases.get(id, timeout=timeout)
Get reads one IdentityAlias by ID.
def
list(self, filter, *args, timeout=None)
3414 def list(self, filter, *args, timeout=None): 3415 ''' 3416 List gets a list of IdentityAliases matching a given set of criteria. 3417 ''' 3418 return self.identity_aliases.list(filter, *args, timeout=timeout)
List gets a list of IdentityAliases matching a given set of criteria.
class
IdentityAliasesHistory:
3421class IdentityAliasesHistory: 3422 ''' 3423 IdentityAliasesHistory records all changes to the state of a IdentityAlias. 3424 See `strongdm.models.IdentityAliasHistory`. 3425 ''' 3426 def __init__(self, channel, client): 3427 self.parent = client 3428 self.stub = IdentityAliasesHistoryStub(channel) 3429 3430 def list(self, filter, *args, timeout=None): 3431 ''' 3432 List gets a list of IdentityAliasHistory records matching a given set of criteria. 3433 ''' 3434 deadline = None if timeout is None else time.time() + timeout 3435 req = IdentityAliasHistoryListRequest() 3436 req.meta.CopyFrom(ListRequestMetadata()) 3437 if self.parent.page_limit > 0: 3438 req.meta.limit = self.parent.page_limit 3439 if self.parent.snapshot_datetime is not None: 3440 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3441 3442 req.filter = plumbing.quote_filter_args(filter, *args) 3443 3444 def generator(svc, req): 3445 tries = 0 3446 while True: 3447 t = None if deadline is None else deadline - time.time() 3448 try: 3449 plumbing_response = svc.stub.List( 3450 req, 3451 metadata=svc.parent.get_metadata( 3452 'IdentityAliasesHistory.List', req), 3453 timeout=t) 3454 except Exception as e: 3455 if self.parent.shouldRetry(tries, e, deadline): 3456 tries += 1 3457 time.sleep( 3458 self.parent.exponentialBackoff(tries, deadline)) 3459 continue 3460 raise plumbing.convert_error_to_porcelain(e) from e 3461 tries = 0 3462 for plumbing_item in plumbing_response.history: 3463 yield plumbing.convert_identity_alias_history_to_porcelain( 3464 plumbing_item) 3465 if plumbing_response.meta.next_cursor == '': 3466 break 3467 req.meta.cursor = plumbing_response.meta.next_cursor 3468 3469 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)
3430 def list(self, filter, *args, timeout=None): 3431 ''' 3432 List gets a list of IdentityAliasHistory records matching a given set of criteria. 3433 ''' 3434 deadline = None if timeout is None else time.time() + timeout 3435 req = IdentityAliasHistoryListRequest() 3436 req.meta.CopyFrom(ListRequestMetadata()) 3437 if self.parent.page_limit > 0: 3438 req.meta.limit = self.parent.page_limit 3439 if self.parent.snapshot_datetime is not None: 3440 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3441 3442 req.filter = plumbing.quote_filter_args(filter, *args) 3443 3444 def generator(svc, req): 3445 tries = 0 3446 while True: 3447 t = None if deadline is None else deadline - time.time() 3448 try: 3449 plumbing_response = svc.stub.List( 3450 req, 3451 metadata=svc.parent.get_metadata( 3452 'IdentityAliasesHistory.List', req), 3453 timeout=t) 3454 except Exception as e: 3455 if self.parent.shouldRetry(tries, e, deadline): 3456 tries += 1 3457 time.sleep( 3458 self.parent.exponentialBackoff(tries, deadline)) 3459 continue 3460 raise plumbing.convert_error_to_porcelain(e) from e 3461 tries = 0 3462 for plumbing_item in plumbing_response.history: 3463 yield plumbing.convert_identity_alias_history_to_porcelain( 3464 plumbing_item) 3465 if plumbing_response.meta.next_cursor == '': 3466 break 3467 req.meta.cursor = plumbing_response.meta.next_cursor 3468 3469 return generator(self, req)
List gets a list of IdentityAliasHistory records matching a given set of criteria.
class
IdentitySets:
3472class IdentitySets: 3473 ''' 3474 A IdentitySet is a named grouping of Identity Aliases for Accounts. 3475 An Account's relationship to a IdentitySet is defined via IdentityAlias objects. 3476 See `strongdm.models.IdentitySet`. 3477 ''' 3478 def __init__(self, channel, client): 3479 self.parent = client 3480 self.stub = IdentitySetsStub(channel) 3481 3482 def create(self, identity_set, timeout=None): 3483 ''' 3484 Create registers a new IdentitySet. 3485 ''' 3486 deadline = None if timeout is None else time.time() + timeout 3487 req = IdentitySetCreateRequest() 3488 3489 if identity_set is not None: 3490 req.identity_set.CopyFrom( 3491 plumbing.convert_identity_set_to_plumbing(identity_set)) 3492 tries = 0 3493 plumbing_response = None 3494 while True: 3495 t = None if deadline is None else deadline - time.time() 3496 try: 3497 plumbing_response = self.stub.Create( 3498 req, 3499 metadata=self.parent.get_metadata('IdentitySets.Create', 3500 req), 3501 timeout=t) 3502 except Exception as e: 3503 if self.parent.shouldRetry(tries, e, deadline): 3504 tries += 1 3505 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3506 continue 3507 raise plumbing.convert_error_to_porcelain(e) from e 3508 break 3509 3510 resp = models.IdentitySetCreateResponse() 3511 resp.identity_set = plumbing.convert_identity_set_to_porcelain( 3512 plumbing_response.identity_set) 3513 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 3514 plumbing_response.meta) 3515 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3516 plumbing_response.rate_limit) 3517 return resp 3518 3519 def get(self, id, timeout=None): 3520 ''' 3521 Get reads one IdentitySet by ID. 3522 ''' 3523 deadline = None if timeout is None else time.time() + timeout 3524 req = IdentitySetGetRequest() 3525 if self.parent.snapshot_datetime is not None: 3526 req.meta.CopyFrom(GetRequestMetadata()) 3527 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3528 3529 req.id = (id) 3530 tries = 0 3531 plumbing_response = None 3532 while True: 3533 t = None if deadline is None else deadline - time.time() 3534 try: 3535 plumbing_response = self.stub.Get( 3536 req, 3537 metadata=self.parent.get_metadata('IdentitySets.Get', req), 3538 timeout=t) 3539 except Exception as e: 3540 if self.parent.shouldRetry(tries, e, deadline): 3541 tries += 1 3542 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3543 continue 3544 raise plumbing.convert_error_to_porcelain(e) from e 3545 break 3546 3547 resp = models.IdentitySetGetResponse() 3548 resp.identity_set = plumbing.convert_identity_set_to_porcelain( 3549 plumbing_response.identity_set) 3550 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3551 plumbing_response.meta) 3552 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3553 plumbing_response.rate_limit) 3554 return resp 3555 3556 def update(self, identity_set, timeout=None): 3557 ''' 3558 Update replaces all the fields of a IdentitySet by ID. 3559 ''' 3560 deadline = None if timeout is None else time.time() + timeout 3561 req = IdentitySetUpdateRequest() 3562 3563 if identity_set is not None: 3564 req.identity_set.CopyFrom( 3565 plumbing.convert_identity_set_to_plumbing(identity_set)) 3566 tries = 0 3567 plumbing_response = None 3568 while True: 3569 t = None if deadline is None else deadline - time.time() 3570 try: 3571 plumbing_response = self.stub.Update( 3572 req, 3573 metadata=self.parent.get_metadata('IdentitySets.Update', 3574 req), 3575 timeout=t) 3576 except Exception as e: 3577 if self.parent.shouldRetry(tries, e, deadline): 3578 tries += 1 3579 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3580 continue 3581 raise plumbing.convert_error_to_porcelain(e) from e 3582 break 3583 3584 resp = models.IdentitySetUpdateResponse() 3585 resp.identity_set = plumbing.convert_identity_set_to_porcelain( 3586 plumbing_response.identity_set) 3587 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 3588 plumbing_response.meta) 3589 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3590 plumbing_response.rate_limit) 3591 return resp 3592 3593 def delete(self, id, timeout=None): 3594 ''' 3595 Delete removes a IdentitySet by ID. 3596 ''' 3597 deadline = None if timeout is None else time.time() + timeout 3598 req = IdentitySetDeleteRequest() 3599 3600 req.id = (id) 3601 tries = 0 3602 plumbing_response = None 3603 while True: 3604 t = None if deadline is None else deadline - time.time() 3605 try: 3606 plumbing_response = self.stub.Delete( 3607 req, 3608 metadata=self.parent.get_metadata('IdentitySets.Delete', 3609 req), 3610 timeout=t) 3611 except Exception as e: 3612 if self.parent.shouldRetry(tries, e, deadline): 3613 tries += 1 3614 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3615 continue 3616 raise plumbing.convert_error_to_porcelain(e) from e 3617 break 3618 3619 resp = models.IdentitySetDeleteResponse() 3620 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3621 plumbing_response.meta) 3622 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3623 plumbing_response.rate_limit) 3624 return resp 3625 3626 def list(self, filter, *args, timeout=None): 3627 ''' 3628 List gets a list of IdentitySets matching a given set of criteria. 3629 ''' 3630 deadline = None if timeout is None else time.time() + timeout 3631 req = IdentitySetListRequest() 3632 req.meta.CopyFrom(ListRequestMetadata()) 3633 if self.parent.page_limit > 0: 3634 req.meta.limit = self.parent.page_limit 3635 if self.parent.snapshot_datetime is not None: 3636 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3637 3638 req.filter = plumbing.quote_filter_args(filter, *args) 3639 3640 def generator(svc, req): 3641 tries = 0 3642 while True: 3643 t = None if deadline is None else deadline - time.time() 3644 try: 3645 plumbing_response = svc.stub.List( 3646 req, 3647 metadata=svc.parent.get_metadata( 3648 'IdentitySets.List', req), 3649 timeout=t) 3650 except Exception as e: 3651 if self.parent.shouldRetry(tries, e, deadline): 3652 tries += 1 3653 time.sleep( 3654 self.parent.exponentialBackoff(tries, deadline)) 3655 continue 3656 raise plumbing.convert_error_to_porcelain(e) from e 3657 tries = 0 3658 for plumbing_item in plumbing_response.identity_sets: 3659 yield plumbing.convert_identity_set_to_porcelain( 3660 plumbing_item) 3661 if plumbing_response.meta.next_cursor == '': 3662 break 3663 req.meta.cursor = plumbing_response.meta.next_cursor 3664 3665 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)
3482 def create(self, identity_set, timeout=None): 3483 ''' 3484 Create registers a new IdentitySet. 3485 ''' 3486 deadline = None if timeout is None else time.time() + timeout 3487 req = IdentitySetCreateRequest() 3488 3489 if identity_set is not None: 3490 req.identity_set.CopyFrom( 3491 plumbing.convert_identity_set_to_plumbing(identity_set)) 3492 tries = 0 3493 plumbing_response = None 3494 while True: 3495 t = None if deadline is None else deadline - time.time() 3496 try: 3497 plumbing_response = self.stub.Create( 3498 req, 3499 metadata=self.parent.get_metadata('IdentitySets.Create', 3500 req), 3501 timeout=t) 3502 except Exception as e: 3503 if self.parent.shouldRetry(tries, e, deadline): 3504 tries += 1 3505 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3506 continue 3507 raise plumbing.convert_error_to_porcelain(e) from e 3508 break 3509 3510 resp = models.IdentitySetCreateResponse() 3511 resp.identity_set = plumbing.convert_identity_set_to_porcelain( 3512 plumbing_response.identity_set) 3513 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 3514 plumbing_response.meta) 3515 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3516 plumbing_response.rate_limit) 3517 return resp
Create registers a new IdentitySet.
def
get(self, id, timeout=None)
3519 def get(self, id, timeout=None): 3520 ''' 3521 Get reads one IdentitySet by ID. 3522 ''' 3523 deadline = None if timeout is None else time.time() + timeout 3524 req = IdentitySetGetRequest() 3525 if self.parent.snapshot_datetime is not None: 3526 req.meta.CopyFrom(GetRequestMetadata()) 3527 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3528 3529 req.id = (id) 3530 tries = 0 3531 plumbing_response = None 3532 while True: 3533 t = None if deadline is None else deadline - time.time() 3534 try: 3535 plumbing_response = self.stub.Get( 3536 req, 3537 metadata=self.parent.get_metadata('IdentitySets.Get', req), 3538 timeout=t) 3539 except Exception as e: 3540 if self.parent.shouldRetry(tries, e, deadline): 3541 tries += 1 3542 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3543 continue 3544 raise plumbing.convert_error_to_porcelain(e) from e 3545 break 3546 3547 resp = models.IdentitySetGetResponse() 3548 resp.identity_set = plumbing.convert_identity_set_to_porcelain( 3549 plumbing_response.identity_set) 3550 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 3551 plumbing_response.meta) 3552 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3553 plumbing_response.rate_limit) 3554 return resp
Get reads one IdentitySet by ID.
def
update(self, identity_set, timeout=None)
3556 def update(self, identity_set, timeout=None): 3557 ''' 3558 Update replaces all the fields of a IdentitySet by ID. 3559 ''' 3560 deadline = None if timeout is None else time.time() + timeout 3561 req = IdentitySetUpdateRequest() 3562 3563 if identity_set is not None: 3564 req.identity_set.CopyFrom( 3565 plumbing.convert_identity_set_to_plumbing(identity_set)) 3566 tries = 0 3567 plumbing_response = None 3568 while True: 3569 t = None if deadline is None else deadline - time.time() 3570 try: 3571 plumbing_response = self.stub.Update( 3572 req, 3573 metadata=self.parent.get_metadata('IdentitySets.Update', 3574 req), 3575 timeout=t) 3576 except Exception as e: 3577 if self.parent.shouldRetry(tries, e, deadline): 3578 tries += 1 3579 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3580 continue 3581 raise plumbing.convert_error_to_porcelain(e) from e 3582 break 3583 3584 resp = models.IdentitySetUpdateResponse() 3585 resp.identity_set = plumbing.convert_identity_set_to_porcelain( 3586 plumbing_response.identity_set) 3587 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 3588 plumbing_response.meta) 3589 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3590 plumbing_response.rate_limit) 3591 return resp
Update replaces all the fields of a IdentitySet by ID.
def
delete(self, id, timeout=None)
3593 def delete(self, id, timeout=None): 3594 ''' 3595 Delete removes a IdentitySet by ID. 3596 ''' 3597 deadline = None if timeout is None else time.time() + timeout 3598 req = IdentitySetDeleteRequest() 3599 3600 req.id = (id) 3601 tries = 0 3602 plumbing_response = None 3603 while True: 3604 t = None if deadline is None else deadline - time.time() 3605 try: 3606 plumbing_response = self.stub.Delete( 3607 req, 3608 metadata=self.parent.get_metadata('IdentitySets.Delete', 3609 req), 3610 timeout=t) 3611 except Exception as e: 3612 if self.parent.shouldRetry(tries, e, deadline): 3613 tries += 1 3614 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3615 continue 3616 raise plumbing.convert_error_to_porcelain(e) from e 3617 break 3618 3619 resp = models.IdentitySetDeleteResponse() 3620 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 3621 plumbing_response.meta) 3622 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3623 plumbing_response.rate_limit) 3624 return resp
Delete removes a IdentitySet by ID.
def
list(self, filter, *args, timeout=None)
3626 def list(self, filter, *args, timeout=None): 3627 ''' 3628 List gets a list of IdentitySets matching a given set of criteria. 3629 ''' 3630 deadline = None if timeout is None else time.time() + timeout 3631 req = IdentitySetListRequest() 3632 req.meta.CopyFrom(ListRequestMetadata()) 3633 if self.parent.page_limit > 0: 3634 req.meta.limit = self.parent.page_limit 3635 if self.parent.snapshot_datetime is not None: 3636 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3637 3638 req.filter = plumbing.quote_filter_args(filter, *args) 3639 3640 def generator(svc, req): 3641 tries = 0 3642 while True: 3643 t = None if deadline is None else deadline - time.time() 3644 try: 3645 plumbing_response = svc.stub.List( 3646 req, 3647 metadata=svc.parent.get_metadata( 3648 'IdentitySets.List', req), 3649 timeout=t) 3650 except Exception as e: 3651 if self.parent.shouldRetry(tries, e, deadline): 3652 tries += 1 3653 time.sleep( 3654 self.parent.exponentialBackoff(tries, deadline)) 3655 continue 3656 raise plumbing.convert_error_to_porcelain(e) from e 3657 tries = 0 3658 for plumbing_item in plumbing_response.identity_sets: 3659 yield plumbing.convert_identity_set_to_porcelain( 3660 plumbing_item) 3661 if plumbing_response.meta.next_cursor == '': 3662 break 3663 req.meta.cursor = plumbing_response.meta.next_cursor 3664 3665 return generator(self, req)
List gets a list of IdentitySets matching a given set of criteria.
class
SnapshotIdentitySets:
3668class SnapshotIdentitySets: 3669 ''' 3670 SnapshotIdentitySets exposes the read only methods of the IdentitySets 3671 service for historical queries. 3672 ''' 3673 def __init__(self, identity_sets): 3674 self.identity_sets = identity_sets 3675 3676 def get(self, id, timeout=None): 3677 ''' 3678 Get reads one IdentitySet by ID. 3679 ''' 3680 return self.identity_sets.get(id, timeout=timeout) 3681 3682 def list(self, filter, *args, timeout=None): 3683 ''' 3684 List gets a list of IdentitySets matching a given set of criteria. 3685 ''' 3686 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)
3676 def get(self, id, timeout=None): 3677 ''' 3678 Get reads one IdentitySet by ID. 3679 ''' 3680 return self.identity_sets.get(id, timeout=timeout)
Get reads one IdentitySet by ID.
def
list(self, filter, *args, timeout=None)
3682 def list(self, filter, *args, timeout=None): 3683 ''' 3684 List gets a list of IdentitySets matching a given set of criteria. 3685 ''' 3686 return self.identity_sets.list(filter, *args, timeout=timeout)
List gets a list of IdentitySets matching a given set of criteria.
class
IdentitySetsHistory:
3689class IdentitySetsHistory: 3690 ''' 3691 IdentitySetsHistory records all changes to the state of a IdentitySet. 3692 See `strongdm.models.IdentitySetHistory`. 3693 ''' 3694 def __init__(self, channel, client): 3695 self.parent = client 3696 self.stub = IdentitySetsHistoryStub(channel) 3697 3698 def list(self, filter, *args, timeout=None): 3699 ''' 3700 List gets a list of IdentitySetHistory records matching a given set of criteria. 3701 ''' 3702 deadline = None if timeout is None else time.time() + timeout 3703 req = IdentitySetHistoryListRequest() 3704 req.meta.CopyFrom(ListRequestMetadata()) 3705 if self.parent.page_limit > 0: 3706 req.meta.limit = self.parent.page_limit 3707 if self.parent.snapshot_datetime is not None: 3708 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3709 3710 req.filter = plumbing.quote_filter_args(filter, *args) 3711 3712 def generator(svc, req): 3713 tries = 0 3714 while True: 3715 t = None if deadline is None else deadline - time.time() 3716 try: 3717 plumbing_response = svc.stub.List( 3718 req, 3719 metadata=svc.parent.get_metadata( 3720 'IdentitySetsHistory.List', req), 3721 timeout=t) 3722 except Exception as e: 3723 if self.parent.shouldRetry(tries, e, deadline): 3724 tries += 1 3725 time.sleep( 3726 self.parent.exponentialBackoff(tries, deadline)) 3727 continue 3728 raise plumbing.convert_error_to_porcelain(e) from e 3729 tries = 0 3730 for plumbing_item in plumbing_response.history: 3731 yield plumbing.convert_identity_set_history_to_porcelain( 3732 plumbing_item) 3733 if plumbing_response.meta.next_cursor == '': 3734 break 3735 req.meta.cursor = plumbing_response.meta.next_cursor 3736 3737 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)
3698 def list(self, filter, *args, timeout=None): 3699 ''' 3700 List gets a list of IdentitySetHistory records matching a given set of criteria. 3701 ''' 3702 deadline = None if timeout is None else time.time() + timeout 3703 req = IdentitySetHistoryListRequest() 3704 req.meta.CopyFrom(ListRequestMetadata()) 3705 if self.parent.page_limit > 0: 3706 req.meta.limit = self.parent.page_limit 3707 if self.parent.snapshot_datetime is not None: 3708 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3709 3710 req.filter = plumbing.quote_filter_args(filter, *args) 3711 3712 def generator(svc, req): 3713 tries = 0 3714 while True: 3715 t = None if deadline is None else deadline - time.time() 3716 try: 3717 plumbing_response = svc.stub.List( 3718 req, 3719 metadata=svc.parent.get_metadata( 3720 'IdentitySetsHistory.List', req), 3721 timeout=t) 3722 except Exception as e: 3723 if self.parent.shouldRetry(tries, e, deadline): 3724 tries += 1 3725 time.sleep( 3726 self.parent.exponentialBackoff(tries, deadline)) 3727 continue 3728 raise plumbing.convert_error_to_porcelain(e) from e 3729 tries = 0 3730 for plumbing_item in plumbing_response.history: 3731 yield plumbing.convert_identity_set_history_to_porcelain( 3732 plumbing_item) 3733 if plumbing_response.meta.next_cursor == '': 3734 break 3735 req.meta.cursor = plumbing_response.meta.next_cursor 3736 3737 return generator(self, req)
List gets a list of IdentitySetHistory records matching a given set of criteria.
class
ManagedSecrets:
3740class ManagedSecrets: 3741 ''' 3742 ManagedSecret is a private vertical for creating, reading, updating, 3743 deleting, listing and rotating the managed secrets in the secrets engines as 3744 an authenticated user. 3745 See `strongdm.models.ManagedSecret`. 3746 ''' 3747 def __init__(self, channel, client): 3748 self.parent = client 3749 self.stub = ManagedSecretsStub(channel) 3750 3751 def list(self, filter, *args, timeout=None): 3752 ''' 3753 List returns Managed Secrets from a Secret Engine. 3754 ''' 3755 deadline = None if timeout is None else time.time() + timeout 3756 req = ManagedSecretListRequest() 3757 req.meta.CopyFrom(ListRequestMetadata()) 3758 if self.parent.page_limit > 0: 3759 req.meta.limit = self.parent.page_limit 3760 if self.parent.snapshot_datetime is not None: 3761 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3762 3763 req.filter = plumbing.quote_filter_args(filter, *args) 3764 3765 def generator(svc, req): 3766 tries = 0 3767 while True: 3768 t = None if deadline is None else deadline - time.time() 3769 try: 3770 plumbing_response = svc.stub.List( 3771 req, 3772 metadata=svc.parent.get_metadata( 3773 'ManagedSecrets.List', req), 3774 timeout=t) 3775 except Exception as e: 3776 if self.parent.shouldRetry(tries, e, deadline): 3777 tries += 1 3778 time.sleep( 3779 self.parent.exponentialBackoff(tries, deadline)) 3780 continue 3781 raise plumbing.convert_error_to_porcelain(e) from e 3782 tries = 0 3783 for plumbing_item in plumbing_response.managed_secrets: 3784 yield plumbing.convert_managed_secret_to_porcelain( 3785 plumbing_item) 3786 if plumbing_response.meta.next_cursor == '': 3787 break 3788 req.meta.cursor = plumbing_response.meta.next_cursor 3789 3790 return generator(self, req) 3791 3792 def list_by_actor(self, filter, *args, timeout=None): 3793 ''' 3794 List returns Managed Secrets for an Actor from a Secret Engine. 3795 ''' 3796 deadline = None if timeout is None else time.time() + timeout 3797 req = ManagedSecretListRequest() 3798 req.meta.CopyFrom(ListRequestMetadata()) 3799 if self.parent.page_limit > 0: 3800 req.meta.limit = self.parent.page_limit 3801 if self.parent.snapshot_datetime is not None: 3802 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3803 3804 req.filter = plumbing.quote_filter_args(filter, *args) 3805 3806 def generator(svc, req): 3807 tries = 0 3808 while True: 3809 t = None if deadline is None else deadline - time.time() 3810 try: 3811 plumbing_response = svc.stub.ListByActor( 3812 req, 3813 metadata=svc.parent.get_metadata( 3814 'ManagedSecrets.ListByActor', req), 3815 timeout=t) 3816 except Exception as e: 3817 if self.parent.shouldRetry(tries, e, deadline): 3818 tries += 1 3819 time.sleep( 3820 self.parent.exponentialBackoff(tries, deadline)) 3821 continue 3822 raise plumbing.convert_error_to_porcelain(e) from e 3823 tries = 0 3824 for plumbing_item in plumbing_response.managed_secrets: 3825 yield plumbing.convert_managed_secret_to_porcelain( 3826 plumbing_item) 3827 if plumbing_response.meta.next_cursor == '': 3828 break 3829 req.meta.cursor = plumbing_response.meta.next_cursor 3830 3831 return generator(self, req) 3832 3833 def create(self, managed_secret, timeout=None): 3834 ''' 3835 Create creates a Managed Secret 3836 ''' 3837 deadline = None if timeout is None else time.time() + timeout 3838 req = ManagedSecretCreateRequest() 3839 3840 if managed_secret is not None: 3841 req.managed_secret.CopyFrom( 3842 plumbing.convert_managed_secret_to_plumbing(managed_secret)) 3843 tries = 0 3844 plumbing_response = None 3845 while True: 3846 t = None if deadline is None else deadline - time.time() 3847 try: 3848 plumbing_response = self.stub.Create( 3849 req, 3850 metadata=self.parent.get_metadata('ManagedSecrets.Create', 3851 req), 3852 timeout=t) 3853 except Exception as e: 3854 if self.parent.shouldRetry(tries, e, deadline): 3855 tries += 1 3856 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3857 continue 3858 raise plumbing.convert_error_to_porcelain(e) from e 3859 break 3860 3861 resp = models.ManagedSecretCreateResponse() 3862 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 3863 plumbing_response.managed_secret) 3864 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 3865 plumbing_response.meta) 3866 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3867 plumbing_response.rate_limit) 3868 return resp 3869 3870 def update(self, managed_secret, timeout=None): 3871 ''' 3872 Update updates a Managed Secret 3873 ''' 3874 deadline = None if timeout is None else time.time() + timeout 3875 req = ManagedSecretUpdateRequest() 3876 3877 if managed_secret is not None: 3878 req.managed_secret.CopyFrom( 3879 plumbing.convert_managed_secret_to_plumbing(managed_secret)) 3880 tries = 0 3881 plumbing_response = None 3882 while True: 3883 t = None if deadline is None else deadline - time.time() 3884 try: 3885 plumbing_response = self.stub.Update( 3886 req, 3887 metadata=self.parent.get_metadata('ManagedSecrets.Update', 3888 req), 3889 timeout=t) 3890 except Exception as e: 3891 if self.parent.shouldRetry(tries, e, deadline): 3892 tries += 1 3893 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3894 continue 3895 raise plumbing.convert_error_to_porcelain(e) from e 3896 break 3897 3898 resp = models.ManagedSecretUpdateResponse() 3899 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 3900 plumbing_response.managed_secret) 3901 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 3902 plumbing_response.meta) 3903 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3904 plumbing_response.rate_limit) 3905 return resp 3906 3907 def rotate(self, id, timeout=None): 3908 ''' 3909 Rotate forces rotation of Managed Secret 3910 ''' 3911 deadline = None if timeout is None else time.time() + timeout 3912 req = ManagedSecretRotateRequest() 3913 3914 req.id = (id) 3915 tries = 0 3916 plumbing_response = None 3917 while True: 3918 t = None if deadline is None else deadline - time.time() 3919 try: 3920 plumbing_response = self.stub.Rotate( 3921 req, 3922 metadata=self.parent.get_metadata('ManagedSecrets.Rotate', 3923 req), 3924 timeout=t) 3925 except Exception as e: 3926 if self.parent.shouldRetry(tries, e, deadline): 3927 tries += 1 3928 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3929 continue 3930 raise plumbing.convert_error_to_porcelain(e) from e 3931 break 3932 3933 resp = models.ManagedSecretRotateResponse() 3934 resp.meta = plumbing.convert_generic_response_metadata_to_porcelain( 3935 plumbing_response.meta) 3936 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3937 plumbing_response.rate_limit) 3938 return resp 3939 3940 def delete(self, id, timeout=None): 3941 ''' 3942 Delete deletes a Managed Secret 3943 ''' 3944 deadline = None if timeout is None else time.time() + timeout 3945 req = ManagedSecretDeleteRequest() 3946 3947 req.id = (id) 3948 tries = 0 3949 plumbing_response = None 3950 while True: 3951 t = None if deadline is None else deadline - time.time() 3952 try: 3953 plumbing_response = self.stub.Delete( 3954 req, 3955 metadata=self.parent.get_metadata('ManagedSecrets.Delete', 3956 req), 3957 timeout=t) 3958 except Exception as e: 3959 if self.parent.shouldRetry(tries, e, deadline): 3960 tries += 1 3961 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3962 continue 3963 raise plumbing.convert_error_to_porcelain(e) from e 3964 break 3965 3966 resp = models.ManagedSecretDeleteResponse() 3967 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3968 plumbing_response.rate_limit) 3969 return resp 3970 3971 def force_delete(self, id, timeout=None): 3972 ''' 3973 ForceDelete deletes a Managed Secret regardless of errors on external system 3974 ''' 3975 deadline = None if timeout is None else time.time() + timeout 3976 req = ManagedSecretDeleteRequest() 3977 3978 req.id = (id) 3979 tries = 0 3980 plumbing_response = None 3981 while True: 3982 t = None if deadline is None else deadline - time.time() 3983 try: 3984 plumbing_response = self.stub.ForceDelete( 3985 req, 3986 metadata=self.parent.get_metadata( 3987 'ManagedSecrets.ForceDelete', req), 3988 timeout=t) 3989 except Exception as e: 3990 if self.parent.shouldRetry(tries, e, deadline): 3991 tries += 1 3992 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3993 continue 3994 raise plumbing.convert_error_to_porcelain(e) from e 3995 break 3996 3997 resp = models.ManagedSecretDeleteResponse() 3998 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3999 plumbing_response.rate_limit) 4000 return resp 4001 4002 def get(self, id, timeout=None): 4003 ''' 4004 Get gets details of a Managed Secret without sensitive data 4005 ''' 4006 deadline = None if timeout is None else time.time() + timeout 4007 req = ManagedSecretGetRequest() 4008 if self.parent.snapshot_datetime is not None: 4009 req.meta.CopyFrom(GetRequestMetadata()) 4010 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4011 4012 req.id = (id) 4013 tries = 0 4014 plumbing_response = None 4015 while True: 4016 t = None if deadline is None else deadline - time.time() 4017 try: 4018 plumbing_response = self.stub.Get( 4019 req, 4020 metadata=self.parent.get_metadata('ManagedSecrets.Get', 4021 req), 4022 timeout=t) 4023 except Exception as e: 4024 if self.parent.shouldRetry(tries, e, deadline): 4025 tries += 1 4026 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4027 continue 4028 raise plumbing.convert_error_to_porcelain(e) from e 4029 break 4030 4031 resp = models.ManagedSecretGetResponse() 4032 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 4033 plumbing_response.managed_secret) 4034 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4035 plumbing_response.meta) 4036 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4037 plumbing_response.rate_limit) 4038 return resp 4039 4040 def retrieve(self, id, public_key, timeout=None): 4041 ''' 4042 Retrieve returns Managed Secret with sensitive data 4043 ''' 4044 deadline = None if timeout is None else time.time() + timeout 4045 req = ManagedSecretRetrieveRequest() 4046 4047 req.id = (id) 4048 req.public_key = (public_key) 4049 tries = 0 4050 plumbing_response = None 4051 while True: 4052 t = None if deadline is None else deadline - time.time() 4053 try: 4054 plumbing_response = self.stub.Retrieve( 4055 req, 4056 metadata=self.parent.get_metadata( 4057 'ManagedSecrets.Retrieve', req), 4058 timeout=t) 4059 except Exception as e: 4060 if self.parent.shouldRetry(tries, e, deadline): 4061 tries += 1 4062 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4063 continue 4064 raise plumbing.convert_error_to_porcelain(e) from e 4065 break 4066 4067 resp = models.ManagedSecretRetrieveResponse() 4068 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 4069 plumbing_response.managed_secret) 4070 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4071 plumbing_response.meta) 4072 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4073 plumbing_response.rate_limit) 4074 return resp 4075 4076 def validate(self, id, timeout=None): 4077 ''' 4078 Validate returns the result of testing the stored credential against the 4079 secret engine. 4080 ''' 4081 deadline = None if timeout is None else time.time() + timeout 4082 req = ManagedSecretValidateRequest() 4083 4084 req.id = (id) 4085 tries = 0 4086 plumbing_response = None 4087 while True: 4088 t = None if deadline is None else deadline - time.time() 4089 try: 4090 plumbing_response = self.stub.Validate( 4091 req, 4092 metadata=self.parent.get_metadata( 4093 'ManagedSecrets.Validate', req), 4094 timeout=t) 4095 except Exception as e: 4096 if self.parent.shouldRetry(tries, e, deadline): 4097 tries += 1 4098 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4099 continue 4100 raise plumbing.convert_error_to_porcelain(e) from e 4101 break 4102 4103 resp = models.ManagedSecretValidateResponse() 4104 resp.invalid_info = (plumbing_response.invalid_info) 4105 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4106 plumbing_response.meta) 4107 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4108 plumbing_response.rate_limit) 4109 resp.valid = (plumbing_response.valid) 4110 return resp 4111 4112 def logs(self, filter, *args, timeout=None): 4113 ''' 4114 Logs returns the audit records for the managed secret. This may be replaced 4115 in the future. 4116 ''' 4117 deadline = None if timeout is None else time.time() + timeout 4118 req = ManagedSecretLogsRequest() 4119 req.meta.CopyFrom(ListRequestMetadata()) 4120 if self.parent.page_limit > 0: 4121 req.meta.limit = self.parent.page_limit 4122 if self.parent.snapshot_datetime is not None: 4123 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4124 4125 req.filter = plumbing.quote_filter_args(filter, *args) 4126 4127 def generator(svc, req): 4128 tries = 0 4129 while True: 4130 t = None if deadline is None else deadline - time.time() 4131 try: 4132 plumbing_response = svc.stub.Logs( 4133 req, 4134 metadata=svc.parent.get_metadata( 4135 'ManagedSecrets.Logs', req), 4136 timeout=t) 4137 except Exception as e: 4138 if self.parent.shouldRetry(tries, e, deadline): 4139 tries += 1 4140 time.sleep( 4141 self.parent.exponentialBackoff(tries, deadline)) 4142 continue 4143 raise plumbing.convert_error_to_porcelain(e) from e 4144 tries = 0 4145 for plumbing_item in plumbing_response.managed_secret_logs: 4146 yield plumbing.convert_managed_secret_log_to_porcelain( 4147 plumbing_item) 4148 if plumbing_response.meta.next_cursor == '': 4149 break 4150 req.meta.cursor = plumbing_response.meta.next_cursor 4151 4152 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)
3751 def list(self, filter, *args, timeout=None): 3752 ''' 3753 List returns Managed Secrets from a Secret Engine. 3754 ''' 3755 deadline = None if timeout is None else time.time() + timeout 3756 req = ManagedSecretListRequest() 3757 req.meta.CopyFrom(ListRequestMetadata()) 3758 if self.parent.page_limit > 0: 3759 req.meta.limit = self.parent.page_limit 3760 if self.parent.snapshot_datetime is not None: 3761 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3762 3763 req.filter = plumbing.quote_filter_args(filter, *args) 3764 3765 def generator(svc, req): 3766 tries = 0 3767 while True: 3768 t = None if deadline is None else deadline - time.time() 3769 try: 3770 plumbing_response = svc.stub.List( 3771 req, 3772 metadata=svc.parent.get_metadata( 3773 'ManagedSecrets.List', req), 3774 timeout=t) 3775 except Exception as e: 3776 if self.parent.shouldRetry(tries, e, deadline): 3777 tries += 1 3778 time.sleep( 3779 self.parent.exponentialBackoff(tries, deadline)) 3780 continue 3781 raise plumbing.convert_error_to_porcelain(e) from e 3782 tries = 0 3783 for plumbing_item in plumbing_response.managed_secrets: 3784 yield plumbing.convert_managed_secret_to_porcelain( 3785 plumbing_item) 3786 if plumbing_response.meta.next_cursor == '': 3787 break 3788 req.meta.cursor = plumbing_response.meta.next_cursor 3789 3790 return generator(self, req)
List returns Managed Secrets from a Secret Engine.
def
list_by_actor(self, filter, *args, timeout=None)
3792 def list_by_actor(self, filter, *args, timeout=None): 3793 ''' 3794 List returns Managed Secrets for an Actor from a Secret Engine. 3795 ''' 3796 deadline = None if timeout is None else time.time() + timeout 3797 req = ManagedSecretListRequest() 3798 req.meta.CopyFrom(ListRequestMetadata()) 3799 if self.parent.page_limit > 0: 3800 req.meta.limit = self.parent.page_limit 3801 if self.parent.snapshot_datetime is not None: 3802 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 3803 3804 req.filter = plumbing.quote_filter_args(filter, *args) 3805 3806 def generator(svc, req): 3807 tries = 0 3808 while True: 3809 t = None if deadline is None else deadline - time.time() 3810 try: 3811 plumbing_response = svc.stub.ListByActor( 3812 req, 3813 metadata=svc.parent.get_metadata( 3814 'ManagedSecrets.ListByActor', req), 3815 timeout=t) 3816 except Exception as e: 3817 if self.parent.shouldRetry(tries, e, deadline): 3818 tries += 1 3819 time.sleep( 3820 self.parent.exponentialBackoff(tries, deadline)) 3821 continue 3822 raise plumbing.convert_error_to_porcelain(e) from e 3823 tries = 0 3824 for plumbing_item in plumbing_response.managed_secrets: 3825 yield plumbing.convert_managed_secret_to_porcelain( 3826 plumbing_item) 3827 if plumbing_response.meta.next_cursor == '': 3828 break 3829 req.meta.cursor = plumbing_response.meta.next_cursor 3830 3831 return generator(self, req)
List returns Managed Secrets for an Actor from a Secret Engine.
def
create(self, managed_secret, timeout=None)
3833 def create(self, managed_secret, timeout=None): 3834 ''' 3835 Create creates a Managed Secret 3836 ''' 3837 deadline = None if timeout is None else time.time() + timeout 3838 req = ManagedSecretCreateRequest() 3839 3840 if managed_secret is not None: 3841 req.managed_secret.CopyFrom( 3842 plumbing.convert_managed_secret_to_plumbing(managed_secret)) 3843 tries = 0 3844 plumbing_response = None 3845 while True: 3846 t = None if deadline is None else deadline - time.time() 3847 try: 3848 plumbing_response = self.stub.Create( 3849 req, 3850 metadata=self.parent.get_metadata('ManagedSecrets.Create', 3851 req), 3852 timeout=t) 3853 except Exception as e: 3854 if self.parent.shouldRetry(tries, e, deadline): 3855 tries += 1 3856 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3857 continue 3858 raise plumbing.convert_error_to_porcelain(e) from e 3859 break 3860 3861 resp = models.ManagedSecretCreateResponse() 3862 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 3863 plumbing_response.managed_secret) 3864 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 3865 plumbing_response.meta) 3866 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3867 plumbing_response.rate_limit) 3868 return resp
Create creates a Managed Secret
def
update(self, managed_secret, timeout=None)
3870 def update(self, managed_secret, timeout=None): 3871 ''' 3872 Update updates a Managed Secret 3873 ''' 3874 deadline = None if timeout is None else time.time() + timeout 3875 req = ManagedSecretUpdateRequest() 3876 3877 if managed_secret is not None: 3878 req.managed_secret.CopyFrom( 3879 plumbing.convert_managed_secret_to_plumbing(managed_secret)) 3880 tries = 0 3881 plumbing_response = None 3882 while True: 3883 t = None if deadline is None else deadline - time.time() 3884 try: 3885 plumbing_response = self.stub.Update( 3886 req, 3887 metadata=self.parent.get_metadata('ManagedSecrets.Update', 3888 req), 3889 timeout=t) 3890 except Exception as e: 3891 if self.parent.shouldRetry(tries, e, deadline): 3892 tries += 1 3893 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3894 continue 3895 raise plumbing.convert_error_to_porcelain(e) from e 3896 break 3897 3898 resp = models.ManagedSecretUpdateResponse() 3899 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 3900 plumbing_response.managed_secret) 3901 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 3902 plumbing_response.meta) 3903 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3904 plumbing_response.rate_limit) 3905 return resp
Update updates a Managed Secret
def
rotate(self, id, timeout=None)
3907 def rotate(self, id, timeout=None): 3908 ''' 3909 Rotate forces rotation of Managed Secret 3910 ''' 3911 deadline = None if timeout is None else time.time() + timeout 3912 req = ManagedSecretRotateRequest() 3913 3914 req.id = (id) 3915 tries = 0 3916 plumbing_response = None 3917 while True: 3918 t = None if deadline is None else deadline - time.time() 3919 try: 3920 plumbing_response = self.stub.Rotate( 3921 req, 3922 metadata=self.parent.get_metadata('ManagedSecrets.Rotate', 3923 req), 3924 timeout=t) 3925 except Exception as e: 3926 if self.parent.shouldRetry(tries, e, deadline): 3927 tries += 1 3928 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3929 continue 3930 raise plumbing.convert_error_to_porcelain(e) from e 3931 break 3932 3933 resp = models.ManagedSecretRotateResponse() 3934 resp.meta = plumbing.convert_generic_response_metadata_to_porcelain( 3935 plumbing_response.meta) 3936 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3937 plumbing_response.rate_limit) 3938 return resp
Rotate forces rotation of Managed Secret
def
delete(self, id, timeout=None)
3940 def delete(self, id, timeout=None): 3941 ''' 3942 Delete deletes a Managed Secret 3943 ''' 3944 deadline = None if timeout is None else time.time() + timeout 3945 req = ManagedSecretDeleteRequest() 3946 3947 req.id = (id) 3948 tries = 0 3949 plumbing_response = None 3950 while True: 3951 t = None if deadline is None else deadline - time.time() 3952 try: 3953 plumbing_response = self.stub.Delete( 3954 req, 3955 metadata=self.parent.get_metadata('ManagedSecrets.Delete', 3956 req), 3957 timeout=t) 3958 except Exception as e: 3959 if self.parent.shouldRetry(tries, e, deadline): 3960 tries += 1 3961 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3962 continue 3963 raise plumbing.convert_error_to_porcelain(e) from e 3964 break 3965 3966 resp = models.ManagedSecretDeleteResponse() 3967 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3968 plumbing_response.rate_limit) 3969 return resp
Delete deletes a Managed Secret
def
force_delete(self, id, timeout=None)
3971 def force_delete(self, id, timeout=None): 3972 ''' 3973 ForceDelete deletes a Managed Secret regardless of errors on external system 3974 ''' 3975 deadline = None if timeout is None else time.time() + timeout 3976 req = ManagedSecretDeleteRequest() 3977 3978 req.id = (id) 3979 tries = 0 3980 plumbing_response = None 3981 while True: 3982 t = None if deadline is None else deadline - time.time() 3983 try: 3984 plumbing_response = self.stub.ForceDelete( 3985 req, 3986 metadata=self.parent.get_metadata( 3987 'ManagedSecrets.ForceDelete', req), 3988 timeout=t) 3989 except Exception as e: 3990 if self.parent.shouldRetry(tries, e, deadline): 3991 tries += 1 3992 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 3993 continue 3994 raise plumbing.convert_error_to_porcelain(e) from e 3995 break 3996 3997 resp = models.ManagedSecretDeleteResponse() 3998 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 3999 plumbing_response.rate_limit) 4000 return resp
ForceDelete deletes a Managed Secret regardless of errors on external system
def
get(self, id, timeout=None)
4002 def get(self, id, timeout=None): 4003 ''' 4004 Get gets details of a Managed Secret without sensitive data 4005 ''' 4006 deadline = None if timeout is None else time.time() + timeout 4007 req = ManagedSecretGetRequest() 4008 if self.parent.snapshot_datetime is not None: 4009 req.meta.CopyFrom(GetRequestMetadata()) 4010 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4011 4012 req.id = (id) 4013 tries = 0 4014 plumbing_response = None 4015 while True: 4016 t = None if deadline is None else deadline - time.time() 4017 try: 4018 plumbing_response = self.stub.Get( 4019 req, 4020 metadata=self.parent.get_metadata('ManagedSecrets.Get', 4021 req), 4022 timeout=t) 4023 except Exception as e: 4024 if self.parent.shouldRetry(tries, e, deadline): 4025 tries += 1 4026 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4027 continue 4028 raise plumbing.convert_error_to_porcelain(e) from e 4029 break 4030 4031 resp = models.ManagedSecretGetResponse() 4032 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 4033 plumbing_response.managed_secret) 4034 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4035 plumbing_response.meta) 4036 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4037 plumbing_response.rate_limit) 4038 return resp
Get gets details of a Managed Secret without sensitive data
def
retrieve(self, id, public_key, timeout=None)
4040 def retrieve(self, id, public_key, timeout=None): 4041 ''' 4042 Retrieve returns Managed Secret with sensitive data 4043 ''' 4044 deadline = None if timeout is None else time.time() + timeout 4045 req = ManagedSecretRetrieveRequest() 4046 4047 req.id = (id) 4048 req.public_key = (public_key) 4049 tries = 0 4050 plumbing_response = None 4051 while True: 4052 t = None if deadline is None else deadline - time.time() 4053 try: 4054 plumbing_response = self.stub.Retrieve( 4055 req, 4056 metadata=self.parent.get_metadata( 4057 'ManagedSecrets.Retrieve', req), 4058 timeout=t) 4059 except Exception as e: 4060 if self.parent.shouldRetry(tries, e, deadline): 4061 tries += 1 4062 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4063 continue 4064 raise plumbing.convert_error_to_porcelain(e) from e 4065 break 4066 4067 resp = models.ManagedSecretRetrieveResponse() 4068 resp.managed_secret = plumbing.convert_managed_secret_to_porcelain( 4069 plumbing_response.managed_secret) 4070 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4071 plumbing_response.meta) 4072 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4073 plumbing_response.rate_limit) 4074 return resp
Retrieve returns Managed Secret with sensitive data
def
validate(self, id, timeout=None)
4076 def validate(self, id, timeout=None): 4077 ''' 4078 Validate returns the result of testing the stored credential against the 4079 secret engine. 4080 ''' 4081 deadline = None if timeout is None else time.time() + timeout 4082 req = ManagedSecretValidateRequest() 4083 4084 req.id = (id) 4085 tries = 0 4086 plumbing_response = None 4087 while True: 4088 t = None if deadline is None else deadline - time.time() 4089 try: 4090 plumbing_response = self.stub.Validate( 4091 req, 4092 metadata=self.parent.get_metadata( 4093 'ManagedSecrets.Validate', req), 4094 timeout=t) 4095 except Exception as e: 4096 if self.parent.shouldRetry(tries, e, deadline): 4097 tries += 1 4098 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4099 continue 4100 raise plumbing.convert_error_to_porcelain(e) from e 4101 break 4102 4103 resp = models.ManagedSecretValidateResponse() 4104 resp.invalid_info = (plumbing_response.invalid_info) 4105 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4106 plumbing_response.meta) 4107 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4108 plumbing_response.rate_limit) 4109 resp.valid = (plumbing_response.valid) 4110 return resp
Validate returns the result of testing the stored credential against the secret engine.
def
logs(self, filter, *args, timeout=None)
4112 def logs(self, filter, *args, timeout=None): 4113 ''' 4114 Logs returns the audit records for the managed secret. This may be replaced 4115 in the future. 4116 ''' 4117 deadline = None if timeout is None else time.time() + timeout 4118 req = ManagedSecretLogsRequest() 4119 req.meta.CopyFrom(ListRequestMetadata()) 4120 if self.parent.page_limit > 0: 4121 req.meta.limit = self.parent.page_limit 4122 if self.parent.snapshot_datetime is not None: 4123 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4124 4125 req.filter = plumbing.quote_filter_args(filter, *args) 4126 4127 def generator(svc, req): 4128 tries = 0 4129 while True: 4130 t = None if deadline is None else deadline - time.time() 4131 try: 4132 plumbing_response = svc.stub.Logs( 4133 req, 4134 metadata=svc.parent.get_metadata( 4135 'ManagedSecrets.Logs', req), 4136 timeout=t) 4137 except Exception as e: 4138 if self.parent.shouldRetry(tries, e, deadline): 4139 tries += 1 4140 time.sleep( 4141 self.parent.exponentialBackoff(tries, deadline)) 4142 continue 4143 raise plumbing.convert_error_to_porcelain(e) from e 4144 tries = 0 4145 for plumbing_item in plumbing_response.managed_secret_logs: 4146 yield plumbing.convert_managed_secret_log_to_porcelain( 4147 plumbing_item) 4148 if plumbing_response.meta.next_cursor == '': 4149 break 4150 req.meta.cursor = plumbing_response.meta.next_cursor 4151 4152 return generator(self, req)
Logs returns the audit records for the managed secret. This may be replaced in the future.
class
Nodes:
4155class Nodes: 4156 ''' 4157 Nodes make up the StrongDM network, and allow your users to connect securely to your resources. 4158 There are three types of nodes: 4159 1. **Relay:** creates connectivity to your datasources, while maintaining the egress-only nature of your firewall 4160 2. **Gateway:** a relay that also listens for connections from StrongDM clients 4161 3. **Proxy Cluster:** a cluster of workers that together mediate access from clients to resources 4162 See: 4163 `strongdm.models.Gateway` 4164 `strongdm.models.ProxyCluster` 4165 `strongdm.models.Relay` 4166 ''' 4167 def __init__(self, channel, client): 4168 self.parent = client 4169 self.stub = NodesStub(channel) 4170 4171 def create(self, node, timeout=None): 4172 ''' 4173 Create registers a new Node. 4174 ''' 4175 deadline = None if timeout is None else time.time() + timeout 4176 req = NodeCreateRequest() 4177 4178 if node is not None: 4179 req.node.CopyFrom(plumbing.convert_node_to_plumbing(node)) 4180 tries = 0 4181 plumbing_response = None 4182 while True: 4183 t = None if deadline is None else deadline - time.time() 4184 try: 4185 plumbing_response = self.stub.Create( 4186 req, 4187 metadata=self.parent.get_metadata('Nodes.Create', req), 4188 timeout=t) 4189 except Exception as e: 4190 if self.parent.shouldRetry(tries, e, deadline): 4191 tries += 1 4192 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4193 continue 4194 raise plumbing.convert_error_to_porcelain(e) from e 4195 break 4196 4197 resp = models.NodeCreateResponse() 4198 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4199 plumbing_response.meta) 4200 resp.node = plumbing.convert_node_to_porcelain(plumbing_response.node) 4201 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4202 plumbing_response.rate_limit) 4203 resp.token = (plumbing_response.token) 4204 return resp 4205 4206 def get(self, id, timeout=None): 4207 ''' 4208 Get reads one Node by ID. 4209 ''' 4210 deadline = None if timeout is None else time.time() + timeout 4211 req = NodeGetRequest() 4212 if self.parent.snapshot_datetime is not None: 4213 req.meta.CopyFrom(GetRequestMetadata()) 4214 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4215 4216 req.id = (id) 4217 tries = 0 4218 plumbing_response = None 4219 while True: 4220 t = None if deadline is None else deadline - time.time() 4221 try: 4222 plumbing_response = self.stub.Get( 4223 req, 4224 metadata=self.parent.get_metadata('Nodes.Get', req), 4225 timeout=t) 4226 except Exception as e: 4227 if self.parent.shouldRetry(tries, e, deadline): 4228 tries += 1 4229 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4230 continue 4231 raise plumbing.convert_error_to_porcelain(e) from e 4232 break 4233 4234 resp = models.NodeGetResponse() 4235 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4236 plumbing_response.meta) 4237 resp.node = plumbing.convert_node_to_porcelain(plumbing_response.node) 4238 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4239 plumbing_response.rate_limit) 4240 return resp 4241 4242 def update(self, node, timeout=None): 4243 ''' 4244 Update replaces all the fields of a Node by ID. 4245 ''' 4246 deadline = None if timeout is None else time.time() + timeout 4247 req = NodeUpdateRequest() 4248 4249 if node is not None: 4250 req.node.CopyFrom(plumbing.convert_node_to_plumbing(node)) 4251 tries = 0 4252 plumbing_response = None 4253 while True: 4254 t = None if deadline is None else deadline - time.time() 4255 try: 4256 plumbing_response = self.stub.Update( 4257 req, 4258 metadata=self.parent.get_metadata('Nodes.Update', req), 4259 timeout=t) 4260 except Exception as e: 4261 if self.parent.shouldRetry(tries, e, deadline): 4262 tries += 1 4263 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4264 continue 4265 raise plumbing.convert_error_to_porcelain(e) from e 4266 break 4267 4268 resp = models.NodeUpdateResponse() 4269 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 4270 plumbing_response.meta) 4271 resp.node = plumbing.convert_node_to_porcelain(plumbing_response.node) 4272 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4273 plumbing_response.rate_limit) 4274 return resp 4275 4276 def delete(self, id, timeout=None): 4277 ''' 4278 Delete removes a Node by ID. 4279 ''' 4280 deadline = None if timeout is None else time.time() + timeout 4281 req = NodeDeleteRequest() 4282 4283 req.id = (id) 4284 tries = 0 4285 plumbing_response = None 4286 while True: 4287 t = None if deadline is None else deadline - time.time() 4288 try: 4289 plumbing_response = self.stub.Delete( 4290 req, 4291 metadata=self.parent.get_metadata('Nodes.Delete', req), 4292 timeout=t) 4293 except Exception as e: 4294 if self.parent.shouldRetry(tries, e, deadline): 4295 tries += 1 4296 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4297 continue 4298 raise plumbing.convert_error_to_porcelain(e) from e 4299 break 4300 4301 resp = models.NodeDeleteResponse() 4302 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 4303 plumbing_response.meta) 4304 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4305 plumbing_response.rate_limit) 4306 return resp 4307 4308 def list(self, filter, *args, timeout=None): 4309 ''' 4310 List gets a list of Nodes matching a given set of criteria. 4311 ''' 4312 deadline = None if timeout is None else time.time() + timeout 4313 req = NodeListRequest() 4314 req.meta.CopyFrom(ListRequestMetadata()) 4315 if self.parent.page_limit > 0: 4316 req.meta.limit = self.parent.page_limit 4317 if self.parent.snapshot_datetime is not None: 4318 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4319 4320 req.filter = plumbing.quote_filter_args(filter, *args) 4321 4322 def generator(svc, req): 4323 tries = 0 4324 while True: 4325 t = None if deadline is None else deadline - time.time() 4326 try: 4327 plumbing_response = svc.stub.List( 4328 req, 4329 metadata=svc.parent.get_metadata('Nodes.List', req), 4330 timeout=t) 4331 except Exception as e: 4332 if self.parent.shouldRetry(tries, e, deadline): 4333 tries += 1 4334 time.sleep( 4335 self.parent.exponentialBackoff(tries, deadline)) 4336 continue 4337 raise plumbing.convert_error_to_porcelain(e) from e 4338 tries = 0 4339 for plumbing_item in plumbing_response.nodes: 4340 yield plumbing.convert_node_to_porcelain(plumbing_item) 4341 if plumbing_response.meta.next_cursor == '': 4342 break 4343 req.meta.cursor = plumbing_response.meta.next_cursor 4344 4345 return generator(self, req) 4346 4347 def tcp_probe(self, node_id, host, port, timeout=None): 4348 ''' 4349 TCPProbe instructs a Node to connect to an address via TCP and report the 4350 result. 4351 ''' 4352 deadline = None if timeout is None else time.time() + timeout 4353 req = NodeTCPProbeRequest() 4354 4355 req.node_id = (node_id) 4356 req.host = (host) 4357 req.port = (port) 4358 tries = 0 4359 plumbing_response = None 4360 while True: 4361 t = None if deadline is None else deadline - time.time() 4362 try: 4363 plumbing_response = self.stub.TCPProbe( 4364 req, 4365 metadata=self.parent.get_metadata('Nodes.TCPProbe', req), 4366 timeout=t) 4367 except Exception as e: 4368 if self.parent.shouldRetry(tries, e, deadline): 4369 tries += 1 4370 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4371 continue 4372 raise plumbing.convert_error_to_porcelain(e) from e 4373 break 4374 4375 resp = models.NodeTCPProbeResponse() 4376 resp.error = (plumbing_response.error) 4377 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4378 plumbing_response.meta) 4379 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4380 plumbing_response.rate_limit) 4381 resp.succeeded = (plumbing_response.succeeded) 4382 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)
4171 def create(self, node, timeout=None): 4172 ''' 4173 Create registers a new Node. 4174 ''' 4175 deadline = None if timeout is None else time.time() + timeout 4176 req = NodeCreateRequest() 4177 4178 if node is not None: 4179 req.node.CopyFrom(plumbing.convert_node_to_plumbing(node)) 4180 tries = 0 4181 plumbing_response = None 4182 while True: 4183 t = None if deadline is None else deadline - time.time() 4184 try: 4185 plumbing_response = self.stub.Create( 4186 req, 4187 metadata=self.parent.get_metadata('Nodes.Create', req), 4188 timeout=t) 4189 except Exception as e: 4190 if self.parent.shouldRetry(tries, e, deadline): 4191 tries += 1 4192 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4193 continue 4194 raise plumbing.convert_error_to_porcelain(e) from e 4195 break 4196 4197 resp = models.NodeCreateResponse() 4198 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4199 plumbing_response.meta) 4200 resp.node = plumbing.convert_node_to_porcelain(plumbing_response.node) 4201 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4202 plumbing_response.rate_limit) 4203 resp.token = (plumbing_response.token) 4204 return resp
Create registers a new Node.
def
get(self, id, timeout=None)
4206 def get(self, id, timeout=None): 4207 ''' 4208 Get reads one Node by ID. 4209 ''' 4210 deadline = None if timeout is None else time.time() + timeout 4211 req = NodeGetRequest() 4212 if self.parent.snapshot_datetime is not None: 4213 req.meta.CopyFrom(GetRequestMetadata()) 4214 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4215 4216 req.id = (id) 4217 tries = 0 4218 plumbing_response = None 4219 while True: 4220 t = None if deadline is None else deadline - time.time() 4221 try: 4222 plumbing_response = self.stub.Get( 4223 req, 4224 metadata=self.parent.get_metadata('Nodes.Get', req), 4225 timeout=t) 4226 except Exception as e: 4227 if self.parent.shouldRetry(tries, e, deadline): 4228 tries += 1 4229 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4230 continue 4231 raise plumbing.convert_error_to_porcelain(e) from e 4232 break 4233 4234 resp = models.NodeGetResponse() 4235 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4236 plumbing_response.meta) 4237 resp.node = plumbing.convert_node_to_porcelain(plumbing_response.node) 4238 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4239 plumbing_response.rate_limit) 4240 return resp
Get reads one Node by ID.
def
update(self, node, timeout=None)
4242 def update(self, node, timeout=None): 4243 ''' 4244 Update replaces all the fields of a Node by ID. 4245 ''' 4246 deadline = None if timeout is None else time.time() + timeout 4247 req = NodeUpdateRequest() 4248 4249 if node is not None: 4250 req.node.CopyFrom(plumbing.convert_node_to_plumbing(node)) 4251 tries = 0 4252 plumbing_response = None 4253 while True: 4254 t = None if deadline is None else deadline - time.time() 4255 try: 4256 plumbing_response = self.stub.Update( 4257 req, 4258 metadata=self.parent.get_metadata('Nodes.Update', req), 4259 timeout=t) 4260 except Exception as e: 4261 if self.parent.shouldRetry(tries, e, deadline): 4262 tries += 1 4263 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4264 continue 4265 raise plumbing.convert_error_to_porcelain(e) from e 4266 break 4267 4268 resp = models.NodeUpdateResponse() 4269 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 4270 plumbing_response.meta) 4271 resp.node = plumbing.convert_node_to_porcelain(plumbing_response.node) 4272 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4273 plumbing_response.rate_limit) 4274 return resp
Update replaces all the fields of a Node by ID.
def
delete(self, id, timeout=None)
4276 def delete(self, id, timeout=None): 4277 ''' 4278 Delete removes a Node by ID. 4279 ''' 4280 deadline = None if timeout is None else time.time() + timeout 4281 req = NodeDeleteRequest() 4282 4283 req.id = (id) 4284 tries = 0 4285 plumbing_response = None 4286 while True: 4287 t = None if deadline is None else deadline - time.time() 4288 try: 4289 plumbing_response = self.stub.Delete( 4290 req, 4291 metadata=self.parent.get_metadata('Nodes.Delete', req), 4292 timeout=t) 4293 except Exception as e: 4294 if self.parent.shouldRetry(tries, e, deadline): 4295 tries += 1 4296 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4297 continue 4298 raise plumbing.convert_error_to_porcelain(e) from e 4299 break 4300 4301 resp = models.NodeDeleteResponse() 4302 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 4303 plumbing_response.meta) 4304 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4305 plumbing_response.rate_limit) 4306 return resp
Delete removes a Node by ID.
def
list(self, filter, *args, timeout=None)
4308 def list(self, filter, *args, timeout=None): 4309 ''' 4310 List gets a list of Nodes matching a given set of criteria. 4311 ''' 4312 deadline = None if timeout is None else time.time() + timeout 4313 req = NodeListRequest() 4314 req.meta.CopyFrom(ListRequestMetadata()) 4315 if self.parent.page_limit > 0: 4316 req.meta.limit = self.parent.page_limit 4317 if self.parent.snapshot_datetime is not None: 4318 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4319 4320 req.filter = plumbing.quote_filter_args(filter, *args) 4321 4322 def generator(svc, req): 4323 tries = 0 4324 while True: 4325 t = None if deadline is None else deadline - time.time() 4326 try: 4327 plumbing_response = svc.stub.List( 4328 req, 4329 metadata=svc.parent.get_metadata('Nodes.List', req), 4330 timeout=t) 4331 except Exception as e: 4332 if self.parent.shouldRetry(tries, e, deadline): 4333 tries += 1 4334 time.sleep( 4335 self.parent.exponentialBackoff(tries, deadline)) 4336 continue 4337 raise plumbing.convert_error_to_porcelain(e) from e 4338 tries = 0 4339 for plumbing_item in plumbing_response.nodes: 4340 yield plumbing.convert_node_to_porcelain(plumbing_item) 4341 if plumbing_response.meta.next_cursor == '': 4342 break 4343 req.meta.cursor = plumbing_response.meta.next_cursor 4344 4345 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)
4347 def tcp_probe(self, node_id, host, port, timeout=None): 4348 ''' 4349 TCPProbe instructs a Node to connect to an address via TCP and report the 4350 result. 4351 ''' 4352 deadline = None if timeout is None else time.time() + timeout 4353 req = NodeTCPProbeRequest() 4354 4355 req.node_id = (node_id) 4356 req.host = (host) 4357 req.port = (port) 4358 tries = 0 4359 plumbing_response = None 4360 while True: 4361 t = None if deadline is None else deadline - time.time() 4362 try: 4363 plumbing_response = self.stub.TCPProbe( 4364 req, 4365 metadata=self.parent.get_metadata('Nodes.TCPProbe', req), 4366 timeout=t) 4367 except Exception as e: 4368 if self.parent.shouldRetry(tries, e, deadline): 4369 tries += 1 4370 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4371 continue 4372 raise plumbing.convert_error_to_porcelain(e) from e 4373 break 4374 4375 resp = models.NodeTCPProbeResponse() 4376 resp.error = (plumbing_response.error) 4377 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4378 plumbing_response.meta) 4379 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4380 plumbing_response.rate_limit) 4381 resp.succeeded = (plumbing_response.succeeded) 4382 return resp
TCPProbe instructs a Node to connect to an address via TCP and report the result.
class
SnapshotNodes:
4385class SnapshotNodes: 4386 ''' 4387 SnapshotNodes exposes the read only methods of the Nodes 4388 service for historical queries. 4389 ''' 4390 def __init__(self, nodes): 4391 self.nodes = nodes 4392 4393 def get(self, id, timeout=None): 4394 ''' 4395 Get reads one Node by ID. 4396 ''' 4397 return self.nodes.get(id, timeout=timeout) 4398 4399 def list(self, filter, *args, timeout=None): 4400 ''' 4401 List gets a list of Nodes matching a given set of criteria. 4402 ''' 4403 return self.nodes.list(filter, *args, timeout=timeout)
SnapshotNodes exposes the read only methods of the Nodes service for historical queries.
class
NodesHistory:
4406class NodesHistory: 4407 ''' 4408 NodesHistory records all changes to the state of a Node. 4409 See `strongdm.models.NodeHistory`. 4410 ''' 4411 def __init__(self, channel, client): 4412 self.parent = client 4413 self.stub = NodesHistoryStub(channel) 4414 4415 def list(self, filter, *args, timeout=None): 4416 ''' 4417 List gets a list of NodeHistory records matching a given set of criteria. 4418 ''' 4419 deadline = None if timeout is None else time.time() + timeout 4420 req = NodeHistoryListRequest() 4421 req.meta.CopyFrom(ListRequestMetadata()) 4422 if self.parent.page_limit > 0: 4423 req.meta.limit = self.parent.page_limit 4424 if self.parent.snapshot_datetime is not None: 4425 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4426 4427 req.filter = plumbing.quote_filter_args(filter, *args) 4428 4429 def generator(svc, req): 4430 tries = 0 4431 while True: 4432 t = None if deadline is None else deadline - time.time() 4433 try: 4434 plumbing_response = svc.stub.List( 4435 req, 4436 metadata=svc.parent.get_metadata( 4437 'NodesHistory.List', req), 4438 timeout=t) 4439 except Exception as e: 4440 if self.parent.shouldRetry(tries, e, deadline): 4441 tries += 1 4442 time.sleep( 4443 self.parent.exponentialBackoff(tries, deadline)) 4444 continue 4445 raise plumbing.convert_error_to_porcelain(e) from e 4446 tries = 0 4447 for plumbing_item in plumbing_response.history: 4448 yield plumbing.convert_node_history_to_porcelain( 4449 plumbing_item) 4450 if plumbing_response.meta.next_cursor == '': 4451 break 4452 req.meta.cursor = plumbing_response.meta.next_cursor 4453 4454 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)
4415 def list(self, filter, *args, timeout=None): 4416 ''' 4417 List gets a list of NodeHistory records matching a given set of criteria. 4418 ''' 4419 deadline = None if timeout is None else time.time() + timeout 4420 req = NodeHistoryListRequest() 4421 req.meta.CopyFrom(ListRequestMetadata()) 4422 if self.parent.page_limit > 0: 4423 req.meta.limit = self.parent.page_limit 4424 if self.parent.snapshot_datetime is not None: 4425 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4426 4427 req.filter = plumbing.quote_filter_args(filter, *args) 4428 4429 def generator(svc, req): 4430 tries = 0 4431 while True: 4432 t = None if deadline is None else deadline - time.time() 4433 try: 4434 plumbing_response = svc.stub.List( 4435 req, 4436 metadata=svc.parent.get_metadata( 4437 'NodesHistory.List', req), 4438 timeout=t) 4439 except Exception as e: 4440 if self.parent.shouldRetry(tries, e, deadline): 4441 tries += 1 4442 time.sleep( 4443 self.parent.exponentialBackoff(tries, deadline)) 4444 continue 4445 raise plumbing.convert_error_to_porcelain(e) from e 4446 tries = 0 4447 for plumbing_item in plumbing_response.history: 4448 yield plumbing.convert_node_history_to_porcelain( 4449 plumbing_item) 4450 if plumbing_response.meta.next_cursor == '': 4451 break 4452 req.meta.cursor = plumbing_response.meta.next_cursor 4453 4454 return generator(self, req)
List gets a list of NodeHistory records matching a given set of criteria.
class
OrganizationHistory:
4457class OrganizationHistory: 4458 ''' 4459 OrganizationHistory records all changes to the state of an Organization. 4460 See `strongdm.models.OrganizationHistoryRecord`. 4461 ''' 4462 def __init__(self, channel, client): 4463 self.parent = client 4464 self.stub = OrganizationHistoryStub(channel) 4465 4466 def list(self, filter, *args, timeout=None): 4467 ''' 4468 List gets a list of OrganizationHistory records matching a given set of criteria. 4469 ''' 4470 deadline = None if timeout is None else time.time() + timeout 4471 req = OrganizationHistoryListRequest() 4472 req.meta.CopyFrom(ListRequestMetadata()) 4473 if self.parent.page_limit > 0: 4474 req.meta.limit = self.parent.page_limit 4475 if self.parent.snapshot_datetime is not None: 4476 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4477 4478 req.filter = plumbing.quote_filter_args(filter, *args) 4479 4480 def generator(svc, req): 4481 tries = 0 4482 while True: 4483 t = None if deadline is None else deadline - time.time() 4484 try: 4485 plumbing_response = svc.stub.List( 4486 req, 4487 metadata=svc.parent.get_metadata( 4488 'OrganizationHistory.List', req), 4489 timeout=t) 4490 except Exception as e: 4491 if self.parent.shouldRetry(tries, e, deadline): 4492 tries += 1 4493 time.sleep( 4494 self.parent.exponentialBackoff(tries, deadline)) 4495 continue 4496 raise plumbing.convert_error_to_porcelain(e) from e 4497 tries = 0 4498 for plumbing_item in plumbing_response.history: 4499 yield plumbing.convert_organization_history_record_to_porcelain( 4500 plumbing_item) 4501 if plumbing_response.meta.next_cursor == '': 4502 break 4503 req.meta.cursor = plumbing_response.meta.next_cursor 4504 4505 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)
4466 def list(self, filter, *args, timeout=None): 4467 ''' 4468 List gets a list of OrganizationHistory records matching a given set of criteria. 4469 ''' 4470 deadline = None if timeout is None else time.time() + timeout 4471 req = OrganizationHistoryListRequest() 4472 req.meta.CopyFrom(ListRequestMetadata()) 4473 if self.parent.page_limit > 0: 4474 req.meta.limit = self.parent.page_limit 4475 if self.parent.snapshot_datetime is not None: 4476 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4477 4478 req.filter = plumbing.quote_filter_args(filter, *args) 4479 4480 def generator(svc, req): 4481 tries = 0 4482 while True: 4483 t = None if deadline is None else deadline - time.time() 4484 try: 4485 plumbing_response = svc.stub.List( 4486 req, 4487 metadata=svc.parent.get_metadata( 4488 'OrganizationHistory.List', req), 4489 timeout=t) 4490 except Exception as e: 4491 if self.parent.shouldRetry(tries, e, deadline): 4492 tries += 1 4493 time.sleep( 4494 self.parent.exponentialBackoff(tries, deadline)) 4495 continue 4496 raise plumbing.convert_error_to_porcelain(e) from e 4497 tries = 0 4498 for plumbing_item in plumbing_response.history: 4499 yield plumbing.convert_organization_history_record_to_porcelain( 4500 plumbing_item) 4501 if plumbing_response.meta.next_cursor == '': 4502 break 4503 req.meta.cursor = plumbing_response.meta.next_cursor 4504 4505 return generator(self, req)
List gets a list of OrganizationHistory records matching a given set of criteria.
class
PeeringGroupNodes:
4508class PeeringGroupNodes: 4509 ''' 4510 PeeringGroupNodes provides the building blocks necessary to obtain attach a node to a peering group. 4511 See `strongdm.models.PeeringGroupNode`. 4512 ''' 4513 def __init__(self, channel, client): 4514 self.parent = client 4515 self.stub = PeeringGroupNodesStub(channel) 4516 4517 def create(self, peering_group_node, timeout=None): 4518 ''' 4519 Create attaches a Node to a PeeringGroup 4520 ''' 4521 deadline = None if timeout is None else time.time() + timeout 4522 req = PeeringGroupNodeCreateRequest() 4523 4524 if peering_group_node is not None: 4525 req.peering_group_node.CopyFrom( 4526 plumbing.convert_peering_group_node_to_plumbing( 4527 peering_group_node)) 4528 tries = 0 4529 plumbing_response = None 4530 while True: 4531 t = None if deadline is None else deadline - time.time() 4532 try: 4533 plumbing_response = self.stub.Create( 4534 req, 4535 metadata=self.parent.get_metadata( 4536 'PeeringGroupNodes.Create', req), 4537 timeout=t) 4538 except Exception as e: 4539 if self.parent.shouldRetry(tries, e, deadline): 4540 tries += 1 4541 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4542 continue 4543 raise plumbing.convert_error_to_porcelain(e) from e 4544 break 4545 4546 resp = models.PeeringGroupNodeCreateResponse() 4547 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4548 plumbing_response.meta) 4549 resp.peering_group_node = plumbing.convert_peering_group_node_to_porcelain( 4550 plumbing_response.peering_group_node) 4551 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4552 plumbing_response.rate_limit) 4553 return resp 4554 4555 def delete(self, id, timeout=None): 4556 ''' 4557 Delete detaches a Node to a PeeringGroup. 4558 ''' 4559 deadline = None if timeout is None else time.time() + timeout 4560 req = PeeringGroupNodeDeleteRequest() 4561 4562 req.id = (id) 4563 tries = 0 4564 plumbing_response = None 4565 while True: 4566 t = None if deadline is None else deadline - time.time() 4567 try: 4568 plumbing_response = self.stub.Delete( 4569 req, 4570 metadata=self.parent.get_metadata( 4571 'PeeringGroupNodes.Delete', req), 4572 timeout=t) 4573 except Exception as e: 4574 if self.parent.shouldRetry(tries, e, deadline): 4575 tries += 1 4576 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4577 continue 4578 raise plumbing.convert_error_to_porcelain(e) from e 4579 break 4580 4581 resp = models.PeeringGroupNodeDeleteResponse() 4582 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 4583 plumbing_response.meta) 4584 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4585 plumbing_response.rate_limit) 4586 return resp 4587 4588 def get(self, id, timeout=None): 4589 ''' 4590 Get reads the information of one peering group to node attachment. 4591 ''' 4592 deadline = None if timeout is None else time.time() + timeout 4593 req = PeeringGroupNodeGetRequest() 4594 if self.parent.snapshot_datetime is not None: 4595 req.meta.CopyFrom(GetRequestMetadata()) 4596 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4597 4598 req.id = (id) 4599 tries = 0 4600 plumbing_response = None 4601 while True: 4602 t = None if deadline is None else deadline - time.time() 4603 try: 4604 plumbing_response = self.stub.Get( 4605 req, 4606 metadata=self.parent.get_metadata('PeeringGroupNodes.Get', 4607 req), 4608 timeout=t) 4609 except Exception as e: 4610 if self.parent.shouldRetry(tries, e, deadline): 4611 tries += 1 4612 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4613 continue 4614 raise plumbing.convert_error_to_porcelain(e) from e 4615 break 4616 4617 resp = models.PeeringGroupNodeGetResponse() 4618 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4619 plumbing_response.meta) 4620 resp.peering_group_node = plumbing.convert_peering_group_node_to_porcelain( 4621 plumbing_response.peering_group_node) 4622 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4623 plumbing_response.rate_limit) 4624 return resp 4625 4626 def list(self, filter, *args, timeout=None): 4627 ''' 4628 List gets a list of peering group node attachments. 4629 ''' 4630 deadline = None if timeout is None else time.time() + timeout 4631 req = PeeringGroupNodeListRequest() 4632 req.meta.CopyFrom(ListRequestMetadata()) 4633 if self.parent.page_limit > 0: 4634 req.meta.limit = self.parent.page_limit 4635 if self.parent.snapshot_datetime is not None: 4636 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4637 4638 req.filter = plumbing.quote_filter_args(filter, *args) 4639 4640 def generator(svc, req): 4641 tries = 0 4642 while True: 4643 t = None if deadline is None else deadline - time.time() 4644 try: 4645 plumbing_response = svc.stub.List( 4646 req, 4647 metadata=svc.parent.get_metadata( 4648 'PeeringGroupNodes.List', req), 4649 timeout=t) 4650 except Exception as e: 4651 if self.parent.shouldRetry(tries, e, deadline): 4652 tries += 1 4653 time.sleep( 4654 self.parent.exponentialBackoff(tries, deadline)) 4655 continue 4656 raise plumbing.convert_error_to_porcelain(e) from e 4657 tries = 0 4658 for plumbing_item in plumbing_response.peering_group_nodes: 4659 yield plumbing.convert_peering_group_node_to_porcelain( 4660 plumbing_item) 4661 if plumbing_response.meta.next_cursor == '': 4662 break 4663 req.meta.cursor = plumbing_response.meta.next_cursor 4664 4665 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)
4517 def create(self, peering_group_node, timeout=None): 4518 ''' 4519 Create attaches a Node to a PeeringGroup 4520 ''' 4521 deadline = None if timeout is None else time.time() + timeout 4522 req = PeeringGroupNodeCreateRequest() 4523 4524 if peering_group_node is not None: 4525 req.peering_group_node.CopyFrom( 4526 plumbing.convert_peering_group_node_to_plumbing( 4527 peering_group_node)) 4528 tries = 0 4529 plumbing_response = None 4530 while True: 4531 t = None if deadline is None else deadline - time.time() 4532 try: 4533 plumbing_response = self.stub.Create( 4534 req, 4535 metadata=self.parent.get_metadata( 4536 'PeeringGroupNodes.Create', req), 4537 timeout=t) 4538 except Exception as e: 4539 if self.parent.shouldRetry(tries, e, deadline): 4540 tries += 1 4541 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4542 continue 4543 raise plumbing.convert_error_to_porcelain(e) from e 4544 break 4545 4546 resp = models.PeeringGroupNodeCreateResponse() 4547 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4548 plumbing_response.meta) 4549 resp.peering_group_node = plumbing.convert_peering_group_node_to_porcelain( 4550 plumbing_response.peering_group_node) 4551 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4552 plumbing_response.rate_limit) 4553 return resp
Create attaches a Node to a PeeringGroup
def
delete(self, id, timeout=None)
4555 def delete(self, id, timeout=None): 4556 ''' 4557 Delete detaches a Node to a PeeringGroup. 4558 ''' 4559 deadline = None if timeout is None else time.time() + timeout 4560 req = PeeringGroupNodeDeleteRequest() 4561 4562 req.id = (id) 4563 tries = 0 4564 plumbing_response = None 4565 while True: 4566 t = None if deadline is None else deadline - time.time() 4567 try: 4568 plumbing_response = self.stub.Delete( 4569 req, 4570 metadata=self.parent.get_metadata( 4571 'PeeringGroupNodes.Delete', req), 4572 timeout=t) 4573 except Exception as e: 4574 if self.parent.shouldRetry(tries, e, deadline): 4575 tries += 1 4576 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4577 continue 4578 raise plumbing.convert_error_to_porcelain(e) from e 4579 break 4580 4581 resp = models.PeeringGroupNodeDeleteResponse() 4582 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 4583 plumbing_response.meta) 4584 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4585 plumbing_response.rate_limit) 4586 return resp
Delete detaches a Node to a PeeringGroup.
def
get(self, id, timeout=None)
4588 def get(self, id, timeout=None): 4589 ''' 4590 Get reads the information of one peering group to node attachment. 4591 ''' 4592 deadline = None if timeout is None else time.time() + timeout 4593 req = PeeringGroupNodeGetRequest() 4594 if self.parent.snapshot_datetime is not None: 4595 req.meta.CopyFrom(GetRequestMetadata()) 4596 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4597 4598 req.id = (id) 4599 tries = 0 4600 plumbing_response = None 4601 while True: 4602 t = None if deadline is None else deadline - time.time() 4603 try: 4604 plumbing_response = self.stub.Get( 4605 req, 4606 metadata=self.parent.get_metadata('PeeringGroupNodes.Get', 4607 req), 4608 timeout=t) 4609 except Exception as e: 4610 if self.parent.shouldRetry(tries, e, deadline): 4611 tries += 1 4612 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4613 continue 4614 raise plumbing.convert_error_to_porcelain(e) from e 4615 break 4616 4617 resp = models.PeeringGroupNodeGetResponse() 4618 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4619 plumbing_response.meta) 4620 resp.peering_group_node = plumbing.convert_peering_group_node_to_porcelain( 4621 plumbing_response.peering_group_node) 4622 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4623 plumbing_response.rate_limit) 4624 return resp
Get reads the information of one peering group to node attachment.
def
list(self, filter, *args, timeout=None)
4626 def list(self, filter, *args, timeout=None): 4627 ''' 4628 List gets a list of peering group node attachments. 4629 ''' 4630 deadline = None if timeout is None else time.time() + timeout 4631 req = PeeringGroupNodeListRequest() 4632 req.meta.CopyFrom(ListRequestMetadata()) 4633 if self.parent.page_limit > 0: 4634 req.meta.limit = self.parent.page_limit 4635 if self.parent.snapshot_datetime is not None: 4636 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4637 4638 req.filter = plumbing.quote_filter_args(filter, *args) 4639 4640 def generator(svc, req): 4641 tries = 0 4642 while True: 4643 t = None if deadline is None else deadline - time.time() 4644 try: 4645 plumbing_response = svc.stub.List( 4646 req, 4647 metadata=svc.parent.get_metadata( 4648 'PeeringGroupNodes.List', req), 4649 timeout=t) 4650 except Exception as e: 4651 if self.parent.shouldRetry(tries, e, deadline): 4652 tries += 1 4653 time.sleep( 4654 self.parent.exponentialBackoff(tries, deadline)) 4655 continue 4656 raise plumbing.convert_error_to_porcelain(e) from e 4657 tries = 0 4658 for plumbing_item in plumbing_response.peering_group_nodes: 4659 yield plumbing.convert_peering_group_node_to_porcelain( 4660 plumbing_item) 4661 if plumbing_response.meta.next_cursor == '': 4662 break 4663 req.meta.cursor = plumbing_response.meta.next_cursor 4664 4665 return generator(self, req)
List gets a list of peering group node attachments.
class
PeeringGroupPeers:
4668class PeeringGroupPeers: 4669 ''' 4670 PeeringGroupPeers provides the building blocks necessary to link two peering groups. 4671 See `strongdm.models.PeeringGroupPeer`. 4672 ''' 4673 def __init__(self, channel, client): 4674 self.parent = client 4675 self.stub = PeeringGroupPeersStub(channel) 4676 4677 def create(self, peering_group_peer, timeout=None): 4678 ''' 4679 Create links two peering groups. 4680 ''' 4681 deadline = None if timeout is None else time.time() + timeout 4682 req = PeeringGroupPeerCreateRequest() 4683 4684 if peering_group_peer is not None: 4685 req.peering_group_peer.CopyFrom( 4686 plumbing.convert_peering_group_peer_to_plumbing( 4687 peering_group_peer)) 4688 tries = 0 4689 plumbing_response = None 4690 while True: 4691 t = None if deadline is None else deadline - time.time() 4692 try: 4693 plumbing_response = self.stub.Create( 4694 req, 4695 metadata=self.parent.get_metadata( 4696 'PeeringGroupPeers.Create', req), 4697 timeout=t) 4698 except Exception as e: 4699 if self.parent.shouldRetry(tries, e, deadline): 4700 tries += 1 4701 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4702 continue 4703 raise plumbing.convert_error_to_porcelain(e) from e 4704 break 4705 4706 resp = models.PeeringGroupPeerCreateResponse() 4707 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4708 plumbing_response.meta) 4709 resp.peering_group_peer = plumbing.convert_peering_group_peer_to_porcelain( 4710 plumbing_response.peering_group_peer) 4711 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4712 plumbing_response.rate_limit) 4713 return resp 4714 4715 def delete(self, id, timeout=None): 4716 ''' 4717 Delete unlinks two peering groups. 4718 ''' 4719 deadline = None if timeout is None else time.time() + timeout 4720 req = PeeringGroupPeerDeleteRequest() 4721 4722 req.id = (id) 4723 tries = 0 4724 plumbing_response = None 4725 while True: 4726 t = None if deadline is None else deadline - time.time() 4727 try: 4728 plumbing_response = self.stub.Delete( 4729 req, 4730 metadata=self.parent.get_metadata( 4731 'PeeringGroupPeers.Delete', req), 4732 timeout=t) 4733 except Exception as e: 4734 if self.parent.shouldRetry(tries, e, deadline): 4735 tries += 1 4736 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4737 continue 4738 raise plumbing.convert_error_to_porcelain(e) from e 4739 break 4740 4741 resp = models.PeeringGroupPeerDeleteResponse() 4742 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 4743 plumbing_response.meta) 4744 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4745 plumbing_response.rate_limit) 4746 return resp 4747 4748 def get(self, id, timeout=None): 4749 ''' 4750 Get reads the information of one peering group link. 4751 ''' 4752 deadline = None if timeout is None else time.time() + timeout 4753 req = PeeringGroupPeerGetRequest() 4754 if self.parent.snapshot_datetime is not None: 4755 req.meta.CopyFrom(GetRequestMetadata()) 4756 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4757 4758 req.id = (id) 4759 tries = 0 4760 plumbing_response = None 4761 while True: 4762 t = None if deadline is None else deadline - time.time() 4763 try: 4764 plumbing_response = self.stub.Get( 4765 req, 4766 metadata=self.parent.get_metadata('PeeringGroupPeers.Get', 4767 req), 4768 timeout=t) 4769 except Exception as e: 4770 if self.parent.shouldRetry(tries, e, deadline): 4771 tries += 1 4772 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4773 continue 4774 raise plumbing.convert_error_to_porcelain(e) from e 4775 break 4776 4777 resp = models.PeeringGroupPeerGetResponse() 4778 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4779 plumbing_response.meta) 4780 resp.peering_group_peer = plumbing.convert_peering_group_peer_to_porcelain( 4781 plumbing_response.peering_group_peer) 4782 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4783 plumbing_response.rate_limit) 4784 return resp 4785 4786 def list(self, filter, *args, timeout=None): 4787 ''' 4788 List gets a list of peering group links. 4789 ''' 4790 deadline = None if timeout is None else time.time() + timeout 4791 req = PeeringGroupPeerListRequest() 4792 req.meta.CopyFrom(ListRequestMetadata()) 4793 if self.parent.page_limit > 0: 4794 req.meta.limit = self.parent.page_limit 4795 if self.parent.snapshot_datetime is not None: 4796 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4797 4798 req.filter = plumbing.quote_filter_args(filter, *args) 4799 4800 def generator(svc, req): 4801 tries = 0 4802 while True: 4803 t = None if deadline is None else deadline - time.time() 4804 try: 4805 plumbing_response = svc.stub.List( 4806 req, 4807 metadata=svc.parent.get_metadata( 4808 'PeeringGroupPeers.List', req), 4809 timeout=t) 4810 except Exception as e: 4811 if self.parent.shouldRetry(tries, e, deadline): 4812 tries += 1 4813 time.sleep( 4814 self.parent.exponentialBackoff(tries, deadline)) 4815 continue 4816 raise plumbing.convert_error_to_porcelain(e) from e 4817 tries = 0 4818 for plumbing_item in plumbing_response.peering_group_peers: 4819 yield plumbing.convert_peering_group_peer_to_porcelain( 4820 plumbing_item) 4821 if plumbing_response.meta.next_cursor == '': 4822 break 4823 req.meta.cursor = plumbing_response.meta.next_cursor 4824 4825 return generator(self, req)
PeeringGroupPeers provides the building blocks necessary to link two peering groups.
See strongdm.models.PeeringGroupPeer.
def
create(self, peering_group_peer, timeout=None)
4677 def create(self, peering_group_peer, timeout=None): 4678 ''' 4679 Create links two peering groups. 4680 ''' 4681 deadline = None if timeout is None else time.time() + timeout 4682 req = PeeringGroupPeerCreateRequest() 4683 4684 if peering_group_peer is not None: 4685 req.peering_group_peer.CopyFrom( 4686 plumbing.convert_peering_group_peer_to_plumbing( 4687 peering_group_peer)) 4688 tries = 0 4689 plumbing_response = None 4690 while True: 4691 t = None if deadline is None else deadline - time.time() 4692 try: 4693 plumbing_response = self.stub.Create( 4694 req, 4695 metadata=self.parent.get_metadata( 4696 'PeeringGroupPeers.Create', req), 4697 timeout=t) 4698 except Exception as e: 4699 if self.parent.shouldRetry(tries, e, deadline): 4700 tries += 1 4701 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4702 continue 4703 raise plumbing.convert_error_to_porcelain(e) from e 4704 break 4705 4706 resp = models.PeeringGroupPeerCreateResponse() 4707 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4708 plumbing_response.meta) 4709 resp.peering_group_peer = plumbing.convert_peering_group_peer_to_porcelain( 4710 plumbing_response.peering_group_peer) 4711 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4712 plumbing_response.rate_limit) 4713 return resp
Create links two peering groups.
def
delete(self, id, timeout=None)
4715 def delete(self, id, timeout=None): 4716 ''' 4717 Delete unlinks two peering groups. 4718 ''' 4719 deadline = None if timeout is None else time.time() + timeout 4720 req = PeeringGroupPeerDeleteRequest() 4721 4722 req.id = (id) 4723 tries = 0 4724 plumbing_response = None 4725 while True: 4726 t = None if deadline is None else deadline - time.time() 4727 try: 4728 plumbing_response = self.stub.Delete( 4729 req, 4730 metadata=self.parent.get_metadata( 4731 'PeeringGroupPeers.Delete', req), 4732 timeout=t) 4733 except Exception as e: 4734 if self.parent.shouldRetry(tries, e, deadline): 4735 tries += 1 4736 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4737 continue 4738 raise plumbing.convert_error_to_porcelain(e) from e 4739 break 4740 4741 resp = models.PeeringGroupPeerDeleteResponse() 4742 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 4743 plumbing_response.meta) 4744 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4745 plumbing_response.rate_limit) 4746 return resp
Delete unlinks two peering groups.
def
get(self, id, timeout=None)
4748 def get(self, id, timeout=None): 4749 ''' 4750 Get reads the information of one peering group link. 4751 ''' 4752 deadline = None if timeout is None else time.time() + timeout 4753 req = PeeringGroupPeerGetRequest() 4754 if self.parent.snapshot_datetime is not None: 4755 req.meta.CopyFrom(GetRequestMetadata()) 4756 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4757 4758 req.id = (id) 4759 tries = 0 4760 plumbing_response = None 4761 while True: 4762 t = None if deadline is None else deadline - time.time() 4763 try: 4764 plumbing_response = self.stub.Get( 4765 req, 4766 metadata=self.parent.get_metadata('PeeringGroupPeers.Get', 4767 req), 4768 timeout=t) 4769 except Exception as e: 4770 if self.parent.shouldRetry(tries, e, deadline): 4771 tries += 1 4772 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4773 continue 4774 raise plumbing.convert_error_to_porcelain(e) from e 4775 break 4776 4777 resp = models.PeeringGroupPeerGetResponse() 4778 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4779 plumbing_response.meta) 4780 resp.peering_group_peer = plumbing.convert_peering_group_peer_to_porcelain( 4781 plumbing_response.peering_group_peer) 4782 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4783 plumbing_response.rate_limit) 4784 return resp
Get reads the information of one peering group link.
def
list(self, filter, *args, timeout=None)
4786 def list(self, filter, *args, timeout=None): 4787 ''' 4788 List gets a list of peering group links. 4789 ''' 4790 deadline = None if timeout is None else time.time() + timeout 4791 req = PeeringGroupPeerListRequest() 4792 req.meta.CopyFrom(ListRequestMetadata()) 4793 if self.parent.page_limit > 0: 4794 req.meta.limit = self.parent.page_limit 4795 if self.parent.snapshot_datetime is not None: 4796 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4797 4798 req.filter = plumbing.quote_filter_args(filter, *args) 4799 4800 def generator(svc, req): 4801 tries = 0 4802 while True: 4803 t = None if deadline is None else deadline - time.time() 4804 try: 4805 plumbing_response = svc.stub.List( 4806 req, 4807 metadata=svc.parent.get_metadata( 4808 'PeeringGroupPeers.List', req), 4809 timeout=t) 4810 except Exception as e: 4811 if self.parent.shouldRetry(tries, e, deadline): 4812 tries += 1 4813 time.sleep( 4814 self.parent.exponentialBackoff(tries, deadline)) 4815 continue 4816 raise plumbing.convert_error_to_porcelain(e) from e 4817 tries = 0 4818 for plumbing_item in plumbing_response.peering_group_peers: 4819 yield plumbing.convert_peering_group_peer_to_porcelain( 4820 plumbing_item) 4821 if plumbing_response.meta.next_cursor == '': 4822 break 4823 req.meta.cursor = plumbing_response.meta.next_cursor 4824 4825 return generator(self, req)
List gets a list of peering group links.
class
PeeringGroupResources:
4828class PeeringGroupResources: 4829 ''' 4830 PeeringGroupResources provides the building blocks necessary to obtain attach a resource to a peering group. 4831 See `strongdm.models.PeeringGroupResource`. 4832 ''' 4833 def __init__(self, channel, client): 4834 self.parent = client 4835 self.stub = PeeringGroupResourcesStub(channel) 4836 4837 def create(self, peering_group_resource, timeout=None): 4838 ''' 4839 Create attaches a Resource to a PeeringGroup 4840 ''' 4841 deadline = None if timeout is None else time.time() + timeout 4842 req = PeeringGroupResourceCreateRequest() 4843 4844 if peering_group_resource is not None: 4845 req.peering_group_resource.CopyFrom( 4846 plumbing.convert_peering_group_resource_to_plumbing( 4847 peering_group_resource)) 4848 tries = 0 4849 plumbing_response = None 4850 while True: 4851 t = None if deadline is None else deadline - time.time() 4852 try: 4853 plumbing_response = self.stub.Create( 4854 req, 4855 metadata=self.parent.get_metadata( 4856 'PeeringGroupResources.Create', req), 4857 timeout=t) 4858 except Exception as e: 4859 if self.parent.shouldRetry(tries, e, deadline): 4860 tries += 1 4861 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4862 continue 4863 raise plumbing.convert_error_to_porcelain(e) from e 4864 break 4865 4866 resp = models.PeeringGroupResourceCreateResponse() 4867 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4868 plumbing_response.meta) 4869 resp.peering_group_resource = plumbing.convert_peering_group_resource_to_porcelain( 4870 plumbing_response.peering_group_resource) 4871 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4872 plumbing_response.rate_limit) 4873 return resp 4874 4875 def delete(self, id, timeout=None): 4876 ''' 4877 Delete detaches a Resource to a PeeringGroup 4878 ''' 4879 deadline = None if timeout is None else time.time() + timeout 4880 req = PeeringGroupResourceDeleteRequest() 4881 4882 req.id = (id) 4883 tries = 0 4884 plumbing_response = None 4885 while True: 4886 t = None if deadline is None else deadline - time.time() 4887 try: 4888 plumbing_response = self.stub.Delete( 4889 req, 4890 metadata=self.parent.get_metadata( 4891 'PeeringGroupResources.Delete', req), 4892 timeout=t) 4893 except Exception as e: 4894 if self.parent.shouldRetry(tries, e, deadline): 4895 tries += 1 4896 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4897 continue 4898 raise plumbing.convert_error_to_porcelain(e) from e 4899 break 4900 4901 resp = models.PeeringGroupResourceDeleteResponse() 4902 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 4903 plumbing_response.meta) 4904 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4905 plumbing_response.rate_limit) 4906 return resp 4907 4908 def get(self, id, timeout=None): 4909 ''' 4910 Get reads the information of one peering group to resource attachment. 4911 ''' 4912 deadline = None if timeout is None else time.time() + timeout 4913 req = PeeringGroupResourceGetRequest() 4914 if self.parent.snapshot_datetime is not None: 4915 req.meta.CopyFrom(GetRequestMetadata()) 4916 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4917 4918 req.id = (id) 4919 tries = 0 4920 plumbing_response = None 4921 while True: 4922 t = None if deadline is None else deadline - time.time() 4923 try: 4924 plumbing_response = self.stub.Get( 4925 req, 4926 metadata=self.parent.get_metadata( 4927 'PeeringGroupResources.Get', req), 4928 timeout=t) 4929 except Exception as e: 4930 if self.parent.shouldRetry(tries, e, deadline): 4931 tries += 1 4932 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4933 continue 4934 raise plumbing.convert_error_to_porcelain(e) from e 4935 break 4936 4937 resp = models.PeeringGroupResourceGetResponse() 4938 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4939 plumbing_response.meta) 4940 resp.peering_group_resource = plumbing.convert_peering_group_resource_to_porcelain( 4941 plumbing_response.peering_group_resource) 4942 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4943 plumbing_response.rate_limit) 4944 return resp 4945 4946 def list(self, filter, *args, timeout=None): 4947 ''' 4948 List gets a list of peering group resource attachments. 4949 ''' 4950 deadline = None if timeout is None else time.time() + timeout 4951 req = PeeringGroupResourceListRequest() 4952 req.meta.CopyFrom(ListRequestMetadata()) 4953 if self.parent.page_limit > 0: 4954 req.meta.limit = self.parent.page_limit 4955 if self.parent.snapshot_datetime is not None: 4956 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4957 4958 req.filter = plumbing.quote_filter_args(filter, *args) 4959 4960 def generator(svc, req): 4961 tries = 0 4962 while True: 4963 t = None if deadline is None else deadline - time.time() 4964 try: 4965 plumbing_response = svc.stub.List( 4966 req, 4967 metadata=svc.parent.get_metadata( 4968 'PeeringGroupResources.List', req), 4969 timeout=t) 4970 except Exception as e: 4971 if self.parent.shouldRetry(tries, e, deadline): 4972 tries += 1 4973 time.sleep( 4974 self.parent.exponentialBackoff(tries, deadline)) 4975 continue 4976 raise plumbing.convert_error_to_porcelain(e) from e 4977 tries = 0 4978 for plumbing_item in plumbing_response.peering_group_resources: 4979 yield plumbing.convert_peering_group_resource_to_porcelain( 4980 plumbing_item) 4981 if plumbing_response.meta.next_cursor == '': 4982 break 4983 req.meta.cursor = plumbing_response.meta.next_cursor 4984 4985 return generator(self, req)
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)
4837 def create(self, peering_group_resource, timeout=None): 4838 ''' 4839 Create attaches a Resource to a PeeringGroup 4840 ''' 4841 deadline = None if timeout is None else time.time() + timeout 4842 req = PeeringGroupResourceCreateRequest() 4843 4844 if peering_group_resource is not None: 4845 req.peering_group_resource.CopyFrom( 4846 plumbing.convert_peering_group_resource_to_plumbing( 4847 peering_group_resource)) 4848 tries = 0 4849 plumbing_response = None 4850 while True: 4851 t = None if deadline is None else deadline - time.time() 4852 try: 4853 plumbing_response = self.stub.Create( 4854 req, 4855 metadata=self.parent.get_metadata( 4856 'PeeringGroupResources.Create', req), 4857 timeout=t) 4858 except Exception as e: 4859 if self.parent.shouldRetry(tries, e, deadline): 4860 tries += 1 4861 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4862 continue 4863 raise plumbing.convert_error_to_porcelain(e) from e 4864 break 4865 4866 resp = models.PeeringGroupResourceCreateResponse() 4867 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 4868 plumbing_response.meta) 4869 resp.peering_group_resource = plumbing.convert_peering_group_resource_to_porcelain( 4870 plumbing_response.peering_group_resource) 4871 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4872 plumbing_response.rate_limit) 4873 return resp
Create attaches a Resource to a PeeringGroup
def
delete(self, id, timeout=None)
4875 def delete(self, id, timeout=None): 4876 ''' 4877 Delete detaches a Resource to a PeeringGroup 4878 ''' 4879 deadline = None if timeout is None else time.time() + timeout 4880 req = PeeringGroupResourceDeleteRequest() 4881 4882 req.id = (id) 4883 tries = 0 4884 plumbing_response = None 4885 while True: 4886 t = None if deadline is None else deadline - time.time() 4887 try: 4888 plumbing_response = self.stub.Delete( 4889 req, 4890 metadata=self.parent.get_metadata( 4891 'PeeringGroupResources.Delete', req), 4892 timeout=t) 4893 except Exception as e: 4894 if self.parent.shouldRetry(tries, e, deadline): 4895 tries += 1 4896 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4897 continue 4898 raise plumbing.convert_error_to_porcelain(e) from e 4899 break 4900 4901 resp = models.PeeringGroupResourceDeleteResponse() 4902 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 4903 plumbing_response.meta) 4904 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4905 plumbing_response.rate_limit) 4906 return resp
Delete detaches a Resource to a PeeringGroup
def
get(self, id, timeout=None)
4908 def get(self, id, timeout=None): 4909 ''' 4910 Get reads the information of one peering group to resource attachment. 4911 ''' 4912 deadline = None if timeout is None else time.time() + timeout 4913 req = PeeringGroupResourceGetRequest() 4914 if self.parent.snapshot_datetime is not None: 4915 req.meta.CopyFrom(GetRequestMetadata()) 4916 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4917 4918 req.id = (id) 4919 tries = 0 4920 plumbing_response = None 4921 while True: 4922 t = None if deadline is None else deadline - time.time() 4923 try: 4924 plumbing_response = self.stub.Get( 4925 req, 4926 metadata=self.parent.get_metadata( 4927 'PeeringGroupResources.Get', req), 4928 timeout=t) 4929 except Exception as e: 4930 if self.parent.shouldRetry(tries, e, deadline): 4931 tries += 1 4932 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 4933 continue 4934 raise plumbing.convert_error_to_porcelain(e) from e 4935 break 4936 4937 resp = models.PeeringGroupResourceGetResponse() 4938 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 4939 plumbing_response.meta) 4940 resp.peering_group_resource = plumbing.convert_peering_group_resource_to_porcelain( 4941 plumbing_response.peering_group_resource) 4942 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 4943 plumbing_response.rate_limit) 4944 return resp
Get reads the information of one peering group to resource attachment.
def
list(self, filter, *args, timeout=None)
4946 def list(self, filter, *args, timeout=None): 4947 ''' 4948 List gets a list of peering group resource attachments. 4949 ''' 4950 deadline = None if timeout is None else time.time() + timeout 4951 req = PeeringGroupResourceListRequest() 4952 req.meta.CopyFrom(ListRequestMetadata()) 4953 if self.parent.page_limit > 0: 4954 req.meta.limit = self.parent.page_limit 4955 if self.parent.snapshot_datetime is not None: 4956 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 4957 4958 req.filter = plumbing.quote_filter_args(filter, *args) 4959 4960 def generator(svc, req): 4961 tries = 0 4962 while True: 4963 t = None if deadline is None else deadline - time.time() 4964 try: 4965 plumbing_response = svc.stub.List( 4966 req, 4967 metadata=svc.parent.get_metadata( 4968 'PeeringGroupResources.List', req), 4969 timeout=t) 4970 except Exception as e: 4971 if self.parent.shouldRetry(tries, e, deadline): 4972 tries += 1 4973 time.sleep( 4974 self.parent.exponentialBackoff(tries, deadline)) 4975 continue 4976 raise plumbing.convert_error_to_porcelain(e) from e 4977 tries = 0 4978 for plumbing_item in plumbing_response.peering_group_resources: 4979 yield plumbing.convert_peering_group_resource_to_porcelain( 4980 plumbing_item) 4981 if plumbing_response.meta.next_cursor == '': 4982 break 4983 req.meta.cursor = plumbing_response.meta.next_cursor 4984 4985 return generator(self, req)
List gets a list of peering group resource attachments.
class
PeeringGroups:
4988class PeeringGroups: 4989 ''' 4990 PeeringGroups provides the building blocks necessary to obtain explicit network topology and routing. 4991 See `strongdm.models.PeeringGroup`. 4992 ''' 4993 def __init__(self, channel, client): 4994 self.parent = client 4995 self.stub = PeeringGroupsStub(channel) 4996 4997 def create(self, peering_group, timeout=None): 4998 ''' 4999 Create registers a new PeeringGroup. 5000 ''' 5001 deadline = None if timeout is None else time.time() + timeout 5002 req = PeeringGroupCreateRequest() 5003 5004 if peering_group is not None: 5005 req.peering_group.CopyFrom( 5006 plumbing.convert_peering_group_to_plumbing(peering_group)) 5007 tries = 0 5008 plumbing_response = None 5009 while True: 5010 t = None if deadline is None else deadline - time.time() 5011 try: 5012 plumbing_response = self.stub.Create( 5013 req, 5014 metadata=self.parent.get_metadata('PeeringGroups.Create', 5015 req), 5016 timeout=t) 5017 except Exception as e: 5018 if self.parent.shouldRetry(tries, e, deadline): 5019 tries += 1 5020 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5021 continue 5022 raise plumbing.convert_error_to_porcelain(e) from e 5023 break 5024 5025 resp = models.PeeringGroupCreateResponse() 5026 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5027 plumbing_response.meta) 5028 resp.peering_group = plumbing.convert_peering_group_to_porcelain( 5029 plumbing_response.peering_group) 5030 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5031 plumbing_response.rate_limit) 5032 return resp 5033 5034 def delete(self, id, timeout=None): 5035 ''' 5036 Delete removes a PeeringGroup by ID. 5037 ''' 5038 deadline = None if timeout is None else time.time() + timeout 5039 req = PeeringGroupDeleteRequest() 5040 5041 req.id = (id) 5042 tries = 0 5043 plumbing_response = None 5044 while True: 5045 t = None if deadline is None else deadline - time.time() 5046 try: 5047 plumbing_response = self.stub.Delete( 5048 req, 5049 metadata=self.parent.get_metadata('PeeringGroups.Delete', 5050 req), 5051 timeout=t) 5052 except Exception as e: 5053 if self.parent.shouldRetry(tries, e, deadline): 5054 tries += 1 5055 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5056 continue 5057 raise plumbing.convert_error_to_porcelain(e) from e 5058 break 5059 5060 resp = models.PeeringGroupDeleteResponse() 5061 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 5062 plumbing_response.meta) 5063 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5064 plumbing_response.rate_limit) 5065 return resp 5066 5067 def get(self, id, timeout=None): 5068 ''' 5069 Get reads one PeeringGroup by ID. It will load all its dependencies. 5070 ''' 5071 deadline = None if timeout is None else time.time() + timeout 5072 req = PeeringGroupGetRequest() 5073 if self.parent.snapshot_datetime is not None: 5074 req.meta.CopyFrom(GetRequestMetadata()) 5075 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5076 5077 req.id = (id) 5078 tries = 0 5079 plumbing_response = None 5080 while True: 5081 t = None if deadline is None else deadline - time.time() 5082 try: 5083 plumbing_response = self.stub.Get( 5084 req, 5085 metadata=self.parent.get_metadata('PeeringGroups.Get', 5086 req), 5087 timeout=t) 5088 except Exception as e: 5089 if self.parent.shouldRetry(tries, e, deadline): 5090 tries += 1 5091 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5092 continue 5093 raise plumbing.convert_error_to_porcelain(e) from e 5094 break 5095 5096 resp = models.PeeringGroupGetResponse() 5097 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5098 plumbing_response.meta) 5099 resp.peering_group = plumbing.convert_peering_group_to_porcelain( 5100 plumbing_response.peering_group) 5101 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5102 plumbing_response.rate_limit) 5103 return resp 5104 5105 def list(self, filter, *args, timeout=None): 5106 ''' 5107 List gets a list of Peering Groups. 5108 ''' 5109 deadline = None if timeout is None else time.time() + timeout 5110 req = PeeringGroupListRequest() 5111 req.meta.CopyFrom(ListRequestMetadata()) 5112 if self.parent.page_limit > 0: 5113 req.meta.limit = self.parent.page_limit 5114 if self.parent.snapshot_datetime is not None: 5115 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5116 5117 req.filter = plumbing.quote_filter_args(filter, *args) 5118 5119 def generator(svc, req): 5120 tries = 0 5121 while True: 5122 t = None if deadline is None else deadline - time.time() 5123 try: 5124 plumbing_response = svc.stub.List( 5125 req, 5126 metadata=svc.parent.get_metadata( 5127 'PeeringGroups.List', req), 5128 timeout=t) 5129 except Exception as e: 5130 if self.parent.shouldRetry(tries, e, deadline): 5131 tries += 1 5132 time.sleep( 5133 self.parent.exponentialBackoff(tries, deadline)) 5134 continue 5135 raise plumbing.convert_error_to_porcelain(e) from e 5136 tries = 0 5137 for plumbing_item in plumbing_response.peering_groups: 5138 yield plumbing.convert_peering_group_to_porcelain( 5139 plumbing_item) 5140 if plumbing_response.meta.next_cursor == '': 5141 break 5142 req.meta.cursor = plumbing_response.meta.next_cursor 5143 5144 return generator(self, req)
PeeringGroups provides the building blocks necessary to obtain explicit network topology and routing.
See strongdm.models.PeeringGroup.
def
create(self, peering_group, timeout=None)
4997 def create(self, peering_group, timeout=None): 4998 ''' 4999 Create registers a new PeeringGroup. 5000 ''' 5001 deadline = None if timeout is None else time.time() + timeout 5002 req = PeeringGroupCreateRequest() 5003 5004 if peering_group is not None: 5005 req.peering_group.CopyFrom( 5006 plumbing.convert_peering_group_to_plumbing(peering_group)) 5007 tries = 0 5008 plumbing_response = None 5009 while True: 5010 t = None if deadline is None else deadline - time.time() 5011 try: 5012 plumbing_response = self.stub.Create( 5013 req, 5014 metadata=self.parent.get_metadata('PeeringGroups.Create', 5015 req), 5016 timeout=t) 5017 except Exception as e: 5018 if self.parent.shouldRetry(tries, e, deadline): 5019 tries += 1 5020 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5021 continue 5022 raise plumbing.convert_error_to_porcelain(e) from e 5023 break 5024 5025 resp = models.PeeringGroupCreateResponse() 5026 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5027 plumbing_response.meta) 5028 resp.peering_group = plumbing.convert_peering_group_to_porcelain( 5029 plumbing_response.peering_group) 5030 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5031 plumbing_response.rate_limit) 5032 return resp
Create registers a new PeeringGroup.
def
delete(self, id, timeout=None)
5034 def delete(self, id, timeout=None): 5035 ''' 5036 Delete removes a PeeringGroup by ID. 5037 ''' 5038 deadline = None if timeout is None else time.time() + timeout 5039 req = PeeringGroupDeleteRequest() 5040 5041 req.id = (id) 5042 tries = 0 5043 plumbing_response = None 5044 while True: 5045 t = None if deadline is None else deadline - time.time() 5046 try: 5047 plumbing_response = self.stub.Delete( 5048 req, 5049 metadata=self.parent.get_metadata('PeeringGroups.Delete', 5050 req), 5051 timeout=t) 5052 except Exception as e: 5053 if self.parent.shouldRetry(tries, e, deadline): 5054 tries += 1 5055 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5056 continue 5057 raise plumbing.convert_error_to_porcelain(e) from e 5058 break 5059 5060 resp = models.PeeringGroupDeleteResponse() 5061 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 5062 plumbing_response.meta) 5063 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5064 plumbing_response.rate_limit) 5065 return resp
Delete removes a PeeringGroup by ID.
def
get(self, id, timeout=None)
5067 def get(self, id, timeout=None): 5068 ''' 5069 Get reads one PeeringGroup by ID. It will load all its dependencies. 5070 ''' 5071 deadline = None if timeout is None else time.time() + timeout 5072 req = PeeringGroupGetRequest() 5073 if self.parent.snapshot_datetime is not None: 5074 req.meta.CopyFrom(GetRequestMetadata()) 5075 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5076 5077 req.id = (id) 5078 tries = 0 5079 plumbing_response = None 5080 while True: 5081 t = None if deadline is None else deadline - time.time() 5082 try: 5083 plumbing_response = self.stub.Get( 5084 req, 5085 metadata=self.parent.get_metadata('PeeringGroups.Get', 5086 req), 5087 timeout=t) 5088 except Exception as e: 5089 if self.parent.shouldRetry(tries, e, deadline): 5090 tries += 1 5091 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5092 continue 5093 raise plumbing.convert_error_to_porcelain(e) from e 5094 break 5095 5096 resp = models.PeeringGroupGetResponse() 5097 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5098 plumbing_response.meta) 5099 resp.peering_group = plumbing.convert_peering_group_to_porcelain( 5100 plumbing_response.peering_group) 5101 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5102 plumbing_response.rate_limit) 5103 return resp
Get reads one PeeringGroup by ID. It will load all its dependencies.
def
list(self, filter, *args, timeout=None)
5105 def list(self, filter, *args, timeout=None): 5106 ''' 5107 List gets a list of Peering Groups. 5108 ''' 5109 deadline = None if timeout is None else time.time() + timeout 5110 req = PeeringGroupListRequest() 5111 req.meta.CopyFrom(ListRequestMetadata()) 5112 if self.parent.page_limit > 0: 5113 req.meta.limit = self.parent.page_limit 5114 if self.parent.snapshot_datetime is not None: 5115 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5116 5117 req.filter = plumbing.quote_filter_args(filter, *args) 5118 5119 def generator(svc, req): 5120 tries = 0 5121 while True: 5122 t = None if deadline is None else deadline - time.time() 5123 try: 5124 plumbing_response = svc.stub.List( 5125 req, 5126 metadata=svc.parent.get_metadata( 5127 'PeeringGroups.List', req), 5128 timeout=t) 5129 except Exception as e: 5130 if self.parent.shouldRetry(tries, e, deadline): 5131 tries += 1 5132 time.sleep( 5133 self.parent.exponentialBackoff(tries, deadline)) 5134 continue 5135 raise plumbing.convert_error_to_porcelain(e) from e 5136 tries = 0 5137 for plumbing_item in plumbing_response.peering_groups: 5138 yield plumbing.convert_peering_group_to_porcelain( 5139 plumbing_item) 5140 if plumbing_response.meta.next_cursor == '': 5141 break 5142 req.meta.cursor = plumbing_response.meta.next_cursor 5143 5144 return generator(self, req)
List gets a list of Peering Groups.
class
Policies:
5147class Policies: 5148 ''' 5149 Policies are the collection of one or more statements that enforce fine-grained access 5150 control for the users of an organization. 5151 See `strongdm.models.Policy`. 5152 ''' 5153 def __init__(self, channel, client): 5154 self.parent = client 5155 self.stub = PoliciesStub(channel) 5156 5157 def create(self, policy, timeout=None): 5158 ''' 5159 Create creates a new Policy. 5160 ''' 5161 deadline = None if timeout is None else time.time() + timeout 5162 req = PolicyCreateRequest() 5163 5164 if policy is not None: 5165 req.policy.CopyFrom(plumbing.convert_policy_to_plumbing(policy)) 5166 tries = 0 5167 plumbing_response = None 5168 while True: 5169 t = None if deadline is None else deadline - time.time() 5170 try: 5171 plumbing_response = self.stub.Create( 5172 req, 5173 metadata=self.parent.get_metadata('Policies.Create', req), 5174 timeout=t) 5175 except Exception as e: 5176 if self.parent.shouldRetry(tries, e, deadline): 5177 tries += 1 5178 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5179 continue 5180 raise plumbing.convert_error_to_porcelain(e) from e 5181 break 5182 5183 resp = models.PolicyCreateResponse() 5184 resp.policy = plumbing.convert_policy_to_porcelain( 5185 plumbing_response.policy) 5186 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5187 plumbing_response.rate_limit) 5188 return resp 5189 5190 def delete(self, id, timeout=None): 5191 ''' 5192 Delete removes a Policy by ID. 5193 ''' 5194 deadline = None if timeout is None else time.time() + timeout 5195 req = PolicyDeleteRequest() 5196 5197 req.id = (id) 5198 tries = 0 5199 plumbing_response = None 5200 while True: 5201 t = None if deadline is None else deadline - time.time() 5202 try: 5203 plumbing_response = self.stub.Delete( 5204 req, 5205 metadata=self.parent.get_metadata('Policies.Delete', req), 5206 timeout=t) 5207 except Exception as e: 5208 if self.parent.shouldRetry(tries, e, deadline): 5209 tries += 1 5210 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5211 continue 5212 raise plumbing.convert_error_to_porcelain(e) from e 5213 break 5214 5215 resp = models.PolicyDeleteResponse() 5216 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5217 plumbing_response.rate_limit) 5218 return resp 5219 5220 def update(self, policy, timeout=None): 5221 ''' 5222 Update replaces all the fields of a Policy by ID. 5223 ''' 5224 deadline = None if timeout is None else time.time() + timeout 5225 req = PolicyUpdateRequest() 5226 5227 if policy is not None: 5228 req.policy.CopyFrom(plumbing.convert_policy_to_plumbing(policy)) 5229 tries = 0 5230 plumbing_response = None 5231 while True: 5232 t = None if deadline is None else deadline - time.time() 5233 try: 5234 plumbing_response = self.stub.Update( 5235 req, 5236 metadata=self.parent.get_metadata('Policies.Update', req), 5237 timeout=t) 5238 except Exception as e: 5239 if self.parent.shouldRetry(tries, e, deadline): 5240 tries += 1 5241 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5242 continue 5243 raise plumbing.convert_error_to_porcelain(e) from e 5244 break 5245 5246 resp = models.PolicyUpdateResponse() 5247 resp.policy = plumbing.convert_policy_to_porcelain( 5248 plumbing_response.policy) 5249 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5250 plumbing_response.rate_limit) 5251 return resp 5252 5253 def get(self, id, timeout=None): 5254 ''' 5255 Get reads one Policy by ID. 5256 ''' 5257 deadline = None if timeout is None else time.time() + timeout 5258 req = PolicyGetRequest() 5259 if self.parent.snapshot_datetime is not None: 5260 req.meta.CopyFrom(GetRequestMetadata()) 5261 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5262 5263 req.id = (id) 5264 tries = 0 5265 plumbing_response = None 5266 while True: 5267 t = None if deadline is None else deadline - time.time() 5268 try: 5269 plumbing_response = self.stub.Get( 5270 req, 5271 metadata=self.parent.get_metadata('Policies.Get', req), 5272 timeout=t) 5273 except Exception as e: 5274 if self.parent.shouldRetry(tries, e, deadline): 5275 tries += 1 5276 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5277 continue 5278 raise plumbing.convert_error_to_porcelain(e) from e 5279 break 5280 5281 resp = models.PolicyGetResponse() 5282 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5283 plumbing_response.meta) 5284 resp.policy = plumbing.convert_policy_to_porcelain( 5285 plumbing_response.policy) 5286 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5287 plumbing_response.rate_limit) 5288 return resp 5289 5290 def list(self, filter, *args, timeout=None): 5291 ''' 5292 List gets a list of Policy matching a given set of criteria 5293 ''' 5294 deadline = None if timeout is None else time.time() + timeout 5295 req = PolicyListRequest() 5296 req.meta.CopyFrom(ListRequestMetadata()) 5297 if self.parent.page_limit > 0: 5298 req.meta.limit = self.parent.page_limit 5299 if self.parent.snapshot_datetime is not None: 5300 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5301 5302 req.filter = plumbing.quote_filter_args(filter, *args) 5303 5304 def generator(svc, req): 5305 tries = 0 5306 while True: 5307 t = None if deadline is None else deadline - time.time() 5308 try: 5309 plumbing_response = svc.stub.List( 5310 req, 5311 metadata=svc.parent.get_metadata('Policies.List', req), 5312 timeout=t) 5313 except Exception as e: 5314 if self.parent.shouldRetry(tries, e, deadline): 5315 tries += 1 5316 time.sleep( 5317 self.parent.exponentialBackoff(tries, deadline)) 5318 continue 5319 raise plumbing.convert_error_to_porcelain(e) from e 5320 tries = 0 5321 for plumbing_item in plumbing_response.policies: 5322 yield plumbing.convert_policy_to_porcelain(plumbing_item) 5323 if plumbing_response.meta.next_cursor == '': 5324 break 5325 req.meta.cursor = plumbing_response.meta.next_cursor 5326 5327 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)
5157 def create(self, policy, timeout=None): 5158 ''' 5159 Create creates a new Policy. 5160 ''' 5161 deadline = None if timeout is None else time.time() + timeout 5162 req = PolicyCreateRequest() 5163 5164 if policy is not None: 5165 req.policy.CopyFrom(plumbing.convert_policy_to_plumbing(policy)) 5166 tries = 0 5167 plumbing_response = None 5168 while True: 5169 t = None if deadline is None else deadline - time.time() 5170 try: 5171 plumbing_response = self.stub.Create( 5172 req, 5173 metadata=self.parent.get_metadata('Policies.Create', req), 5174 timeout=t) 5175 except Exception as e: 5176 if self.parent.shouldRetry(tries, e, deadline): 5177 tries += 1 5178 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5179 continue 5180 raise plumbing.convert_error_to_porcelain(e) from e 5181 break 5182 5183 resp = models.PolicyCreateResponse() 5184 resp.policy = plumbing.convert_policy_to_porcelain( 5185 plumbing_response.policy) 5186 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5187 plumbing_response.rate_limit) 5188 return resp
Create creates a new Policy.
def
delete(self, id, timeout=None)
5190 def delete(self, id, timeout=None): 5191 ''' 5192 Delete removes a Policy by ID. 5193 ''' 5194 deadline = None if timeout is None else time.time() + timeout 5195 req = PolicyDeleteRequest() 5196 5197 req.id = (id) 5198 tries = 0 5199 plumbing_response = None 5200 while True: 5201 t = None if deadline is None else deadline - time.time() 5202 try: 5203 plumbing_response = self.stub.Delete( 5204 req, 5205 metadata=self.parent.get_metadata('Policies.Delete', req), 5206 timeout=t) 5207 except Exception as e: 5208 if self.parent.shouldRetry(tries, e, deadline): 5209 tries += 1 5210 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5211 continue 5212 raise plumbing.convert_error_to_porcelain(e) from e 5213 break 5214 5215 resp = models.PolicyDeleteResponse() 5216 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5217 plumbing_response.rate_limit) 5218 return resp
Delete removes a Policy by ID.
def
update(self, policy, timeout=None)
5220 def update(self, policy, timeout=None): 5221 ''' 5222 Update replaces all the fields of a Policy by ID. 5223 ''' 5224 deadline = None if timeout is None else time.time() + timeout 5225 req = PolicyUpdateRequest() 5226 5227 if policy is not None: 5228 req.policy.CopyFrom(plumbing.convert_policy_to_plumbing(policy)) 5229 tries = 0 5230 plumbing_response = None 5231 while True: 5232 t = None if deadline is None else deadline - time.time() 5233 try: 5234 plumbing_response = self.stub.Update( 5235 req, 5236 metadata=self.parent.get_metadata('Policies.Update', req), 5237 timeout=t) 5238 except Exception as e: 5239 if self.parent.shouldRetry(tries, e, deadline): 5240 tries += 1 5241 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5242 continue 5243 raise plumbing.convert_error_to_porcelain(e) from e 5244 break 5245 5246 resp = models.PolicyUpdateResponse() 5247 resp.policy = plumbing.convert_policy_to_porcelain( 5248 plumbing_response.policy) 5249 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5250 plumbing_response.rate_limit) 5251 return resp
Update replaces all the fields of a Policy by ID.
def
get(self, id, timeout=None)
5253 def get(self, id, timeout=None): 5254 ''' 5255 Get reads one Policy by ID. 5256 ''' 5257 deadline = None if timeout is None else time.time() + timeout 5258 req = PolicyGetRequest() 5259 if self.parent.snapshot_datetime is not None: 5260 req.meta.CopyFrom(GetRequestMetadata()) 5261 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5262 5263 req.id = (id) 5264 tries = 0 5265 plumbing_response = None 5266 while True: 5267 t = None if deadline is None else deadline - time.time() 5268 try: 5269 plumbing_response = self.stub.Get( 5270 req, 5271 metadata=self.parent.get_metadata('Policies.Get', req), 5272 timeout=t) 5273 except Exception as e: 5274 if self.parent.shouldRetry(tries, e, deadline): 5275 tries += 1 5276 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5277 continue 5278 raise plumbing.convert_error_to_porcelain(e) from e 5279 break 5280 5281 resp = models.PolicyGetResponse() 5282 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5283 plumbing_response.meta) 5284 resp.policy = plumbing.convert_policy_to_porcelain( 5285 plumbing_response.policy) 5286 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5287 plumbing_response.rate_limit) 5288 return resp
Get reads one Policy by ID.
def
list(self, filter, *args, timeout=None)
5290 def list(self, filter, *args, timeout=None): 5291 ''' 5292 List gets a list of Policy matching a given set of criteria 5293 ''' 5294 deadline = None if timeout is None else time.time() + timeout 5295 req = PolicyListRequest() 5296 req.meta.CopyFrom(ListRequestMetadata()) 5297 if self.parent.page_limit > 0: 5298 req.meta.limit = self.parent.page_limit 5299 if self.parent.snapshot_datetime is not None: 5300 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5301 5302 req.filter = plumbing.quote_filter_args(filter, *args) 5303 5304 def generator(svc, req): 5305 tries = 0 5306 while True: 5307 t = None if deadline is None else deadline - time.time() 5308 try: 5309 plumbing_response = svc.stub.List( 5310 req, 5311 metadata=svc.parent.get_metadata('Policies.List', req), 5312 timeout=t) 5313 except Exception as e: 5314 if self.parent.shouldRetry(tries, e, deadline): 5315 tries += 1 5316 time.sleep( 5317 self.parent.exponentialBackoff(tries, deadline)) 5318 continue 5319 raise plumbing.convert_error_to_porcelain(e) from e 5320 tries = 0 5321 for plumbing_item in plumbing_response.policies: 5322 yield plumbing.convert_policy_to_porcelain(plumbing_item) 5323 if plumbing_response.meta.next_cursor == '': 5324 break 5325 req.meta.cursor = plumbing_response.meta.next_cursor 5326 5327 return generator(self, req)
List gets a list of Policy matching a given set of criteria
class
SnapshotPolicies:
5330class SnapshotPolicies: 5331 ''' 5332 SnapshotPolicies exposes the read only methods of the Policies 5333 service for historical queries. 5334 ''' 5335 def __init__(self, policies): 5336 self.policies = policies 5337 5338 def get(self, id, timeout=None): 5339 ''' 5340 Get reads one Policy by ID. 5341 ''' 5342 return self.policies.get(id, timeout=timeout) 5343 5344 def list(self, filter, *args, timeout=None): 5345 ''' 5346 List gets a list of Policy matching a given set of criteria 5347 ''' 5348 return self.policies.list(filter, *args, timeout=timeout)
SnapshotPolicies exposes the read only methods of the Policies service for historical queries.
class
PoliciesHistory:
5351class PoliciesHistory: 5352 ''' 5353 PoliciesHistory records all changes to the state of a Policy. 5354 See `strongdm.models.PolicyHistory`. 5355 ''' 5356 def __init__(self, channel, client): 5357 self.parent = client 5358 self.stub = PoliciesHistoryStub(channel) 5359 5360 def list(self, filter, *args, timeout=None): 5361 ''' 5362 List gets a list of PolicyHistory records matching a given set of criteria. 5363 ''' 5364 deadline = None if timeout is None else time.time() + timeout 5365 req = PoliciesHistoryListRequest() 5366 req.meta.CopyFrom(ListRequestMetadata()) 5367 if self.parent.page_limit > 0: 5368 req.meta.limit = self.parent.page_limit 5369 if self.parent.snapshot_datetime is not None: 5370 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5371 5372 req.filter = plumbing.quote_filter_args(filter, *args) 5373 5374 def generator(svc, req): 5375 tries = 0 5376 while True: 5377 t = None if deadline is None else deadline - time.time() 5378 try: 5379 plumbing_response = svc.stub.List( 5380 req, 5381 metadata=svc.parent.get_metadata( 5382 'PoliciesHistory.List', req), 5383 timeout=t) 5384 except Exception as e: 5385 if self.parent.shouldRetry(tries, e, deadline): 5386 tries += 1 5387 time.sleep( 5388 self.parent.exponentialBackoff(tries, deadline)) 5389 continue 5390 raise plumbing.convert_error_to_porcelain(e) from e 5391 tries = 0 5392 for plumbing_item in plumbing_response.history: 5393 yield plumbing.convert_policy_history_to_porcelain( 5394 plumbing_item) 5395 if plumbing_response.meta.next_cursor == '': 5396 break 5397 req.meta.cursor = plumbing_response.meta.next_cursor 5398 5399 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)
5360 def list(self, filter, *args, timeout=None): 5361 ''' 5362 List gets a list of PolicyHistory records matching a given set of criteria. 5363 ''' 5364 deadline = None if timeout is None else time.time() + timeout 5365 req = PoliciesHistoryListRequest() 5366 req.meta.CopyFrom(ListRequestMetadata()) 5367 if self.parent.page_limit > 0: 5368 req.meta.limit = self.parent.page_limit 5369 if self.parent.snapshot_datetime is not None: 5370 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5371 5372 req.filter = plumbing.quote_filter_args(filter, *args) 5373 5374 def generator(svc, req): 5375 tries = 0 5376 while True: 5377 t = None if deadline is None else deadline - time.time() 5378 try: 5379 plumbing_response = svc.stub.List( 5380 req, 5381 metadata=svc.parent.get_metadata( 5382 'PoliciesHistory.List', req), 5383 timeout=t) 5384 except Exception as e: 5385 if self.parent.shouldRetry(tries, e, deadline): 5386 tries += 1 5387 time.sleep( 5388 self.parent.exponentialBackoff(tries, deadline)) 5389 continue 5390 raise plumbing.convert_error_to_porcelain(e) from e 5391 tries = 0 5392 for plumbing_item in plumbing_response.history: 5393 yield plumbing.convert_policy_history_to_porcelain( 5394 plumbing_item) 5395 if plumbing_response.meta.next_cursor == '': 5396 break 5397 req.meta.cursor = plumbing_response.meta.next_cursor 5398 5399 return generator(self, req)
List gets a list of PolicyHistory records matching a given set of criteria.
class
ProxyClusterKeys:
5402class ProxyClusterKeys: 5403 ''' 5404 Proxy Cluster Keys are authentication keys for all proxies within a cluster. 5405 The proxies within a cluster share the same key. One cluster can have 5406 multiple keys in order to facilitate key rotation. 5407 See `strongdm.models.ProxyClusterKey`. 5408 ''' 5409 def __init__(self, channel, client): 5410 self.parent = client 5411 self.stub = ProxyClusterKeysStub(channel) 5412 5413 def create(self, proxy_cluster_key, timeout=None): 5414 ''' 5415 Create registers a new ProxyClusterKey. 5416 ''' 5417 deadline = None if timeout is None else time.time() + timeout 5418 req = ProxyClusterKeyCreateRequest() 5419 5420 if proxy_cluster_key is not None: 5421 req.proxy_cluster_key.CopyFrom( 5422 plumbing.convert_proxy_cluster_key_to_plumbing( 5423 proxy_cluster_key)) 5424 tries = 0 5425 plumbing_response = None 5426 while True: 5427 t = None if deadline is None else deadline - time.time() 5428 try: 5429 plumbing_response = self.stub.Create( 5430 req, 5431 metadata=self.parent.get_metadata( 5432 'ProxyClusterKeys.Create', req), 5433 timeout=t) 5434 except Exception as e: 5435 if self.parent.shouldRetry(tries, e, deadline): 5436 tries += 1 5437 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5438 continue 5439 raise plumbing.convert_error_to_porcelain(e) from e 5440 break 5441 5442 resp = models.ProxyClusterKeyCreateResponse() 5443 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5444 plumbing_response.meta) 5445 resp.proxy_cluster_key = plumbing.convert_proxy_cluster_key_to_porcelain( 5446 plumbing_response.proxy_cluster_key) 5447 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5448 plumbing_response.rate_limit) 5449 resp.secret_key = (plumbing_response.secret_key) 5450 return resp 5451 5452 def get(self, id, timeout=None): 5453 ''' 5454 Get reads one ProxyClusterKey by ID. 5455 ''' 5456 deadline = None if timeout is None else time.time() + timeout 5457 req = ProxyClusterKeyGetRequest() 5458 if self.parent.snapshot_datetime is not None: 5459 req.meta.CopyFrom(GetRequestMetadata()) 5460 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5461 5462 req.id = (id) 5463 tries = 0 5464 plumbing_response = None 5465 while True: 5466 t = None if deadline is None else deadline - time.time() 5467 try: 5468 plumbing_response = self.stub.Get( 5469 req, 5470 metadata=self.parent.get_metadata('ProxyClusterKeys.Get', 5471 req), 5472 timeout=t) 5473 except Exception as e: 5474 if self.parent.shouldRetry(tries, e, deadline): 5475 tries += 1 5476 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5477 continue 5478 raise plumbing.convert_error_to_porcelain(e) from e 5479 break 5480 5481 resp = models.ProxyClusterKeyGetResponse() 5482 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5483 plumbing_response.meta) 5484 resp.proxy_cluster_key = plumbing.convert_proxy_cluster_key_to_porcelain( 5485 plumbing_response.proxy_cluster_key) 5486 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5487 plumbing_response.rate_limit) 5488 return resp 5489 5490 def delete(self, id, timeout=None): 5491 ''' 5492 Delete removes a ProxyClusterKey by ID. 5493 ''' 5494 deadline = None if timeout is None else time.time() + timeout 5495 req = ProxyClusterKeyDeleteRequest() 5496 5497 req.id = (id) 5498 tries = 0 5499 plumbing_response = None 5500 while True: 5501 t = None if deadline is None else deadline - time.time() 5502 try: 5503 plumbing_response = self.stub.Delete( 5504 req, 5505 metadata=self.parent.get_metadata( 5506 'ProxyClusterKeys.Delete', req), 5507 timeout=t) 5508 except Exception as e: 5509 if self.parent.shouldRetry(tries, e, deadline): 5510 tries += 1 5511 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5512 continue 5513 raise plumbing.convert_error_to_porcelain(e) from e 5514 break 5515 5516 resp = models.ProxyClusterKeyDeleteResponse() 5517 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 5518 plumbing_response.meta) 5519 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5520 plumbing_response.rate_limit) 5521 return resp 5522 5523 def list(self, filter, *args, timeout=None): 5524 ''' 5525 List gets a list of ProxyClusterKeys matching a given set of criteria. 5526 ''' 5527 deadline = None if timeout is None else time.time() + timeout 5528 req = ProxyClusterKeyListRequest() 5529 req.meta.CopyFrom(ListRequestMetadata()) 5530 if self.parent.page_limit > 0: 5531 req.meta.limit = self.parent.page_limit 5532 if self.parent.snapshot_datetime is not None: 5533 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5534 5535 req.filter = plumbing.quote_filter_args(filter, *args) 5536 5537 def generator(svc, req): 5538 tries = 0 5539 while True: 5540 t = None if deadline is None else deadline - time.time() 5541 try: 5542 plumbing_response = svc.stub.List( 5543 req, 5544 metadata=svc.parent.get_metadata( 5545 'ProxyClusterKeys.List', req), 5546 timeout=t) 5547 except Exception as e: 5548 if self.parent.shouldRetry(tries, e, deadline): 5549 tries += 1 5550 time.sleep( 5551 self.parent.exponentialBackoff(tries, deadline)) 5552 continue 5553 raise plumbing.convert_error_to_porcelain(e) from e 5554 tries = 0 5555 for plumbing_item in plumbing_response.proxy_cluster_keys: 5556 yield plumbing.convert_proxy_cluster_key_to_porcelain( 5557 plumbing_item) 5558 if plumbing_response.meta.next_cursor == '': 5559 break 5560 req.meta.cursor = plumbing_response.meta.next_cursor 5561 5562 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)
5413 def create(self, proxy_cluster_key, timeout=None): 5414 ''' 5415 Create registers a new ProxyClusterKey. 5416 ''' 5417 deadline = None if timeout is None else time.time() + timeout 5418 req = ProxyClusterKeyCreateRequest() 5419 5420 if proxy_cluster_key is not None: 5421 req.proxy_cluster_key.CopyFrom( 5422 plumbing.convert_proxy_cluster_key_to_plumbing( 5423 proxy_cluster_key)) 5424 tries = 0 5425 plumbing_response = None 5426 while True: 5427 t = None if deadline is None else deadline - time.time() 5428 try: 5429 plumbing_response = self.stub.Create( 5430 req, 5431 metadata=self.parent.get_metadata( 5432 'ProxyClusterKeys.Create', req), 5433 timeout=t) 5434 except Exception as e: 5435 if self.parent.shouldRetry(tries, e, deadline): 5436 tries += 1 5437 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5438 continue 5439 raise plumbing.convert_error_to_porcelain(e) from e 5440 break 5441 5442 resp = models.ProxyClusterKeyCreateResponse() 5443 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5444 plumbing_response.meta) 5445 resp.proxy_cluster_key = plumbing.convert_proxy_cluster_key_to_porcelain( 5446 plumbing_response.proxy_cluster_key) 5447 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5448 plumbing_response.rate_limit) 5449 resp.secret_key = (plumbing_response.secret_key) 5450 return resp
Create registers a new ProxyClusterKey.
def
get(self, id, timeout=None)
5452 def get(self, id, timeout=None): 5453 ''' 5454 Get reads one ProxyClusterKey by ID. 5455 ''' 5456 deadline = None if timeout is None else time.time() + timeout 5457 req = ProxyClusterKeyGetRequest() 5458 if self.parent.snapshot_datetime is not None: 5459 req.meta.CopyFrom(GetRequestMetadata()) 5460 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5461 5462 req.id = (id) 5463 tries = 0 5464 plumbing_response = None 5465 while True: 5466 t = None if deadline is None else deadline - time.time() 5467 try: 5468 plumbing_response = self.stub.Get( 5469 req, 5470 metadata=self.parent.get_metadata('ProxyClusterKeys.Get', 5471 req), 5472 timeout=t) 5473 except Exception as e: 5474 if self.parent.shouldRetry(tries, e, deadline): 5475 tries += 1 5476 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5477 continue 5478 raise plumbing.convert_error_to_porcelain(e) from e 5479 break 5480 5481 resp = models.ProxyClusterKeyGetResponse() 5482 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5483 plumbing_response.meta) 5484 resp.proxy_cluster_key = plumbing.convert_proxy_cluster_key_to_porcelain( 5485 plumbing_response.proxy_cluster_key) 5486 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5487 plumbing_response.rate_limit) 5488 return resp
Get reads one ProxyClusterKey by ID.
def
delete(self, id, timeout=None)
5490 def delete(self, id, timeout=None): 5491 ''' 5492 Delete removes a ProxyClusterKey by ID. 5493 ''' 5494 deadline = None if timeout is None else time.time() + timeout 5495 req = ProxyClusterKeyDeleteRequest() 5496 5497 req.id = (id) 5498 tries = 0 5499 plumbing_response = None 5500 while True: 5501 t = None if deadline is None else deadline - time.time() 5502 try: 5503 plumbing_response = self.stub.Delete( 5504 req, 5505 metadata=self.parent.get_metadata( 5506 'ProxyClusterKeys.Delete', req), 5507 timeout=t) 5508 except Exception as e: 5509 if self.parent.shouldRetry(tries, e, deadline): 5510 tries += 1 5511 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5512 continue 5513 raise plumbing.convert_error_to_porcelain(e) from e 5514 break 5515 5516 resp = models.ProxyClusterKeyDeleteResponse() 5517 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 5518 plumbing_response.meta) 5519 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5520 plumbing_response.rate_limit) 5521 return resp
Delete removes a ProxyClusterKey by ID.
def
list(self, filter, *args, timeout=None)
5523 def list(self, filter, *args, timeout=None): 5524 ''' 5525 List gets a list of ProxyClusterKeys matching a given set of criteria. 5526 ''' 5527 deadline = None if timeout is None else time.time() + timeout 5528 req = ProxyClusterKeyListRequest() 5529 req.meta.CopyFrom(ListRequestMetadata()) 5530 if self.parent.page_limit > 0: 5531 req.meta.limit = self.parent.page_limit 5532 if self.parent.snapshot_datetime is not None: 5533 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5534 5535 req.filter = plumbing.quote_filter_args(filter, *args) 5536 5537 def generator(svc, req): 5538 tries = 0 5539 while True: 5540 t = None if deadline is None else deadline - time.time() 5541 try: 5542 plumbing_response = svc.stub.List( 5543 req, 5544 metadata=svc.parent.get_metadata( 5545 'ProxyClusterKeys.List', req), 5546 timeout=t) 5547 except Exception as e: 5548 if self.parent.shouldRetry(tries, e, deadline): 5549 tries += 1 5550 time.sleep( 5551 self.parent.exponentialBackoff(tries, deadline)) 5552 continue 5553 raise plumbing.convert_error_to_porcelain(e) from e 5554 tries = 0 5555 for plumbing_item in plumbing_response.proxy_cluster_keys: 5556 yield plumbing.convert_proxy_cluster_key_to_porcelain( 5557 plumbing_item) 5558 if plumbing_response.meta.next_cursor == '': 5559 break 5560 req.meta.cursor = plumbing_response.meta.next_cursor 5561 5562 return generator(self, req)
List gets a list of ProxyClusterKeys matching a given set of criteria.
class
SnapshotProxyClusterKeys:
5565class SnapshotProxyClusterKeys: 5566 ''' 5567 SnapshotProxyClusterKeys exposes the read only methods of the ProxyClusterKeys 5568 service for historical queries. 5569 ''' 5570 def __init__(self, proxy_cluster_keys): 5571 self.proxy_cluster_keys = proxy_cluster_keys 5572 5573 def get(self, id, timeout=None): 5574 ''' 5575 Get reads one ProxyClusterKey by ID. 5576 ''' 5577 return self.proxy_cluster_keys.get(id, timeout=timeout) 5578 5579 def list(self, filter, *args, timeout=None): 5580 ''' 5581 List gets a list of ProxyClusterKeys matching a given set of criteria. 5582 ''' 5583 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)
5573 def get(self, id, timeout=None): 5574 ''' 5575 Get reads one ProxyClusterKey by ID. 5576 ''' 5577 return self.proxy_cluster_keys.get(id, timeout=timeout)
Get reads one ProxyClusterKey by ID.
def
list(self, filter, *args, timeout=None)
5579 def list(self, filter, *args, timeout=None): 5580 ''' 5581 List gets a list of ProxyClusterKeys matching a given set of criteria. 5582 ''' 5583 return self.proxy_cluster_keys.list(filter, *args, timeout=timeout)
List gets a list of ProxyClusterKeys matching a given set of criteria.
class
Queries:
5586class Queries: 5587 ''' 5588 A Query is a record of a single client request to a resource, such as a SQL query. 5589 Long-running SSH, RDP, or Kubernetes interactive sessions also count as queries. 5590 The Queries service is read-only. 5591 See `strongdm.models.Query`. 5592 ''' 5593 def __init__(self, channel, client): 5594 self.parent = client 5595 self.stub = QueriesStub(channel) 5596 5597 def list(self, filter, *args, timeout=None): 5598 ''' 5599 List gets a list of Queries matching a given set of criteria. 5600 ''' 5601 deadline = None if timeout is None else time.time() + timeout 5602 req = QueryListRequest() 5603 req.meta.CopyFrom(ListRequestMetadata()) 5604 if self.parent.page_limit > 0: 5605 req.meta.limit = self.parent.page_limit 5606 if self.parent.snapshot_datetime is not None: 5607 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5608 5609 req.filter = plumbing.quote_filter_args(filter, *args) 5610 5611 def generator(svc, req): 5612 tries = 0 5613 while True: 5614 t = None if deadline is None else deadline - time.time() 5615 try: 5616 plumbing_response = svc.stub.List( 5617 req, 5618 metadata=svc.parent.get_metadata('Queries.List', req), 5619 timeout=t) 5620 except Exception as e: 5621 if self.parent.shouldRetry(tries, e, deadline): 5622 tries += 1 5623 time.sleep( 5624 self.parent.exponentialBackoff(tries, deadline)) 5625 continue 5626 raise plumbing.convert_error_to_porcelain(e) from e 5627 tries = 0 5628 for plumbing_item in plumbing_response.queries: 5629 yield plumbing.convert_query_to_porcelain(plumbing_item) 5630 if plumbing_response.meta.next_cursor == '': 5631 break 5632 req.meta.cursor = plumbing_response.meta.next_cursor 5633 5634 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)
5597 def list(self, filter, *args, timeout=None): 5598 ''' 5599 List gets a list of Queries matching a given set of criteria. 5600 ''' 5601 deadline = None if timeout is None else time.time() + timeout 5602 req = QueryListRequest() 5603 req.meta.CopyFrom(ListRequestMetadata()) 5604 if self.parent.page_limit > 0: 5605 req.meta.limit = self.parent.page_limit 5606 if self.parent.snapshot_datetime is not None: 5607 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5608 5609 req.filter = plumbing.quote_filter_args(filter, *args) 5610 5611 def generator(svc, req): 5612 tries = 0 5613 while True: 5614 t = None if deadline is None else deadline - time.time() 5615 try: 5616 plumbing_response = svc.stub.List( 5617 req, 5618 metadata=svc.parent.get_metadata('Queries.List', req), 5619 timeout=t) 5620 except Exception as e: 5621 if self.parent.shouldRetry(tries, e, deadline): 5622 tries += 1 5623 time.sleep( 5624 self.parent.exponentialBackoff(tries, deadline)) 5625 continue 5626 raise plumbing.convert_error_to_porcelain(e) from e 5627 tries = 0 5628 for plumbing_item in plumbing_response.queries: 5629 yield plumbing.convert_query_to_porcelain(plumbing_item) 5630 if plumbing_response.meta.next_cursor == '': 5631 break 5632 req.meta.cursor = plumbing_response.meta.next_cursor 5633 5634 return generator(self, req)
List gets a list of Queries matching a given set of criteria.
class
RemoteIdentities:
5637class RemoteIdentities: 5638 ''' 5639 RemoteIdentities assign a resource directly to an account, giving the account the permission to connect to that resource. 5640 See `strongdm.models.RemoteIdentity`. 5641 ''' 5642 def __init__(self, channel, client): 5643 self.parent = client 5644 self.stub = RemoteIdentitiesStub(channel) 5645 5646 def create(self, remote_identity, timeout=None): 5647 ''' 5648 Create registers a new RemoteIdentity. 5649 ''' 5650 deadline = None if timeout is None else time.time() + timeout 5651 req = RemoteIdentityCreateRequest() 5652 5653 if remote_identity is not None: 5654 req.remote_identity.CopyFrom( 5655 plumbing.convert_remote_identity_to_plumbing(remote_identity)) 5656 tries = 0 5657 plumbing_response = None 5658 while True: 5659 t = None if deadline is None else deadline - time.time() 5660 try: 5661 plumbing_response = self.stub.Create( 5662 req, 5663 metadata=self.parent.get_metadata( 5664 'RemoteIdentities.Create', req), 5665 timeout=t) 5666 except Exception as e: 5667 if self.parent.shouldRetry(tries, e, deadline): 5668 tries += 1 5669 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5670 continue 5671 raise plumbing.convert_error_to_porcelain(e) from e 5672 break 5673 5674 resp = models.RemoteIdentityCreateResponse() 5675 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5676 plumbing_response.meta) 5677 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5678 plumbing_response.rate_limit) 5679 resp.remote_identity = plumbing.convert_remote_identity_to_porcelain( 5680 plumbing_response.remote_identity) 5681 return resp 5682 5683 def get(self, id, timeout=None): 5684 ''' 5685 Get reads one RemoteIdentity by ID. 5686 ''' 5687 deadline = None if timeout is None else time.time() + timeout 5688 req = RemoteIdentityGetRequest() 5689 if self.parent.snapshot_datetime is not None: 5690 req.meta.CopyFrom(GetRequestMetadata()) 5691 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5692 5693 req.id = (id) 5694 tries = 0 5695 plumbing_response = None 5696 while True: 5697 t = None if deadline is None else deadline - time.time() 5698 try: 5699 plumbing_response = self.stub.Get( 5700 req, 5701 metadata=self.parent.get_metadata('RemoteIdentities.Get', 5702 req), 5703 timeout=t) 5704 except Exception as e: 5705 if self.parent.shouldRetry(tries, e, deadline): 5706 tries += 1 5707 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5708 continue 5709 raise plumbing.convert_error_to_porcelain(e) from e 5710 break 5711 5712 resp = models.RemoteIdentityGetResponse() 5713 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5714 plumbing_response.meta) 5715 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5716 plumbing_response.rate_limit) 5717 resp.remote_identity = plumbing.convert_remote_identity_to_porcelain( 5718 plumbing_response.remote_identity) 5719 return resp 5720 5721 def update(self, remote_identity, timeout=None): 5722 ''' 5723 Update replaces all the fields of a RemoteIdentity by ID. 5724 ''' 5725 deadline = None if timeout is None else time.time() + timeout 5726 req = RemoteIdentityUpdateRequest() 5727 5728 if remote_identity is not None: 5729 req.remote_identity.CopyFrom( 5730 plumbing.convert_remote_identity_to_plumbing(remote_identity)) 5731 tries = 0 5732 plumbing_response = None 5733 while True: 5734 t = None if deadline is None else deadline - time.time() 5735 try: 5736 plumbing_response = self.stub.Update( 5737 req, 5738 metadata=self.parent.get_metadata( 5739 'RemoteIdentities.Update', req), 5740 timeout=t) 5741 except Exception as e: 5742 if self.parent.shouldRetry(tries, e, deadline): 5743 tries += 1 5744 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5745 continue 5746 raise plumbing.convert_error_to_porcelain(e) from e 5747 break 5748 5749 resp = models.RemoteIdentityUpdateResponse() 5750 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 5751 plumbing_response.meta) 5752 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5753 plumbing_response.rate_limit) 5754 resp.remote_identity = plumbing.convert_remote_identity_to_porcelain( 5755 plumbing_response.remote_identity) 5756 return resp 5757 5758 def delete(self, id, timeout=None): 5759 ''' 5760 Delete removes a RemoteIdentity by ID. 5761 ''' 5762 deadline = None if timeout is None else time.time() + timeout 5763 req = RemoteIdentityDeleteRequest() 5764 5765 req.id = (id) 5766 tries = 0 5767 plumbing_response = None 5768 while True: 5769 t = None if deadline is None else deadline - time.time() 5770 try: 5771 plumbing_response = self.stub.Delete( 5772 req, 5773 metadata=self.parent.get_metadata( 5774 'RemoteIdentities.Delete', req), 5775 timeout=t) 5776 except Exception as e: 5777 if self.parent.shouldRetry(tries, e, deadline): 5778 tries += 1 5779 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5780 continue 5781 raise plumbing.convert_error_to_porcelain(e) from e 5782 break 5783 5784 resp = models.RemoteIdentityDeleteResponse() 5785 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 5786 plumbing_response.meta) 5787 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5788 plumbing_response.rate_limit) 5789 return resp 5790 5791 def list(self, filter, *args, timeout=None): 5792 ''' 5793 List gets a list of RemoteIdentities matching a given set of criteria. 5794 ''' 5795 deadline = None if timeout is None else time.time() + timeout 5796 req = RemoteIdentityListRequest() 5797 req.meta.CopyFrom(ListRequestMetadata()) 5798 if self.parent.page_limit > 0: 5799 req.meta.limit = self.parent.page_limit 5800 if self.parent.snapshot_datetime is not None: 5801 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5802 5803 req.filter = plumbing.quote_filter_args(filter, *args) 5804 5805 def generator(svc, req): 5806 tries = 0 5807 while True: 5808 t = None if deadline is None else deadline - time.time() 5809 try: 5810 plumbing_response = svc.stub.List( 5811 req, 5812 metadata=svc.parent.get_metadata( 5813 'RemoteIdentities.List', req), 5814 timeout=t) 5815 except Exception as e: 5816 if self.parent.shouldRetry(tries, e, deadline): 5817 tries += 1 5818 time.sleep( 5819 self.parent.exponentialBackoff(tries, deadline)) 5820 continue 5821 raise plumbing.convert_error_to_porcelain(e) from e 5822 tries = 0 5823 for plumbing_item in plumbing_response.remote_identities: 5824 yield plumbing.convert_remote_identity_to_porcelain( 5825 plumbing_item) 5826 if plumbing_response.meta.next_cursor == '': 5827 break 5828 req.meta.cursor = plumbing_response.meta.next_cursor 5829 5830 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)
5646 def create(self, remote_identity, timeout=None): 5647 ''' 5648 Create registers a new RemoteIdentity. 5649 ''' 5650 deadline = None if timeout is None else time.time() + timeout 5651 req = RemoteIdentityCreateRequest() 5652 5653 if remote_identity is not None: 5654 req.remote_identity.CopyFrom( 5655 plumbing.convert_remote_identity_to_plumbing(remote_identity)) 5656 tries = 0 5657 plumbing_response = None 5658 while True: 5659 t = None if deadline is None else deadline - time.time() 5660 try: 5661 plumbing_response = self.stub.Create( 5662 req, 5663 metadata=self.parent.get_metadata( 5664 'RemoteIdentities.Create', req), 5665 timeout=t) 5666 except Exception as e: 5667 if self.parent.shouldRetry(tries, e, deadline): 5668 tries += 1 5669 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5670 continue 5671 raise plumbing.convert_error_to_porcelain(e) from e 5672 break 5673 5674 resp = models.RemoteIdentityCreateResponse() 5675 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 5676 plumbing_response.meta) 5677 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5678 plumbing_response.rate_limit) 5679 resp.remote_identity = plumbing.convert_remote_identity_to_porcelain( 5680 plumbing_response.remote_identity) 5681 return resp
Create registers a new RemoteIdentity.
def
get(self, id, timeout=None)
5683 def get(self, id, timeout=None): 5684 ''' 5685 Get reads one RemoteIdentity by ID. 5686 ''' 5687 deadline = None if timeout is None else time.time() + timeout 5688 req = RemoteIdentityGetRequest() 5689 if self.parent.snapshot_datetime is not None: 5690 req.meta.CopyFrom(GetRequestMetadata()) 5691 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5692 5693 req.id = (id) 5694 tries = 0 5695 plumbing_response = None 5696 while True: 5697 t = None if deadline is None else deadline - time.time() 5698 try: 5699 plumbing_response = self.stub.Get( 5700 req, 5701 metadata=self.parent.get_metadata('RemoteIdentities.Get', 5702 req), 5703 timeout=t) 5704 except Exception as e: 5705 if self.parent.shouldRetry(tries, e, deadline): 5706 tries += 1 5707 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5708 continue 5709 raise plumbing.convert_error_to_porcelain(e) from e 5710 break 5711 5712 resp = models.RemoteIdentityGetResponse() 5713 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5714 plumbing_response.meta) 5715 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5716 plumbing_response.rate_limit) 5717 resp.remote_identity = plumbing.convert_remote_identity_to_porcelain( 5718 plumbing_response.remote_identity) 5719 return resp
Get reads one RemoteIdentity by ID.
def
update(self, remote_identity, timeout=None)
5721 def update(self, remote_identity, timeout=None): 5722 ''' 5723 Update replaces all the fields of a RemoteIdentity by ID. 5724 ''' 5725 deadline = None if timeout is None else time.time() + timeout 5726 req = RemoteIdentityUpdateRequest() 5727 5728 if remote_identity is not None: 5729 req.remote_identity.CopyFrom( 5730 plumbing.convert_remote_identity_to_plumbing(remote_identity)) 5731 tries = 0 5732 plumbing_response = None 5733 while True: 5734 t = None if deadline is None else deadline - time.time() 5735 try: 5736 plumbing_response = self.stub.Update( 5737 req, 5738 metadata=self.parent.get_metadata( 5739 'RemoteIdentities.Update', req), 5740 timeout=t) 5741 except Exception as e: 5742 if self.parent.shouldRetry(tries, e, deadline): 5743 tries += 1 5744 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5745 continue 5746 raise plumbing.convert_error_to_porcelain(e) from e 5747 break 5748 5749 resp = models.RemoteIdentityUpdateResponse() 5750 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 5751 plumbing_response.meta) 5752 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5753 plumbing_response.rate_limit) 5754 resp.remote_identity = plumbing.convert_remote_identity_to_porcelain( 5755 plumbing_response.remote_identity) 5756 return resp
Update replaces all the fields of a RemoteIdentity by ID.
def
delete(self, id, timeout=None)
5758 def delete(self, id, timeout=None): 5759 ''' 5760 Delete removes a RemoteIdentity by ID. 5761 ''' 5762 deadline = None if timeout is None else time.time() + timeout 5763 req = RemoteIdentityDeleteRequest() 5764 5765 req.id = (id) 5766 tries = 0 5767 plumbing_response = None 5768 while True: 5769 t = None if deadline is None else deadline - time.time() 5770 try: 5771 plumbing_response = self.stub.Delete( 5772 req, 5773 metadata=self.parent.get_metadata( 5774 'RemoteIdentities.Delete', req), 5775 timeout=t) 5776 except Exception as e: 5777 if self.parent.shouldRetry(tries, e, deadline): 5778 tries += 1 5779 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5780 continue 5781 raise plumbing.convert_error_to_porcelain(e) from e 5782 break 5783 5784 resp = models.RemoteIdentityDeleteResponse() 5785 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 5786 plumbing_response.meta) 5787 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5788 plumbing_response.rate_limit) 5789 return resp
Delete removes a RemoteIdentity by ID.
def
list(self, filter, *args, timeout=None)
5791 def list(self, filter, *args, timeout=None): 5792 ''' 5793 List gets a list of RemoteIdentities matching a given set of criteria. 5794 ''' 5795 deadline = None if timeout is None else time.time() + timeout 5796 req = RemoteIdentityListRequest() 5797 req.meta.CopyFrom(ListRequestMetadata()) 5798 if self.parent.page_limit > 0: 5799 req.meta.limit = self.parent.page_limit 5800 if self.parent.snapshot_datetime is not None: 5801 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5802 5803 req.filter = plumbing.quote_filter_args(filter, *args) 5804 5805 def generator(svc, req): 5806 tries = 0 5807 while True: 5808 t = None if deadline is None else deadline - time.time() 5809 try: 5810 plumbing_response = svc.stub.List( 5811 req, 5812 metadata=svc.parent.get_metadata( 5813 'RemoteIdentities.List', req), 5814 timeout=t) 5815 except Exception as e: 5816 if self.parent.shouldRetry(tries, e, deadline): 5817 tries += 1 5818 time.sleep( 5819 self.parent.exponentialBackoff(tries, deadline)) 5820 continue 5821 raise plumbing.convert_error_to_porcelain(e) from e 5822 tries = 0 5823 for plumbing_item in plumbing_response.remote_identities: 5824 yield plumbing.convert_remote_identity_to_porcelain( 5825 plumbing_item) 5826 if plumbing_response.meta.next_cursor == '': 5827 break 5828 req.meta.cursor = plumbing_response.meta.next_cursor 5829 5830 return generator(self, req)
List gets a list of RemoteIdentities matching a given set of criteria.
class
SnapshotRemoteIdentities:
5833class SnapshotRemoteIdentities: 5834 ''' 5835 SnapshotRemoteIdentities exposes the read only methods of the RemoteIdentities 5836 service for historical queries. 5837 ''' 5838 def __init__(self, remote_identities): 5839 self.remote_identities = remote_identities 5840 5841 def get(self, id, timeout=None): 5842 ''' 5843 Get reads one RemoteIdentity by ID. 5844 ''' 5845 return self.remote_identities.get(id, timeout=timeout) 5846 5847 def list(self, filter, *args, timeout=None): 5848 ''' 5849 List gets a list of RemoteIdentities matching a given set of criteria. 5850 ''' 5851 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)
5841 def get(self, id, timeout=None): 5842 ''' 5843 Get reads one RemoteIdentity by ID. 5844 ''' 5845 return self.remote_identities.get(id, timeout=timeout)
Get reads one RemoteIdentity by ID.
def
list(self, filter, *args, timeout=None)
5847 def list(self, filter, *args, timeout=None): 5848 ''' 5849 List gets a list of RemoteIdentities matching a given set of criteria. 5850 ''' 5851 return self.remote_identities.list(filter, *args, timeout=timeout)
List gets a list of RemoteIdentities matching a given set of criteria.
class
RemoteIdentitiesHistory:
5854class RemoteIdentitiesHistory: 5855 ''' 5856 RemoteIdentitiesHistory records all changes to the state of a RemoteIdentity. 5857 See `strongdm.models.RemoteIdentityHistory`. 5858 ''' 5859 def __init__(self, channel, client): 5860 self.parent = client 5861 self.stub = RemoteIdentitiesHistoryStub(channel) 5862 5863 def list(self, filter, *args, timeout=None): 5864 ''' 5865 List gets a list of RemoteIdentityHistory records matching a given set of criteria. 5866 ''' 5867 deadline = None if timeout is None else time.time() + timeout 5868 req = RemoteIdentityHistoryListRequest() 5869 req.meta.CopyFrom(ListRequestMetadata()) 5870 if self.parent.page_limit > 0: 5871 req.meta.limit = self.parent.page_limit 5872 if self.parent.snapshot_datetime is not None: 5873 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5874 5875 req.filter = plumbing.quote_filter_args(filter, *args) 5876 5877 def generator(svc, req): 5878 tries = 0 5879 while True: 5880 t = None if deadline is None else deadline - time.time() 5881 try: 5882 plumbing_response = svc.stub.List( 5883 req, 5884 metadata=svc.parent.get_metadata( 5885 'RemoteIdentitiesHistory.List', req), 5886 timeout=t) 5887 except Exception as e: 5888 if self.parent.shouldRetry(tries, e, deadline): 5889 tries += 1 5890 time.sleep( 5891 self.parent.exponentialBackoff(tries, deadline)) 5892 continue 5893 raise plumbing.convert_error_to_porcelain(e) from e 5894 tries = 0 5895 for plumbing_item in plumbing_response.history: 5896 yield plumbing.convert_remote_identity_history_to_porcelain( 5897 plumbing_item) 5898 if plumbing_response.meta.next_cursor == '': 5899 break 5900 req.meta.cursor = plumbing_response.meta.next_cursor 5901 5902 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)
5863 def list(self, filter, *args, timeout=None): 5864 ''' 5865 List gets a list of RemoteIdentityHistory records matching a given set of criteria. 5866 ''' 5867 deadline = None if timeout is None else time.time() + timeout 5868 req = RemoteIdentityHistoryListRequest() 5869 req.meta.CopyFrom(ListRequestMetadata()) 5870 if self.parent.page_limit > 0: 5871 req.meta.limit = self.parent.page_limit 5872 if self.parent.snapshot_datetime is not None: 5873 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5874 5875 req.filter = plumbing.quote_filter_args(filter, *args) 5876 5877 def generator(svc, req): 5878 tries = 0 5879 while True: 5880 t = None if deadline is None else deadline - time.time() 5881 try: 5882 plumbing_response = svc.stub.List( 5883 req, 5884 metadata=svc.parent.get_metadata( 5885 'RemoteIdentitiesHistory.List', req), 5886 timeout=t) 5887 except Exception as e: 5888 if self.parent.shouldRetry(tries, e, deadline): 5889 tries += 1 5890 time.sleep( 5891 self.parent.exponentialBackoff(tries, deadline)) 5892 continue 5893 raise plumbing.convert_error_to_porcelain(e) from e 5894 tries = 0 5895 for plumbing_item in plumbing_response.history: 5896 yield plumbing.convert_remote_identity_history_to_porcelain( 5897 plumbing_item) 5898 if plumbing_response.meta.next_cursor == '': 5899 break 5900 req.meta.cursor = plumbing_response.meta.next_cursor 5901 5902 return generator(self, req)
List gets a list of RemoteIdentityHistory records matching a given set of criteria.
class
RemoteIdentityGroups:
5905class RemoteIdentityGroups: 5906 ''' 5907 A RemoteIdentityGroup is a named grouping of Remote Identities for Accounts. 5908 An Account's relationship to a RemoteIdentityGroup is defined via RemoteIdentity objects. 5909 See `strongdm.models.RemoteIdentityGroup`. 5910 ''' 5911 def __init__(self, channel, client): 5912 self.parent = client 5913 self.stub = RemoteIdentityGroupsStub(channel) 5914 5915 def get(self, id, timeout=None): 5916 ''' 5917 Get reads one RemoteIdentityGroup by ID. 5918 ''' 5919 deadline = None if timeout is None else time.time() + timeout 5920 req = RemoteIdentityGroupGetRequest() 5921 if self.parent.snapshot_datetime is not None: 5922 req.meta.CopyFrom(GetRequestMetadata()) 5923 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5924 5925 req.id = (id) 5926 tries = 0 5927 plumbing_response = None 5928 while True: 5929 t = None if deadline is None else deadline - time.time() 5930 try: 5931 plumbing_response = self.stub.Get( 5932 req, 5933 metadata=self.parent.get_metadata( 5934 'RemoteIdentityGroups.Get', req), 5935 timeout=t) 5936 except Exception as e: 5937 if self.parent.shouldRetry(tries, e, deadline): 5938 tries += 1 5939 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5940 continue 5941 raise plumbing.convert_error_to_porcelain(e) from e 5942 break 5943 5944 resp = models.RemoteIdentityGroupGetResponse() 5945 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5946 plumbing_response.meta) 5947 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5948 plumbing_response.rate_limit) 5949 resp.remote_identity_group = plumbing.convert_remote_identity_group_to_porcelain( 5950 plumbing_response.remote_identity_group) 5951 return resp 5952 5953 def list(self, filter, *args, timeout=None): 5954 ''' 5955 List gets a list of RemoteIdentityGroups matching a given set of criteria. 5956 ''' 5957 deadline = None if timeout is None else time.time() + timeout 5958 req = RemoteIdentityGroupListRequest() 5959 req.meta.CopyFrom(ListRequestMetadata()) 5960 if self.parent.page_limit > 0: 5961 req.meta.limit = self.parent.page_limit 5962 if self.parent.snapshot_datetime is not None: 5963 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5964 5965 req.filter = plumbing.quote_filter_args(filter, *args) 5966 5967 def generator(svc, req): 5968 tries = 0 5969 while True: 5970 t = None if deadline is None else deadline - time.time() 5971 try: 5972 plumbing_response = svc.stub.List( 5973 req, 5974 metadata=svc.parent.get_metadata( 5975 'RemoteIdentityGroups.List', req), 5976 timeout=t) 5977 except Exception as e: 5978 if self.parent.shouldRetry(tries, e, deadline): 5979 tries += 1 5980 time.sleep( 5981 self.parent.exponentialBackoff(tries, deadline)) 5982 continue 5983 raise plumbing.convert_error_to_porcelain(e) from e 5984 tries = 0 5985 for plumbing_item in plumbing_response.remote_identity_groups: 5986 yield plumbing.convert_remote_identity_group_to_porcelain( 5987 plumbing_item) 5988 if plumbing_response.meta.next_cursor == '': 5989 break 5990 req.meta.cursor = plumbing_response.meta.next_cursor 5991 5992 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)
5915 def get(self, id, timeout=None): 5916 ''' 5917 Get reads one RemoteIdentityGroup by ID. 5918 ''' 5919 deadline = None if timeout is None else time.time() + timeout 5920 req = RemoteIdentityGroupGetRequest() 5921 if self.parent.snapshot_datetime is not None: 5922 req.meta.CopyFrom(GetRequestMetadata()) 5923 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5924 5925 req.id = (id) 5926 tries = 0 5927 plumbing_response = None 5928 while True: 5929 t = None if deadline is None else deadline - time.time() 5930 try: 5931 plumbing_response = self.stub.Get( 5932 req, 5933 metadata=self.parent.get_metadata( 5934 'RemoteIdentityGroups.Get', req), 5935 timeout=t) 5936 except Exception as e: 5937 if self.parent.shouldRetry(tries, e, deadline): 5938 tries += 1 5939 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 5940 continue 5941 raise plumbing.convert_error_to_porcelain(e) from e 5942 break 5943 5944 resp = models.RemoteIdentityGroupGetResponse() 5945 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 5946 plumbing_response.meta) 5947 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 5948 plumbing_response.rate_limit) 5949 resp.remote_identity_group = plumbing.convert_remote_identity_group_to_porcelain( 5950 plumbing_response.remote_identity_group) 5951 return resp
Get reads one RemoteIdentityGroup by ID.
def
list(self, filter, *args, timeout=None)
5953 def list(self, filter, *args, timeout=None): 5954 ''' 5955 List gets a list of RemoteIdentityGroups matching a given set of criteria. 5956 ''' 5957 deadline = None if timeout is None else time.time() + timeout 5958 req = RemoteIdentityGroupListRequest() 5959 req.meta.CopyFrom(ListRequestMetadata()) 5960 if self.parent.page_limit > 0: 5961 req.meta.limit = self.parent.page_limit 5962 if self.parent.snapshot_datetime is not None: 5963 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 5964 5965 req.filter = plumbing.quote_filter_args(filter, *args) 5966 5967 def generator(svc, req): 5968 tries = 0 5969 while True: 5970 t = None if deadline is None else deadline - time.time() 5971 try: 5972 plumbing_response = svc.stub.List( 5973 req, 5974 metadata=svc.parent.get_metadata( 5975 'RemoteIdentityGroups.List', req), 5976 timeout=t) 5977 except Exception as e: 5978 if self.parent.shouldRetry(tries, e, deadline): 5979 tries += 1 5980 time.sleep( 5981 self.parent.exponentialBackoff(tries, deadline)) 5982 continue 5983 raise plumbing.convert_error_to_porcelain(e) from e 5984 tries = 0 5985 for plumbing_item in plumbing_response.remote_identity_groups: 5986 yield plumbing.convert_remote_identity_group_to_porcelain( 5987 plumbing_item) 5988 if plumbing_response.meta.next_cursor == '': 5989 break 5990 req.meta.cursor = plumbing_response.meta.next_cursor 5991 5992 return generator(self, req)
List gets a list of RemoteIdentityGroups matching a given set of criteria.
class
SnapshotRemoteIdentityGroups:
5995class SnapshotRemoteIdentityGroups: 5996 ''' 5997 SnapshotRemoteIdentityGroups exposes the read only methods of the RemoteIdentityGroups 5998 service for historical queries. 5999 ''' 6000 def __init__(self, remote_identity_groups): 6001 self.remote_identity_groups = remote_identity_groups 6002 6003 def get(self, id, timeout=None): 6004 ''' 6005 Get reads one RemoteIdentityGroup by ID. 6006 ''' 6007 return self.remote_identity_groups.get(id, timeout=timeout) 6008 6009 def list(self, filter, *args, timeout=None): 6010 ''' 6011 List gets a list of RemoteIdentityGroups matching a given set of criteria. 6012 ''' 6013 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)
6003 def get(self, id, timeout=None): 6004 ''' 6005 Get reads one RemoteIdentityGroup by ID. 6006 ''' 6007 return self.remote_identity_groups.get(id, timeout=timeout)
Get reads one RemoteIdentityGroup by ID.
def
list(self, filter, *args, timeout=None)
6009 def list(self, filter, *args, timeout=None): 6010 ''' 6011 List gets a list of RemoteIdentityGroups matching a given set of criteria. 6012 ''' 6013 return self.remote_identity_groups.list(filter, *args, timeout=timeout)
List gets a list of RemoteIdentityGroups matching a given set of criteria.
class
RemoteIdentityGroupsHistory:
6016class RemoteIdentityGroupsHistory: 6017 ''' 6018 RemoteIdentityGroupsHistory records all changes to the state of a RemoteIdentityGroup. 6019 See `strongdm.models.RemoteIdentityGroupHistory`. 6020 ''' 6021 def __init__(self, channel, client): 6022 self.parent = client 6023 self.stub = RemoteIdentityGroupsHistoryStub(channel) 6024 6025 def list(self, filter, *args, timeout=None): 6026 ''' 6027 List gets a list of RemoteIdentityGroupHistory records matching a given set of criteria. 6028 ''' 6029 deadline = None if timeout is None else time.time() + timeout 6030 req = RemoteIdentityGroupHistoryListRequest() 6031 req.meta.CopyFrom(ListRequestMetadata()) 6032 if self.parent.page_limit > 0: 6033 req.meta.limit = self.parent.page_limit 6034 if self.parent.snapshot_datetime is not None: 6035 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6036 6037 req.filter = plumbing.quote_filter_args(filter, *args) 6038 6039 def generator(svc, req): 6040 tries = 0 6041 while True: 6042 t = None if deadline is None else deadline - time.time() 6043 try: 6044 plumbing_response = svc.stub.List( 6045 req, 6046 metadata=svc.parent.get_metadata( 6047 'RemoteIdentityGroupsHistory.List', req), 6048 timeout=t) 6049 except Exception as e: 6050 if self.parent.shouldRetry(tries, e, deadline): 6051 tries += 1 6052 time.sleep( 6053 self.parent.exponentialBackoff(tries, deadline)) 6054 continue 6055 raise plumbing.convert_error_to_porcelain(e) from e 6056 tries = 0 6057 for plumbing_item in plumbing_response.history: 6058 yield plumbing.convert_remote_identity_group_history_to_porcelain( 6059 plumbing_item) 6060 if plumbing_response.meta.next_cursor == '': 6061 break 6062 req.meta.cursor = plumbing_response.meta.next_cursor 6063 6064 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)
6025 def list(self, filter, *args, timeout=None): 6026 ''' 6027 List gets a list of RemoteIdentityGroupHistory records matching a given set of criteria. 6028 ''' 6029 deadline = None if timeout is None else time.time() + timeout 6030 req = RemoteIdentityGroupHistoryListRequest() 6031 req.meta.CopyFrom(ListRequestMetadata()) 6032 if self.parent.page_limit > 0: 6033 req.meta.limit = self.parent.page_limit 6034 if self.parent.snapshot_datetime is not None: 6035 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6036 6037 req.filter = plumbing.quote_filter_args(filter, *args) 6038 6039 def generator(svc, req): 6040 tries = 0 6041 while True: 6042 t = None if deadline is None else deadline - time.time() 6043 try: 6044 plumbing_response = svc.stub.List( 6045 req, 6046 metadata=svc.parent.get_metadata( 6047 'RemoteIdentityGroupsHistory.List', req), 6048 timeout=t) 6049 except Exception as e: 6050 if self.parent.shouldRetry(tries, e, deadline): 6051 tries += 1 6052 time.sleep( 6053 self.parent.exponentialBackoff(tries, deadline)) 6054 continue 6055 raise plumbing.convert_error_to_porcelain(e) from e 6056 tries = 0 6057 for plumbing_item in plumbing_response.history: 6058 yield plumbing.convert_remote_identity_group_history_to_porcelain( 6059 plumbing_item) 6060 if plumbing_response.meta.next_cursor == '': 6061 break 6062 req.meta.cursor = plumbing_response.meta.next_cursor 6063 6064 return generator(self, req)
List gets a list of RemoteIdentityGroupHistory records matching a given set of criteria.
class
Replays:
6067class Replays: 6068 ''' 6069 A Replay captures the data transferred over a long-running SSH, RDP, or Kubernetes interactive session 6070 (otherwise referred to as a query). The Replays service is read-only. 6071 See `strongdm.models.ReplayChunk`. 6072 ''' 6073 def __init__(self, channel, client): 6074 self.parent = client 6075 self.stub = ReplaysStub(channel) 6076 6077 def list(self, filter, *args, timeout=None): 6078 ''' 6079 List gets a list of ReplayChunks for the Query ID specified by the filter criteria. 6080 ''' 6081 deadline = None if timeout is None else time.time() + timeout 6082 req = ReplayListRequest() 6083 req.meta.CopyFrom(ListRequestMetadata()) 6084 if self.parent.page_limit > 0: 6085 req.meta.limit = self.parent.page_limit 6086 if self.parent.snapshot_datetime is not None: 6087 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6088 6089 req.filter = plumbing.quote_filter_args(filter, *args) 6090 6091 def generator(svc, req): 6092 tries = 0 6093 while True: 6094 t = None if deadline is None else deadline - time.time() 6095 try: 6096 plumbing_response = svc.stub.List( 6097 req, 6098 metadata=svc.parent.get_metadata('Replays.List', req), 6099 timeout=t) 6100 except Exception as e: 6101 if self.parent.shouldRetry(tries, e, deadline): 6102 tries += 1 6103 time.sleep( 6104 self.parent.exponentialBackoff(tries, deadline)) 6105 continue 6106 raise plumbing.convert_error_to_porcelain(e) from e 6107 tries = 0 6108 for plumbing_item in plumbing_response.chunks: 6109 yield plumbing.convert_replay_chunk_to_porcelain( 6110 plumbing_item) 6111 if plumbing_response.meta.next_cursor == '': 6112 break 6113 req.meta.cursor = plumbing_response.meta.next_cursor 6114 6115 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)
6077 def list(self, filter, *args, timeout=None): 6078 ''' 6079 List gets a list of ReplayChunks for the Query ID specified by the filter criteria. 6080 ''' 6081 deadline = None if timeout is None else time.time() + timeout 6082 req = ReplayListRequest() 6083 req.meta.CopyFrom(ListRequestMetadata()) 6084 if self.parent.page_limit > 0: 6085 req.meta.limit = self.parent.page_limit 6086 if self.parent.snapshot_datetime is not None: 6087 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6088 6089 req.filter = plumbing.quote_filter_args(filter, *args) 6090 6091 def generator(svc, req): 6092 tries = 0 6093 while True: 6094 t = None if deadline is None else deadline - time.time() 6095 try: 6096 plumbing_response = svc.stub.List( 6097 req, 6098 metadata=svc.parent.get_metadata('Replays.List', req), 6099 timeout=t) 6100 except Exception as e: 6101 if self.parent.shouldRetry(tries, e, deadline): 6102 tries += 1 6103 time.sleep( 6104 self.parent.exponentialBackoff(tries, deadline)) 6105 continue 6106 raise plumbing.convert_error_to_porcelain(e) from e 6107 tries = 0 6108 for plumbing_item in plumbing_response.chunks: 6109 yield plumbing.convert_replay_chunk_to_porcelain( 6110 plumbing_item) 6111 if plumbing_response.meta.next_cursor == '': 6112 break 6113 req.meta.cursor = plumbing_response.meta.next_cursor 6114 6115 return generator(self, req)
List gets a list of ReplayChunks for the Query ID specified by the filter criteria.
class
Resources:
6118class Resources: 6119 ''' 6120 Resources are databases, servers, clusters, websites, or clouds that strongDM 6121 delegates access to. 6122 See: 6123 `strongdm.models.Aerospike` 6124 `strongdm.models.AKS` 6125 `strongdm.models.AKSBasicAuth` 6126 `strongdm.models.AKSServiceAccount` 6127 `strongdm.models.AKSServiceAccountUserImpersonation` 6128 `strongdm.models.AKSUserImpersonation` 6129 `strongdm.models.AmazonEKS` 6130 `strongdm.models.AmazonEKSInstanceProfile` 6131 `strongdm.models.AmazonEKSInstanceProfileUserImpersonation` 6132 `strongdm.models.AmazonEKSUserImpersonation` 6133 `strongdm.models.AmazonES` 6134 `strongdm.models.AmazonESIAM` 6135 `strongdm.models.AmazonMQAMQP091` 6136 `strongdm.models.AMQP` 6137 `strongdm.models.Athena` 6138 `strongdm.models.AthenaIAM` 6139 `strongdm.models.AuroraMysql` 6140 `strongdm.models.AuroraMysqlIAM` 6141 `strongdm.models.AuroraPostgres` 6142 `strongdm.models.AuroraPostgresIAM` 6143 `strongdm.models.AWS` 6144 `strongdm.models.AWSConsole` 6145 `strongdm.models.AWSConsoleStaticKeyPair` 6146 `strongdm.models.AWSInstanceProfile` 6147 `strongdm.models.Azure` 6148 `strongdm.models.AzureCertificate` 6149 `strongdm.models.AzureMysql` 6150 `strongdm.models.AzureMysqlManagedIdentity` 6151 `strongdm.models.AzurePostgres` 6152 `strongdm.models.AzurePostgresManagedIdentity` 6153 `strongdm.models.BigQuery` 6154 `strongdm.models.Cassandra` 6155 `strongdm.models.Citus` 6156 `strongdm.models.ClickHouseHTTP` 6157 `strongdm.models.ClickHouseMySQL` 6158 `strongdm.models.ClickHouseTCP` 6159 `strongdm.models.Clustrix` 6160 `strongdm.models.Cockroach` 6161 `strongdm.models.CouchbaseDatabase` 6162 `strongdm.models.CouchbaseWebUI` 6163 `strongdm.models.DB2I` 6164 `strongdm.models.DB2LUW` 6165 `strongdm.models.DocumentDBHost` 6166 `strongdm.models.DocumentDBHostIAM` 6167 `strongdm.models.DocumentDBReplicaSet` 6168 `strongdm.models.DocumentDBReplicaSetIAM` 6169 `strongdm.models.Druid` 6170 `strongdm.models.DynamoDB` 6171 `strongdm.models.DynamoDBIAM` 6172 `strongdm.models.Elastic` 6173 `strongdm.models.ElasticacheRedis` 6174 `strongdm.models.ElasticacheRedisIAM` 6175 `strongdm.models.EntraID` 6176 `strongdm.models.GCP` 6177 `strongdm.models.GCPConsole` 6178 `strongdm.models.GCPWIF` 6179 `strongdm.models.GoogleGKE` 6180 `strongdm.models.GoogleGKEUserImpersonation` 6181 `strongdm.models.Greenplum` 6182 `strongdm.models.HTTPAuth` 6183 `strongdm.models.HTTPBasicAuth` 6184 `strongdm.models.HTTPNoAuth` 6185 `strongdm.models.Kubernetes` 6186 `strongdm.models.KubernetesBasicAuth` 6187 `strongdm.models.KubernetesPodIdentity` 6188 `strongdm.models.KubernetesServiceAccount` 6189 `strongdm.models.KubernetesServiceAccountUserImpersonation` 6190 `strongdm.models.KubernetesUserImpersonation` 6191 `strongdm.models.Maria` 6192 `strongdm.models.MCP` 6193 `strongdm.models.Memcached` 6194 `strongdm.models.Memsql` 6195 `strongdm.models.MongoHost` 6196 `strongdm.models.MongoLegacyHost` 6197 `strongdm.models.MongoLegacyReplicaset` 6198 `strongdm.models.MongoReplicaSet` 6199 `strongdm.models.MongoShardedCluster` 6200 `strongdm.models.MTLSMysql` 6201 `strongdm.models.MTLSPostgres` 6202 `strongdm.models.Mysql` 6203 `strongdm.models.Neptune` 6204 `strongdm.models.NeptuneIAM` 6205 `strongdm.models.Oracle` 6206 `strongdm.models.OracleNNE` 6207 `strongdm.models.Postgres` 6208 `strongdm.models.Presto` 6209 `strongdm.models.RabbitMQAMQP091` 6210 `strongdm.models.RawTCP` 6211 `strongdm.models.RDP` 6212 `strongdm.models.RDPCert` 6213 `strongdm.models.RDSPostgresIAM` 6214 `strongdm.models.Redis` 6215 `strongdm.models.RedisCluster` 6216 `strongdm.models.Redshift` 6217 `strongdm.models.RedshiftIAM` 6218 `strongdm.models.RedshiftServerlessIAM` 6219 `strongdm.models.SingleStore` 6220 `strongdm.models.Snowflake` 6221 `strongdm.models.Snowsight` 6222 `strongdm.models.SQLServer` 6223 `strongdm.models.SQLServerAzureAD` 6224 `strongdm.models.SQLServerKerberosAD` 6225 `strongdm.models.SSH` 6226 `strongdm.models.SSHCert` 6227 `strongdm.models.SSHCustomerKey` 6228 `strongdm.models.SSHPassword` 6229 `strongdm.models.Sybase` 6230 `strongdm.models.SybaseIQ` 6231 `strongdm.models.Teradata` 6232 `strongdm.models.Trino` 6233 `strongdm.models.Vertica` 6234 ''' 6235 def __init__(self, channel, client): 6236 self.parent = client 6237 self.stub = ResourcesStub(channel) 6238 6239 def enumerate_tags(self, filter, *args, timeout=None): 6240 ''' 6241 EnumerateTags gets a list of the filter matching tags. 6242 ''' 6243 deadline = None if timeout is None else time.time() + timeout 6244 req = EnumerateTagsRequest() 6245 req.meta.CopyFrom(ListRequestMetadata()) 6246 if self.parent.page_limit > 0: 6247 req.meta.limit = self.parent.page_limit 6248 if self.parent.snapshot_datetime is not None: 6249 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6250 6251 req.filter = plumbing.quote_filter_args(filter, *args) 6252 6253 def generator(svc, req): 6254 tries = 0 6255 while True: 6256 t = None if deadline is None else deadline - time.time() 6257 try: 6258 plumbing_response = svc.stub.EnumerateTags( 6259 req, 6260 metadata=svc.parent.get_metadata( 6261 'Resources.EnumerateTags', req), 6262 timeout=t) 6263 except Exception as e: 6264 if self.parent.shouldRetry(tries, e, deadline): 6265 tries += 1 6266 time.sleep( 6267 self.parent.exponentialBackoff(tries, deadline)) 6268 continue 6269 raise plumbing.convert_error_to_porcelain(e) from e 6270 tries = 0 6271 for plumbing_item in plumbing_response.matches: 6272 yield plumbing.convert_tag_to_porcelain(plumbing_item) 6273 if plumbing_response.meta.next_cursor == '': 6274 break 6275 req.meta.cursor = plumbing_response.meta.next_cursor 6276 6277 return generator(self, req) 6278 6279 def create(self, resource, timeout=None): 6280 ''' 6281 Create registers a new Resource. 6282 ''' 6283 deadline = None if timeout is None else time.time() + timeout 6284 req = ResourceCreateRequest() 6285 6286 if resource is not None: 6287 req.resource.CopyFrom( 6288 plumbing.convert_resource_to_plumbing(resource)) 6289 tries = 0 6290 plumbing_response = None 6291 while True: 6292 t = None if deadline is None else deadline - time.time() 6293 try: 6294 plumbing_response = self.stub.Create( 6295 req, 6296 metadata=self.parent.get_metadata('Resources.Create', req), 6297 timeout=t) 6298 except Exception as e: 6299 if self.parent.shouldRetry(tries, e, deadline): 6300 tries += 1 6301 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6302 continue 6303 raise plumbing.convert_error_to_porcelain(e) from e 6304 break 6305 6306 resp = models.ResourceCreateResponse() 6307 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 6308 plumbing_response.meta) 6309 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6310 plumbing_response.rate_limit) 6311 resp.resource = plumbing.convert_resource_to_porcelain( 6312 plumbing_response.resource) 6313 return resp 6314 6315 def get(self, id, timeout=None): 6316 ''' 6317 Get reads one Resource by ID. 6318 ''' 6319 deadline = None if timeout is None else time.time() + timeout 6320 req = ResourceGetRequest() 6321 if self.parent.snapshot_datetime is not None: 6322 req.meta.CopyFrom(GetRequestMetadata()) 6323 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6324 6325 req.id = (id) 6326 tries = 0 6327 plumbing_response = None 6328 while True: 6329 t = None if deadline is None else deadline - time.time() 6330 try: 6331 plumbing_response = self.stub.Get( 6332 req, 6333 metadata=self.parent.get_metadata('Resources.Get', req), 6334 timeout=t) 6335 except Exception as e: 6336 if self.parent.shouldRetry(tries, e, deadline): 6337 tries += 1 6338 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6339 continue 6340 raise plumbing.convert_error_to_porcelain(e) from e 6341 break 6342 6343 resp = models.ResourceGetResponse() 6344 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 6345 plumbing_response.meta) 6346 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6347 plumbing_response.rate_limit) 6348 resp.resource = plumbing.convert_resource_to_porcelain( 6349 plumbing_response.resource) 6350 return resp 6351 6352 def update(self, resource, timeout=None): 6353 ''' 6354 Update replaces all the fields of a Resource by ID. 6355 ''' 6356 deadline = None if timeout is None else time.time() + timeout 6357 req = ResourceUpdateRequest() 6358 6359 if resource is not None: 6360 req.resource.CopyFrom( 6361 plumbing.convert_resource_to_plumbing(resource)) 6362 tries = 0 6363 plumbing_response = None 6364 while True: 6365 t = None if deadline is None else deadline - time.time() 6366 try: 6367 plumbing_response = self.stub.Update( 6368 req, 6369 metadata=self.parent.get_metadata('Resources.Update', req), 6370 timeout=t) 6371 except Exception as e: 6372 if self.parent.shouldRetry(tries, e, deadline): 6373 tries += 1 6374 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6375 continue 6376 raise plumbing.convert_error_to_porcelain(e) from e 6377 break 6378 6379 resp = models.ResourceUpdateResponse() 6380 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 6381 plumbing_response.meta) 6382 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6383 plumbing_response.rate_limit) 6384 resp.resource = plumbing.convert_resource_to_porcelain( 6385 plumbing_response.resource) 6386 return resp 6387 6388 def delete(self, id, timeout=None): 6389 ''' 6390 Delete removes a Resource by ID. 6391 ''' 6392 deadline = None if timeout is None else time.time() + timeout 6393 req = ResourceDeleteRequest() 6394 6395 req.id = (id) 6396 tries = 0 6397 plumbing_response = None 6398 while True: 6399 t = None if deadline is None else deadline - time.time() 6400 try: 6401 plumbing_response = self.stub.Delete( 6402 req, 6403 metadata=self.parent.get_metadata('Resources.Delete', req), 6404 timeout=t) 6405 except Exception as e: 6406 if self.parent.shouldRetry(tries, e, deadline): 6407 tries += 1 6408 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6409 continue 6410 raise plumbing.convert_error_to_porcelain(e) from e 6411 break 6412 6413 resp = models.ResourceDeleteResponse() 6414 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 6415 plumbing_response.meta) 6416 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6417 plumbing_response.rate_limit) 6418 return resp 6419 6420 def list(self, filter, *args, timeout=None): 6421 ''' 6422 List gets a list of Resources matching a given set of criteria. 6423 ''' 6424 deadline = None if timeout is None else time.time() + timeout 6425 req = ResourceListRequest() 6426 req.meta.CopyFrom(ListRequestMetadata()) 6427 if self.parent.page_limit > 0: 6428 req.meta.limit = self.parent.page_limit 6429 if self.parent.snapshot_datetime is not None: 6430 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6431 6432 req.filter = plumbing.quote_filter_args(filter, *args) 6433 6434 def generator(svc, req): 6435 tries = 0 6436 while True: 6437 t = None if deadline is None else deadline - time.time() 6438 try: 6439 plumbing_response = svc.stub.List( 6440 req, 6441 metadata=svc.parent.get_metadata( 6442 'Resources.List', req), 6443 timeout=t) 6444 except Exception as e: 6445 if self.parent.shouldRetry(tries, e, deadline): 6446 tries += 1 6447 time.sleep( 6448 self.parent.exponentialBackoff(tries, deadline)) 6449 continue 6450 raise plumbing.convert_error_to_porcelain(e) from e 6451 tries = 0 6452 for plumbing_item in plumbing_response.resources: 6453 yield plumbing.convert_resource_to_porcelain(plumbing_item) 6454 if plumbing_response.meta.next_cursor == '': 6455 break 6456 req.meta.cursor = plumbing_response.meta.next_cursor 6457 6458 return generator(self, req) 6459 6460 def healthcheck(self, id, timeout=None): 6461 ''' 6462 Healthcheck triggers a remote healthcheck. It may take minutes to propagate across a 6463 large network of Nodes. The call will return immediately, and the updated health of the 6464 Resource can be retrieved via Get or List. 6465 ''' 6466 deadline = None if timeout is None else time.time() + timeout 6467 req = ResourceHealthcheckRequest() 6468 6469 req.id = (id) 6470 tries = 0 6471 plumbing_response = None 6472 while True: 6473 t = None if deadline is None else deadline - time.time() 6474 try: 6475 plumbing_response = self.stub.Healthcheck( 6476 req, 6477 metadata=self.parent.get_metadata('Resources.Healthcheck', 6478 req), 6479 timeout=t) 6480 except Exception as e: 6481 if self.parent.shouldRetry(tries, e, deadline): 6482 tries += 1 6483 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6484 continue 6485 raise plumbing.convert_error_to_porcelain(e) from e 6486 break 6487 6488 resp = models.ResourceHealthcheckResponse() 6489 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 6490 plumbing_response.meta) 6491 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6492 plumbing_response.rate_limit) 6493 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.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.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)
6279 def create(self, resource, timeout=None): 6280 ''' 6281 Create registers a new Resource. 6282 ''' 6283 deadline = None if timeout is None else time.time() + timeout 6284 req = ResourceCreateRequest() 6285 6286 if resource is not None: 6287 req.resource.CopyFrom( 6288 plumbing.convert_resource_to_plumbing(resource)) 6289 tries = 0 6290 plumbing_response = None 6291 while True: 6292 t = None if deadline is None else deadline - time.time() 6293 try: 6294 plumbing_response = self.stub.Create( 6295 req, 6296 metadata=self.parent.get_metadata('Resources.Create', req), 6297 timeout=t) 6298 except Exception as e: 6299 if self.parent.shouldRetry(tries, e, deadline): 6300 tries += 1 6301 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6302 continue 6303 raise plumbing.convert_error_to_porcelain(e) from e 6304 break 6305 6306 resp = models.ResourceCreateResponse() 6307 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 6308 plumbing_response.meta) 6309 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6310 plumbing_response.rate_limit) 6311 resp.resource = plumbing.convert_resource_to_porcelain( 6312 plumbing_response.resource) 6313 return resp
Create registers a new Resource.
def
get(self, id, timeout=None)
6315 def get(self, id, timeout=None): 6316 ''' 6317 Get reads one Resource by ID. 6318 ''' 6319 deadline = None if timeout is None else time.time() + timeout 6320 req = ResourceGetRequest() 6321 if self.parent.snapshot_datetime is not None: 6322 req.meta.CopyFrom(GetRequestMetadata()) 6323 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6324 6325 req.id = (id) 6326 tries = 0 6327 plumbing_response = None 6328 while True: 6329 t = None if deadline is None else deadline - time.time() 6330 try: 6331 plumbing_response = self.stub.Get( 6332 req, 6333 metadata=self.parent.get_metadata('Resources.Get', req), 6334 timeout=t) 6335 except Exception as e: 6336 if self.parent.shouldRetry(tries, e, deadline): 6337 tries += 1 6338 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6339 continue 6340 raise plumbing.convert_error_to_porcelain(e) from e 6341 break 6342 6343 resp = models.ResourceGetResponse() 6344 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 6345 plumbing_response.meta) 6346 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6347 plumbing_response.rate_limit) 6348 resp.resource = plumbing.convert_resource_to_porcelain( 6349 plumbing_response.resource) 6350 return resp
Get reads one Resource by ID.
def
update(self, resource, timeout=None)
6352 def update(self, resource, timeout=None): 6353 ''' 6354 Update replaces all the fields of a Resource by ID. 6355 ''' 6356 deadline = None if timeout is None else time.time() + timeout 6357 req = ResourceUpdateRequest() 6358 6359 if resource is not None: 6360 req.resource.CopyFrom( 6361 plumbing.convert_resource_to_plumbing(resource)) 6362 tries = 0 6363 plumbing_response = None 6364 while True: 6365 t = None if deadline is None else deadline - time.time() 6366 try: 6367 plumbing_response = self.stub.Update( 6368 req, 6369 metadata=self.parent.get_metadata('Resources.Update', req), 6370 timeout=t) 6371 except Exception as e: 6372 if self.parent.shouldRetry(tries, e, deadline): 6373 tries += 1 6374 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6375 continue 6376 raise plumbing.convert_error_to_porcelain(e) from e 6377 break 6378 6379 resp = models.ResourceUpdateResponse() 6380 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 6381 plumbing_response.meta) 6382 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6383 plumbing_response.rate_limit) 6384 resp.resource = plumbing.convert_resource_to_porcelain( 6385 plumbing_response.resource) 6386 return resp
Update replaces all the fields of a Resource by ID.
def
delete(self, id, timeout=None)
6388 def delete(self, id, timeout=None): 6389 ''' 6390 Delete removes a Resource by ID. 6391 ''' 6392 deadline = None if timeout is None else time.time() + timeout 6393 req = ResourceDeleteRequest() 6394 6395 req.id = (id) 6396 tries = 0 6397 plumbing_response = None 6398 while True: 6399 t = None if deadline is None else deadline - time.time() 6400 try: 6401 plumbing_response = self.stub.Delete( 6402 req, 6403 metadata=self.parent.get_metadata('Resources.Delete', req), 6404 timeout=t) 6405 except Exception as e: 6406 if self.parent.shouldRetry(tries, e, deadline): 6407 tries += 1 6408 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6409 continue 6410 raise plumbing.convert_error_to_porcelain(e) from e 6411 break 6412 6413 resp = models.ResourceDeleteResponse() 6414 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 6415 plumbing_response.meta) 6416 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6417 plumbing_response.rate_limit) 6418 return resp
Delete removes a Resource by ID.
def
list(self, filter, *args, timeout=None)
6420 def list(self, filter, *args, timeout=None): 6421 ''' 6422 List gets a list of Resources matching a given set of criteria. 6423 ''' 6424 deadline = None if timeout is None else time.time() + timeout 6425 req = ResourceListRequest() 6426 req.meta.CopyFrom(ListRequestMetadata()) 6427 if self.parent.page_limit > 0: 6428 req.meta.limit = self.parent.page_limit 6429 if self.parent.snapshot_datetime is not None: 6430 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6431 6432 req.filter = plumbing.quote_filter_args(filter, *args) 6433 6434 def generator(svc, req): 6435 tries = 0 6436 while True: 6437 t = None if deadline is None else deadline - time.time() 6438 try: 6439 plumbing_response = svc.stub.List( 6440 req, 6441 metadata=svc.parent.get_metadata( 6442 'Resources.List', req), 6443 timeout=t) 6444 except Exception as e: 6445 if self.parent.shouldRetry(tries, e, deadline): 6446 tries += 1 6447 time.sleep( 6448 self.parent.exponentialBackoff(tries, deadline)) 6449 continue 6450 raise plumbing.convert_error_to_porcelain(e) from e 6451 tries = 0 6452 for plumbing_item in plumbing_response.resources: 6453 yield plumbing.convert_resource_to_porcelain(plumbing_item) 6454 if plumbing_response.meta.next_cursor == '': 6455 break 6456 req.meta.cursor = plumbing_response.meta.next_cursor 6457 6458 return generator(self, req)
List gets a list of Resources matching a given set of criteria.
def
healthcheck(self, id, timeout=None)
6460 def healthcheck(self, id, timeout=None): 6461 ''' 6462 Healthcheck triggers a remote healthcheck. It may take minutes to propagate across a 6463 large network of Nodes. The call will return immediately, and the updated health of the 6464 Resource can be retrieved via Get or List. 6465 ''' 6466 deadline = None if timeout is None else time.time() + timeout 6467 req = ResourceHealthcheckRequest() 6468 6469 req.id = (id) 6470 tries = 0 6471 plumbing_response = None 6472 while True: 6473 t = None if deadline is None else deadline - time.time() 6474 try: 6475 plumbing_response = self.stub.Healthcheck( 6476 req, 6477 metadata=self.parent.get_metadata('Resources.Healthcheck', 6478 req), 6479 timeout=t) 6480 except Exception as e: 6481 if self.parent.shouldRetry(tries, e, deadline): 6482 tries += 1 6483 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6484 continue 6485 raise plumbing.convert_error_to_porcelain(e) from e 6486 break 6487 6488 resp = models.ResourceHealthcheckResponse() 6489 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 6490 plumbing_response.meta) 6491 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6492 plumbing_response.rate_limit) 6493 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:
6496class SnapshotResources: 6497 ''' 6498 SnapshotResources exposes the read only methods of the Resources 6499 service for historical queries. 6500 ''' 6501 def __init__(self, resources): 6502 self.resources = resources 6503 6504 def get(self, id, timeout=None): 6505 ''' 6506 Get reads one Resource by ID. 6507 ''' 6508 return self.resources.get(id, timeout=timeout) 6509 6510 def list(self, filter, *args, timeout=None): 6511 ''' 6512 List gets a list of Resources matching a given set of criteria. 6513 ''' 6514 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)
6504 def get(self, id, timeout=None): 6505 ''' 6506 Get reads one Resource by ID. 6507 ''' 6508 return self.resources.get(id, timeout=timeout)
Get reads one Resource by ID.
def
list(self, filter, *args, timeout=None)
6510 def list(self, filter, *args, timeout=None): 6511 ''' 6512 List gets a list of Resources matching a given set of criteria. 6513 ''' 6514 return self.resources.list(filter, *args, timeout=timeout)
List gets a list of Resources matching a given set of criteria.
class
ResourcesHistory:
6517class ResourcesHistory: 6518 ''' 6519 ResourcesHistory records all changes to the state of a Resource. 6520 See `strongdm.models.ResourceHistory`. 6521 ''' 6522 def __init__(self, channel, client): 6523 self.parent = client 6524 self.stub = ResourcesHistoryStub(channel) 6525 6526 def list(self, filter, *args, timeout=None): 6527 ''' 6528 List gets a list of ResourceHistory records matching a given set of criteria. 6529 ''' 6530 deadline = None if timeout is None else time.time() + timeout 6531 req = ResourceHistoryListRequest() 6532 req.meta.CopyFrom(ListRequestMetadata()) 6533 if self.parent.page_limit > 0: 6534 req.meta.limit = self.parent.page_limit 6535 if self.parent.snapshot_datetime is not None: 6536 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6537 6538 req.filter = plumbing.quote_filter_args(filter, *args) 6539 6540 def generator(svc, req): 6541 tries = 0 6542 while True: 6543 t = None if deadline is None else deadline - time.time() 6544 try: 6545 plumbing_response = svc.stub.List( 6546 req, 6547 metadata=svc.parent.get_metadata( 6548 'ResourcesHistory.List', req), 6549 timeout=t) 6550 except Exception as e: 6551 if self.parent.shouldRetry(tries, e, deadline): 6552 tries += 1 6553 time.sleep( 6554 self.parent.exponentialBackoff(tries, deadline)) 6555 continue 6556 raise plumbing.convert_error_to_porcelain(e) from e 6557 tries = 0 6558 for plumbing_item in plumbing_response.history: 6559 yield plumbing.convert_resource_history_to_porcelain( 6560 plumbing_item) 6561 if plumbing_response.meta.next_cursor == '': 6562 break 6563 req.meta.cursor = plumbing_response.meta.next_cursor 6564 6565 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)
6526 def list(self, filter, *args, timeout=None): 6527 ''' 6528 List gets a list of ResourceHistory records matching a given set of criteria. 6529 ''' 6530 deadline = None if timeout is None else time.time() + timeout 6531 req = ResourceHistoryListRequest() 6532 req.meta.CopyFrom(ListRequestMetadata()) 6533 if self.parent.page_limit > 0: 6534 req.meta.limit = self.parent.page_limit 6535 if self.parent.snapshot_datetime is not None: 6536 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6537 6538 req.filter = plumbing.quote_filter_args(filter, *args) 6539 6540 def generator(svc, req): 6541 tries = 0 6542 while True: 6543 t = None if deadline is None else deadline - time.time() 6544 try: 6545 plumbing_response = svc.stub.List( 6546 req, 6547 metadata=svc.parent.get_metadata( 6548 'ResourcesHistory.List', req), 6549 timeout=t) 6550 except Exception as e: 6551 if self.parent.shouldRetry(tries, e, deadline): 6552 tries += 1 6553 time.sleep( 6554 self.parent.exponentialBackoff(tries, deadline)) 6555 continue 6556 raise plumbing.convert_error_to_porcelain(e) from e 6557 tries = 0 6558 for plumbing_item in plumbing_response.history: 6559 yield plumbing.convert_resource_history_to_porcelain( 6560 plumbing_item) 6561 if plumbing_response.meta.next_cursor == '': 6562 break 6563 req.meta.cursor = plumbing_response.meta.next_cursor 6564 6565 return generator(self, req)
List gets a list of ResourceHistory records matching a given set of criteria.
class
RoleResources:
6568class RoleResources: 6569 ''' 6570 RoleResources enumerates the resources to which roles have access. 6571 The RoleResources service is read-only. 6572 See `strongdm.models.RoleResource`. 6573 ''' 6574 def __init__(self, channel, client): 6575 self.parent = client 6576 self.stub = RoleResourcesStub(channel) 6577 6578 def list(self, filter, *args, timeout=None): 6579 ''' 6580 List gets a list of RoleResource records matching a given set of criteria. 6581 ''' 6582 deadline = None if timeout is None else time.time() + timeout 6583 req = RoleResourceListRequest() 6584 req.meta.CopyFrom(ListRequestMetadata()) 6585 if self.parent.page_limit > 0: 6586 req.meta.limit = self.parent.page_limit 6587 if self.parent.snapshot_datetime is not None: 6588 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6589 6590 req.filter = plumbing.quote_filter_args(filter, *args) 6591 6592 def generator(svc, req): 6593 tries = 0 6594 while True: 6595 t = None if deadline is None else deadline - time.time() 6596 try: 6597 plumbing_response = svc.stub.List( 6598 req, 6599 metadata=svc.parent.get_metadata( 6600 'RoleResources.List', req), 6601 timeout=t) 6602 except Exception as e: 6603 if self.parent.shouldRetry(tries, e, deadline): 6604 tries += 1 6605 time.sleep( 6606 self.parent.exponentialBackoff(tries, deadline)) 6607 continue 6608 raise plumbing.convert_error_to_porcelain(e) from e 6609 tries = 0 6610 for plumbing_item in plumbing_response.role_resources: 6611 yield plumbing.convert_role_resource_to_porcelain( 6612 plumbing_item) 6613 if plumbing_response.meta.next_cursor == '': 6614 break 6615 req.meta.cursor = plumbing_response.meta.next_cursor 6616 6617 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)
6578 def list(self, filter, *args, timeout=None): 6579 ''' 6580 List gets a list of RoleResource records matching a given set of criteria. 6581 ''' 6582 deadline = None if timeout is None else time.time() + timeout 6583 req = RoleResourceListRequest() 6584 req.meta.CopyFrom(ListRequestMetadata()) 6585 if self.parent.page_limit > 0: 6586 req.meta.limit = self.parent.page_limit 6587 if self.parent.snapshot_datetime is not None: 6588 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6589 6590 req.filter = plumbing.quote_filter_args(filter, *args) 6591 6592 def generator(svc, req): 6593 tries = 0 6594 while True: 6595 t = None if deadline is None else deadline - time.time() 6596 try: 6597 plumbing_response = svc.stub.List( 6598 req, 6599 metadata=svc.parent.get_metadata( 6600 'RoleResources.List', req), 6601 timeout=t) 6602 except Exception as e: 6603 if self.parent.shouldRetry(tries, e, deadline): 6604 tries += 1 6605 time.sleep( 6606 self.parent.exponentialBackoff(tries, deadline)) 6607 continue 6608 raise plumbing.convert_error_to_porcelain(e) from e 6609 tries = 0 6610 for plumbing_item in plumbing_response.role_resources: 6611 yield plumbing.convert_role_resource_to_porcelain( 6612 plumbing_item) 6613 if plumbing_response.meta.next_cursor == '': 6614 break 6615 req.meta.cursor = plumbing_response.meta.next_cursor 6616 6617 return generator(self, req)
List gets a list of RoleResource records matching a given set of criteria.
class
SnapshotRoleResources:
6620class SnapshotRoleResources: 6621 ''' 6622 SnapshotRoleResources exposes the read only methods of the RoleResources 6623 service for historical queries. 6624 ''' 6625 def __init__(self, role_resources): 6626 self.role_resources = role_resources 6627 6628 def list(self, filter, *args, timeout=None): 6629 ''' 6630 List gets a list of RoleResource records matching a given set of criteria. 6631 ''' 6632 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)
6628 def list(self, filter, *args, timeout=None): 6629 ''' 6630 List gets a list of RoleResource records matching a given set of criteria. 6631 ''' 6632 return self.role_resources.list(filter, *args, timeout=timeout)
List gets a list of RoleResource records matching a given set of criteria.
class
RoleResourcesHistory:
6635class RoleResourcesHistory: 6636 ''' 6637 RoleResourcesHistory records all changes to the state of a RoleResource. 6638 See `strongdm.models.RoleResourceHistory`. 6639 ''' 6640 def __init__(self, channel, client): 6641 self.parent = client 6642 self.stub = RoleResourcesHistoryStub(channel) 6643 6644 def list(self, filter, *args, timeout=None): 6645 ''' 6646 List gets a list of RoleResourceHistory records matching a given set of criteria. 6647 ''' 6648 deadline = None if timeout is None else time.time() + timeout 6649 req = RoleResourceHistoryListRequest() 6650 req.meta.CopyFrom(ListRequestMetadata()) 6651 if self.parent.page_limit > 0: 6652 req.meta.limit = self.parent.page_limit 6653 if self.parent.snapshot_datetime is not None: 6654 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6655 6656 req.filter = plumbing.quote_filter_args(filter, *args) 6657 6658 def generator(svc, req): 6659 tries = 0 6660 while True: 6661 t = None if deadline is None else deadline - time.time() 6662 try: 6663 plumbing_response = svc.stub.List( 6664 req, 6665 metadata=svc.parent.get_metadata( 6666 'RoleResourcesHistory.List', req), 6667 timeout=t) 6668 except Exception as e: 6669 if self.parent.shouldRetry(tries, e, deadline): 6670 tries += 1 6671 time.sleep( 6672 self.parent.exponentialBackoff(tries, deadline)) 6673 continue 6674 raise plumbing.convert_error_to_porcelain(e) from e 6675 tries = 0 6676 for plumbing_item in plumbing_response.history: 6677 yield plumbing.convert_role_resource_history_to_porcelain( 6678 plumbing_item) 6679 if plumbing_response.meta.next_cursor == '': 6680 break 6681 req.meta.cursor = plumbing_response.meta.next_cursor 6682 6683 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)
6644 def list(self, filter, *args, timeout=None): 6645 ''' 6646 List gets a list of RoleResourceHistory records matching a given set of criteria. 6647 ''' 6648 deadline = None if timeout is None else time.time() + timeout 6649 req = RoleResourceHistoryListRequest() 6650 req.meta.CopyFrom(ListRequestMetadata()) 6651 if self.parent.page_limit > 0: 6652 req.meta.limit = self.parent.page_limit 6653 if self.parent.snapshot_datetime is not None: 6654 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6655 6656 req.filter = plumbing.quote_filter_args(filter, *args) 6657 6658 def generator(svc, req): 6659 tries = 0 6660 while True: 6661 t = None if deadline is None else deadline - time.time() 6662 try: 6663 plumbing_response = svc.stub.List( 6664 req, 6665 metadata=svc.parent.get_metadata( 6666 'RoleResourcesHistory.List', req), 6667 timeout=t) 6668 except Exception as e: 6669 if self.parent.shouldRetry(tries, e, deadline): 6670 tries += 1 6671 time.sleep( 6672 self.parent.exponentialBackoff(tries, deadline)) 6673 continue 6674 raise plumbing.convert_error_to_porcelain(e) from e 6675 tries = 0 6676 for plumbing_item in plumbing_response.history: 6677 yield plumbing.convert_role_resource_history_to_porcelain( 6678 plumbing_item) 6679 if plumbing_response.meta.next_cursor == '': 6680 break 6681 req.meta.cursor = plumbing_response.meta.next_cursor 6682 6683 return generator(self, req)
List gets a list of RoleResourceHistory records matching a given set of criteria.
class
RolesHistory:
6686class RolesHistory: 6687 ''' 6688 RolesHistory records all changes to the state of a Role. 6689 See `strongdm.models.RoleHistory`. 6690 ''' 6691 def __init__(self, channel, client): 6692 self.parent = client 6693 self.stub = RolesHistoryStub(channel) 6694 6695 def list(self, filter, *args, timeout=None): 6696 ''' 6697 List gets a list of RoleHistory records matching a given set of criteria. 6698 ''' 6699 deadline = None if timeout is None else time.time() + timeout 6700 req = RoleHistoryListRequest() 6701 req.meta.CopyFrom(ListRequestMetadata()) 6702 if self.parent.page_limit > 0: 6703 req.meta.limit = self.parent.page_limit 6704 if self.parent.snapshot_datetime is not None: 6705 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6706 6707 req.filter = plumbing.quote_filter_args(filter, *args) 6708 6709 def generator(svc, req): 6710 tries = 0 6711 while True: 6712 t = None if deadline is None else deadline - time.time() 6713 try: 6714 plumbing_response = svc.stub.List( 6715 req, 6716 metadata=svc.parent.get_metadata( 6717 'RolesHistory.List', req), 6718 timeout=t) 6719 except Exception as e: 6720 if self.parent.shouldRetry(tries, e, deadline): 6721 tries += 1 6722 time.sleep( 6723 self.parent.exponentialBackoff(tries, deadline)) 6724 continue 6725 raise plumbing.convert_error_to_porcelain(e) from e 6726 tries = 0 6727 for plumbing_item in plumbing_response.history: 6728 yield plumbing.convert_role_history_to_porcelain( 6729 plumbing_item) 6730 if plumbing_response.meta.next_cursor == '': 6731 break 6732 req.meta.cursor = plumbing_response.meta.next_cursor 6733 6734 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)
6695 def list(self, filter, *args, timeout=None): 6696 ''' 6697 List gets a list of RoleHistory records matching a given set of criteria. 6698 ''' 6699 deadline = None if timeout is None else time.time() + timeout 6700 req = RoleHistoryListRequest() 6701 req.meta.CopyFrom(ListRequestMetadata()) 6702 if self.parent.page_limit > 0: 6703 req.meta.limit = self.parent.page_limit 6704 if self.parent.snapshot_datetime is not None: 6705 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6706 6707 req.filter = plumbing.quote_filter_args(filter, *args) 6708 6709 def generator(svc, req): 6710 tries = 0 6711 while True: 6712 t = None if deadline is None else deadline - time.time() 6713 try: 6714 plumbing_response = svc.stub.List( 6715 req, 6716 metadata=svc.parent.get_metadata( 6717 'RolesHistory.List', req), 6718 timeout=t) 6719 except Exception as e: 6720 if self.parent.shouldRetry(tries, e, deadline): 6721 tries += 1 6722 time.sleep( 6723 self.parent.exponentialBackoff(tries, deadline)) 6724 continue 6725 raise plumbing.convert_error_to_porcelain(e) from e 6726 tries = 0 6727 for plumbing_item in plumbing_response.history: 6728 yield plumbing.convert_role_history_to_porcelain( 6729 plumbing_item) 6730 if plumbing_response.meta.next_cursor == '': 6731 break 6732 req.meta.cursor = plumbing_response.meta.next_cursor 6733 6734 return generator(self, req)
List gets a list of RoleHistory records matching a given set of criteria.
class
SecretStores:
6737class SecretStores: 6738 ''' 6739 SecretStores are servers where resource secrets (passwords, keys) are stored. 6740 See: 6741 `strongdm.models.ActiveDirectoryStore` 6742 `strongdm.models.AWSStore` 6743 `strongdm.models.AWSCertX509Store` 6744 `strongdm.models.AzureStore` 6745 `strongdm.models.CyberarkConjurStore` 6746 `strongdm.models.CyberarkPAMStore` 6747 `strongdm.models.CyberarkPAMExperimentalStore` 6748 `strongdm.models.DelineaStore` 6749 `strongdm.models.GCPStore` 6750 `strongdm.models.GCPCertX509Store` 6751 `strongdm.models.KeyfactorSSHStore` 6752 `strongdm.models.KeyfactorX509Store` 6753 `strongdm.models.StrongVaultStore` 6754 `strongdm.models.VaultAppRoleStore` 6755 `strongdm.models.VaultAppRoleCertSSHStore` 6756 `strongdm.models.VaultAppRoleCertX509Store` 6757 `strongdm.models.VaultAWSEC2Store` 6758 `strongdm.models.VaultAWSEC2CertSSHStore` 6759 `strongdm.models.VaultAWSEC2CertX509Store` 6760 `strongdm.models.VaultAWSIAMStore` 6761 `strongdm.models.VaultAWSIAMCertSSHStore` 6762 `strongdm.models.VaultAWSIAMCertX509Store` 6763 `strongdm.models.VaultTLSStore` 6764 `strongdm.models.VaultTLSCertSSHStore` 6765 `strongdm.models.VaultTLSCertX509Store` 6766 `strongdm.models.VaultTokenStore` 6767 `strongdm.models.VaultTokenCertSSHStore` 6768 `strongdm.models.VaultTokenCertX509Store` 6769 ''' 6770 def __init__(self, channel, client): 6771 self.parent = client 6772 self.stub = SecretStoresStub(channel) 6773 6774 def create(self, secret_store, timeout=None): 6775 deadline = None if timeout is None else time.time() + timeout 6776 req = SecretStoreCreateRequest() 6777 6778 if secret_store is not None: 6779 req.secret_store.CopyFrom( 6780 plumbing.convert_secret_store_to_plumbing(secret_store)) 6781 tries = 0 6782 plumbing_response = None 6783 while True: 6784 t = None if deadline is None else deadline - time.time() 6785 try: 6786 plumbing_response = self.stub.Create( 6787 req, 6788 metadata=self.parent.get_metadata('SecretStores.Create', 6789 req), 6790 timeout=t) 6791 except Exception as e: 6792 if self.parent.shouldRetry(tries, e, deadline): 6793 tries += 1 6794 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6795 continue 6796 raise plumbing.convert_error_to_porcelain(e) from e 6797 break 6798 6799 resp = models.SecretStoreCreateResponse() 6800 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 6801 plumbing_response.meta) 6802 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6803 plumbing_response.rate_limit) 6804 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 6805 plumbing_response.secret_store) 6806 return resp 6807 6808 def get(self, id, timeout=None): 6809 ''' 6810 Get reads one SecretStore by ID. 6811 ''' 6812 deadline = None if timeout is None else time.time() + timeout 6813 req = SecretStoreGetRequest() 6814 if self.parent.snapshot_datetime is not None: 6815 req.meta.CopyFrom(GetRequestMetadata()) 6816 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6817 6818 req.id = (id) 6819 tries = 0 6820 plumbing_response = None 6821 while True: 6822 t = None if deadline is None else deadline - time.time() 6823 try: 6824 plumbing_response = self.stub.Get( 6825 req, 6826 metadata=self.parent.get_metadata('SecretStores.Get', req), 6827 timeout=t) 6828 except Exception as e: 6829 if self.parent.shouldRetry(tries, e, deadline): 6830 tries += 1 6831 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6832 continue 6833 raise plumbing.convert_error_to_porcelain(e) from e 6834 break 6835 6836 resp = models.SecretStoreGetResponse() 6837 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 6838 plumbing_response.meta) 6839 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6840 plumbing_response.rate_limit) 6841 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 6842 plumbing_response.secret_store) 6843 return resp 6844 6845 def update(self, secret_store, timeout=None): 6846 ''' 6847 Update replaces all the fields of a SecretStore by ID. 6848 ''' 6849 deadline = None if timeout is None else time.time() + timeout 6850 req = SecretStoreUpdateRequest() 6851 6852 if secret_store is not None: 6853 req.secret_store.CopyFrom( 6854 plumbing.convert_secret_store_to_plumbing(secret_store)) 6855 tries = 0 6856 plumbing_response = None 6857 while True: 6858 t = None if deadline is None else deadline - time.time() 6859 try: 6860 plumbing_response = self.stub.Update( 6861 req, 6862 metadata=self.parent.get_metadata('SecretStores.Update', 6863 req), 6864 timeout=t) 6865 except Exception as e: 6866 if self.parent.shouldRetry(tries, e, deadline): 6867 tries += 1 6868 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6869 continue 6870 raise plumbing.convert_error_to_porcelain(e) from e 6871 break 6872 6873 resp = models.SecretStoreUpdateResponse() 6874 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 6875 plumbing_response.meta) 6876 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6877 plumbing_response.rate_limit) 6878 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 6879 plumbing_response.secret_store) 6880 return resp 6881 6882 def delete(self, id, timeout=None): 6883 ''' 6884 Delete removes a SecretStore by ID. 6885 ''' 6886 deadline = None if timeout is None else time.time() + timeout 6887 req = SecretStoreDeleteRequest() 6888 6889 req.id = (id) 6890 tries = 0 6891 plumbing_response = None 6892 while True: 6893 t = None if deadline is None else deadline - time.time() 6894 try: 6895 plumbing_response = self.stub.Delete( 6896 req, 6897 metadata=self.parent.get_metadata('SecretStores.Delete', 6898 req), 6899 timeout=t) 6900 except Exception as e: 6901 if self.parent.shouldRetry(tries, e, deadline): 6902 tries += 1 6903 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6904 continue 6905 raise plumbing.convert_error_to_porcelain(e) from e 6906 break 6907 6908 resp = models.SecretStoreDeleteResponse() 6909 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 6910 plumbing_response.meta) 6911 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6912 plumbing_response.rate_limit) 6913 return resp 6914 6915 def list(self, filter, *args, timeout=None): 6916 ''' 6917 List gets a list of SecretStores matching a given set of criteria. 6918 ''' 6919 deadline = None if timeout is None else time.time() + timeout 6920 req = SecretStoreListRequest() 6921 req.meta.CopyFrom(ListRequestMetadata()) 6922 if self.parent.page_limit > 0: 6923 req.meta.limit = self.parent.page_limit 6924 if self.parent.snapshot_datetime is not None: 6925 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6926 6927 req.filter = plumbing.quote_filter_args(filter, *args) 6928 6929 def generator(svc, req): 6930 tries = 0 6931 while True: 6932 t = None if deadline is None else deadline - time.time() 6933 try: 6934 plumbing_response = svc.stub.List( 6935 req, 6936 metadata=svc.parent.get_metadata( 6937 'SecretStores.List', req), 6938 timeout=t) 6939 except Exception as e: 6940 if self.parent.shouldRetry(tries, e, deadline): 6941 tries += 1 6942 time.sleep( 6943 self.parent.exponentialBackoff(tries, deadline)) 6944 continue 6945 raise plumbing.convert_error_to_porcelain(e) from e 6946 tries = 0 6947 for plumbing_item in plumbing_response.secret_stores: 6948 yield plumbing.convert_secret_store_to_porcelain( 6949 plumbing_item) 6950 if plumbing_response.meta.next_cursor == '': 6951 break 6952 req.meta.cursor = plumbing_response.meta.next_cursor 6953 6954 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)
6774 def create(self, secret_store, timeout=None): 6775 deadline = None if timeout is None else time.time() + timeout 6776 req = SecretStoreCreateRequest() 6777 6778 if secret_store is not None: 6779 req.secret_store.CopyFrom( 6780 plumbing.convert_secret_store_to_plumbing(secret_store)) 6781 tries = 0 6782 plumbing_response = None 6783 while True: 6784 t = None if deadline is None else deadline - time.time() 6785 try: 6786 plumbing_response = self.stub.Create( 6787 req, 6788 metadata=self.parent.get_metadata('SecretStores.Create', 6789 req), 6790 timeout=t) 6791 except Exception as e: 6792 if self.parent.shouldRetry(tries, e, deadline): 6793 tries += 1 6794 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6795 continue 6796 raise plumbing.convert_error_to_porcelain(e) from e 6797 break 6798 6799 resp = models.SecretStoreCreateResponse() 6800 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 6801 plumbing_response.meta) 6802 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6803 plumbing_response.rate_limit) 6804 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 6805 plumbing_response.secret_store) 6806 return resp
def
get(self, id, timeout=None)
6808 def get(self, id, timeout=None): 6809 ''' 6810 Get reads one SecretStore by ID. 6811 ''' 6812 deadline = None if timeout is None else time.time() + timeout 6813 req = SecretStoreGetRequest() 6814 if self.parent.snapshot_datetime is not None: 6815 req.meta.CopyFrom(GetRequestMetadata()) 6816 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6817 6818 req.id = (id) 6819 tries = 0 6820 plumbing_response = None 6821 while True: 6822 t = None if deadline is None else deadline - time.time() 6823 try: 6824 plumbing_response = self.stub.Get( 6825 req, 6826 metadata=self.parent.get_metadata('SecretStores.Get', req), 6827 timeout=t) 6828 except Exception as e: 6829 if self.parent.shouldRetry(tries, e, deadline): 6830 tries += 1 6831 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6832 continue 6833 raise plumbing.convert_error_to_porcelain(e) from e 6834 break 6835 6836 resp = models.SecretStoreGetResponse() 6837 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 6838 plumbing_response.meta) 6839 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6840 plumbing_response.rate_limit) 6841 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 6842 plumbing_response.secret_store) 6843 return resp
Get reads one SecretStore by ID.
def
update(self, secret_store, timeout=None)
6845 def update(self, secret_store, timeout=None): 6846 ''' 6847 Update replaces all the fields of a SecretStore by ID. 6848 ''' 6849 deadline = None if timeout is None else time.time() + timeout 6850 req = SecretStoreUpdateRequest() 6851 6852 if secret_store is not None: 6853 req.secret_store.CopyFrom( 6854 plumbing.convert_secret_store_to_plumbing(secret_store)) 6855 tries = 0 6856 plumbing_response = None 6857 while True: 6858 t = None if deadline is None else deadline - time.time() 6859 try: 6860 plumbing_response = self.stub.Update( 6861 req, 6862 metadata=self.parent.get_metadata('SecretStores.Update', 6863 req), 6864 timeout=t) 6865 except Exception as e: 6866 if self.parent.shouldRetry(tries, e, deadline): 6867 tries += 1 6868 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6869 continue 6870 raise plumbing.convert_error_to_porcelain(e) from e 6871 break 6872 6873 resp = models.SecretStoreUpdateResponse() 6874 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 6875 plumbing_response.meta) 6876 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6877 plumbing_response.rate_limit) 6878 resp.secret_store = plumbing.convert_secret_store_to_porcelain( 6879 plumbing_response.secret_store) 6880 return resp
Update replaces all the fields of a SecretStore by ID.
def
delete(self, id, timeout=None)
6882 def delete(self, id, timeout=None): 6883 ''' 6884 Delete removes a SecretStore by ID. 6885 ''' 6886 deadline = None if timeout is None else time.time() + timeout 6887 req = SecretStoreDeleteRequest() 6888 6889 req.id = (id) 6890 tries = 0 6891 plumbing_response = None 6892 while True: 6893 t = None if deadline is None else deadline - time.time() 6894 try: 6895 plumbing_response = self.stub.Delete( 6896 req, 6897 metadata=self.parent.get_metadata('SecretStores.Delete', 6898 req), 6899 timeout=t) 6900 except Exception as e: 6901 if self.parent.shouldRetry(tries, e, deadline): 6902 tries += 1 6903 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 6904 continue 6905 raise plumbing.convert_error_to_porcelain(e) from e 6906 break 6907 6908 resp = models.SecretStoreDeleteResponse() 6909 resp.meta = plumbing.convert_delete_response_metadata_to_porcelain( 6910 plumbing_response.meta) 6911 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 6912 plumbing_response.rate_limit) 6913 return resp
Delete removes a SecretStore by ID.
def
list(self, filter, *args, timeout=None)
6915 def list(self, filter, *args, timeout=None): 6916 ''' 6917 List gets a list of SecretStores matching a given set of criteria. 6918 ''' 6919 deadline = None if timeout is None else time.time() + timeout 6920 req = SecretStoreListRequest() 6921 req.meta.CopyFrom(ListRequestMetadata()) 6922 if self.parent.page_limit > 0: 6923 req.meta.limit = self.parent.page_limit 6924 if self.parent.snapshot_datetime is not None: 6925 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 6926 6927 req.filter = plumbing.quote_filter_args(filter, *args) 6928 6929 def generator(svc, req): 6930 tries = 0 6931 while True: 6932 t = None if deadline is None else deadline - time.time() 6933 try: 6934 plumbing_response = svc.stub.List( 6935 req, 6936 metadata=svc.parent.get_metadata( 6937 'SecretStores.List', req), 6938 timeout=t) 6939 except Exception as e: 6940 if self.parent.shouldRetry(tries, e, deadline): 6941 tries += 1 6942 time.sleep( 6943 self.parent.exponentialBackoff(tries, deadline)) 6944 continue 6945 raise plumbing.convert_error_to_porcelain(e) from e 6946 tries = 0 6947 for plumbing_item in plumbing_response.secret_stores: 6948 yield plumbing.convert_secret_store_to_porcelain( 6949 plumbing_item) 6950 if plumbing_response.meta.next_cursor == '': 6951 break 6952 req.meta.cursor = plumbing_response.meta.next_cursor 6953 6954 return generator(self, req)
List gets a list of SecretStores matching a given set of criteria.
class
SnapshotSecretStores:
6957class SnapshotSecretStores: 6958 ''' 6959 SnapshotSecretStores exposes the read only methods of the SecretStores 6960 service for historical queries. 6961 ''' 6962 def __init__(self, secret_stores): 6963 self.secret_stores = secret_stores 6964 6965 def get(self, id, timeout=None): 6966 ''' 6967 Get reads one SecretStore by ID. 6968 ''' 6969 return self.secret_stores.get(id, timeout=timeout) 6970 6971 def list(self, filter, *args, timeout=None): 6972 ''' 6973 List gets a list of SecretStores matching a given set of criteria. 6974 ''' 6975 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)
6965 def get(self, id, timeout=None): 6966 ''' 6967 Get reads one SecretStore by ID. 6968 ''' 6969 return self.secret_stores.get(id, timeout=timeout)
Get reads one SecretStore by ID.
def
list(self, filter, *args, timeout=None)
6971 def list(self, filter, *args, timeout=None): 6972 ''' 6973 List gets a list of SecretStores matching a given set of criteria. 6974 ''' 6975 return self.secret_stores.list(filter, *args, timeout=timeout)
List gets a list of SecretStores matching a given set of criteria.
class
SecretEngines:
6978class SecretEngines: 6979 ''' 6980 6981 See: 6982 `strongdm.models.ActiveDirectoryEngine` 6983 `strongdm.models.KeyValueEngine` 6984 `strongdm.models.MysqlEngine` 6985 `strongdm.models.PostgresEngine` 6986 `strongdm.models.SqlserverEngine` 6987 ''' 6988 def __init__(self, channel, client): 6989 self.parent = client 6990 self.stub = SecretEnginesStub(channel) 6991 6992 def list(self, filter, *args, timeout=None): 6993 ''' 6994 List returns a list of Secret Engines 6995 ''' 6996 deadline = None if timeout is None else time.time() + timeout 6997 req = SecretEngineListRequest() 6998 req.meta.CopyFrom(ListRequestMetadata()) 6999 if self.parent.page_limit > 0: 7000 req.meta.limit = self.parent.page_limit 7001 if self.parent.snapshot_datetime is not None: 7002 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7003 7004 req.filter = plumbing.quote_filter_args(filter, *args) 7005 7006 def generator(svc, req): 7007 tries = 0 7008 while True: 7009 t = None if deadline is None else deadline - time.time() 7010 try: 7011 plumbing_response = svc.stub.List( 7012 req, 7013 metadata=svc.parent.get_metadata( 7014 'SecretEngines.List', req), 7015 timeout=t) 7016 except Exception as e: 7017 if self.parent.shouldRetry(tries, e, deadline): 7018 tries += 1 7019 time.sleep( 7020 self.parent.exponentialBackoff(tries, deadline)) 7021 continue 7022 raise plumbing.convert_error_to_porcelain(e) from e 7023 tries = 0 7024 for plumbing_item in plumbing_response.secret_engines: 7025 yield plumbing.convert_secret_engine_to_porcelain( 7026 plumbing_item) 7027 if plumbing_response.meta.next_cursor == '': 7028 break 7029 req.meta.cursor = plumbing_response.meta.next_cursor 7030 7031 return generator(self, req) 7032 7033 def get(self, id, timeout=None): 7034 ''' 7035 Get returns a secret engine details 7036 ''' 7037 deadline = None if timeout is None else time.time() + timeout 7038 req = SecretEngineGetRequest() 7039 if self.parent.snapshot_datetime is not None: 7040 req.meta.CopyFrom(GetRequestMetadata()) 7041 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7042 7043 req.id = (id) 7044 tries = 0 7045 plumbing_response = None 7046 while True: 7047 t = None if deadline is None else deadline - time.time() 7048 try: 7049 plumbing_response = self.stub.Get( 7050 req, 7051 metadata=self.parent.get_metadata('SecretEngines.Get', 7052 req), 7053 timeout=t) 7054 except Exception as e: 7055 if self.parent.shouldRetry(tries, e, deadline): 7056 tries += 1 7057 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7058 continue 7059 raise plumbing.convert_error_to_porcelain(e) from e 7060 break 7061 7062 resp = models.SecretEngineGetResponse() 7063 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 7064 plumbing_response.meta) 7065 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7066 plumbing_response.rate_limit) 7067 resp.secret_engine = plumbing.convert_secret_engine_to_porcelain( 7068 plumbing_response.secret_engine) 7069 return resp 7070 7071 def create(self, secret_engine, timeout=None): 7072 ''' 7073 Create creates a secret engine 7074 ''' 7075 deadline = None if timeout is None else time.time() + timeout 7076 req = SecretEngineCreateRequest() 7077 7078 if secret_engine is not None: 7079 req.secret_engine.CopyFrom( 7080 plumbing.convert_secret_engine_to_plumbing(secret_engine)) 7081 tries = 0 7082 plumbing_response = None 7083 while True: 7084 t = None if deadline is None else deadline - time.time() 7085 try: 7086 plumbing_response = self.stub.Create( 7087 req, 7088 metadata=self.parent.get_metadata('SecretEngines.Create', 7089 req), 7090 timeout=t) 7091 except Exception as e: 7092 if self.parent.shouldRetry(tries, e, deadline): 7093 tries += 1 7094 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7095 continue 7096 raise plumbing.convert_error_to_porcelain(e) from e 7097 break 7098 7099 resp = models.SecretEngineCreateResponse() 7100 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 7101 plumbing_response.meta) 7102 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7103 plumbing_response.rate_limit) 7104 resp.secret_engine = plumbing.convert_secret_engine_to_porcelain( 7105 plumbing_response.secret_engine) 7106 return resp 7107 7108 def update(self, secret_engine, timeout=None): 7109 ''' 7110 Update updates a secret engine 7111 ''' 7112 deadline = None if timeout is None else time.time() + timeout 7113 req = SecretEngineUpdateRequest() 7114 7115 if secret_engine is not None: 7116 req.secret_engine.CopyFrom( 7117 plumbing.convert_secret_engine_to_plumbing(secret_engine)) 7118 tries = 0 7119 plumbing_response = None 7120 while True: 7121 t = None if deadline is None else deadline - time.time() 7122 try: 7123 plumbing_response = self.stub.Update( 7124 req, 7125 metadata=self.parent.get_metadata('SecretEngines.Update', 7126 req), 7127 timeout=t) 7128 except Exception as e: 7129 if self.parent.shouldRetry(tries, e, deadline): 7130 tries += 1 7131 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7132 continue 7133 raise plumbing.convert_error_to_porcelain(e) from e 7134 break 7135 7136 resp = models.SecretEngineUpdateResponse() 7137 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 7138 plumbing_response.meta) 7139 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7140 plumbing_response.rate_limit) 7141 resp.secret_engine = plumbing.convert_secret_engine_to_porcelain( 7142 plumbing_response.secret_engine) 7143 return resp 7144 7145 def delete(self, id, timeout=None): 7146 ''' 7147 Delete deletes a secret engine 7148 ''' 7149 deadline = None if timeout is None else time.time() + timeout 7150 req = SecretEngineDeleteRequest() 7151 7152 req.id = (id) 7153 tries = 0 7154 plumbing_response = None 7155 while True: 7156 t = None if deadline is None else deadline - time.time() 7157 try: 7158 plumbing_response = self.stub.Delete( 7159 req, 7160 metadata=self.parent.get_metadata('SecretEngines.Delete', 7161 req), 7162 timeout=t) 7163 except Exception as e: 7164 if self.parent.shouldRetry(tries, e, deadline): 7165 tries += 1 7166 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7167 continue 7168 raise plumbing.convert_error_to_porcelain(e) from e 7169 break 7170 7171 resp = models.SecretEngineDeleteResponse() 7172 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7173 plumbing_response.rate_limit) 7174 return resp 7175 7176 def list_secret_stores(self, filter, *args, timeout=None): 7177 ''' 7178 ListSecretStores returns a list of Secret Stores that can be used as a backing store 7179 for Secret Engine 7180 ''' 7181 deadline = None if timeout is None else time.time() + timeout 7182 req = SecretStoreListRequest() 7183 req.meta.CopyFrom(ListRequestMetadata()) 7184 if self.parent.page_limit > 0: 7185 req.meta.limit = self.parent.page_limit 7186 if self.parent.snapshot_datetime is not None: 7187 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7188 7189 req.filter = plumbing.quote_filter_args(filter, *args) 7190 7191 def generator(svc, req): 7192 tries = 0 7193 while True: 7194 t = None if deadline is None else deadline - time.time() 7195 try: 7196 plumbing_response = svc.stub.ListSecretStores( 7197 req, 7198 metadata=svc.parent.get_metadata( 7199 'SecretEngines.ListSecretStores', req), 7200 timeout=t) 7201 except Exception as e: 7202 if self.parent.shouldRetry(tries, e, deadline): 7203 tries += 1 7204 time.sleep( 7205 self.parent.exponentialBackoff(tries, deadline)) 7206 continue 7207 raise plumbing.convert_error_to_porcelain(e) from e 7208 tries = 0 7209 for plumbing_item in plumbing_response.secret_stores: 7210 yield plumbing.convert_secret_store_to_porcelain( 7211 plumbing_item) 7212 if plumbing_response.meta.next_cursor == '': 7213 break 7214 req.meta.cursor = plumbing_response.meta.next_cursor 7215 7216 return generator(self, req) 7217 7218 def generate_keys(self, secret_engine_id, timeout=None): 7219 ''' 7220 GenerateKeys generates a private key, stores it in a secret store and stores a public key in a secret engine 7221 ''' 7222 deadline = None if timeout is None else time.time() + timeout 7223 req = GenerateKeysRequest() 7224 7225 req.secret_engine_id = (secret_engine_id) 7226 tries = 0 7227 plumbing_response = None 7228 while True: 7229 t = None if deadline is None else deadline - time.time() 7230 try: 7231 plumbing_response = self.stub.GenerateKeys( 7232 req, 7233 metadata=self.parent.get_metadata( 7234 'SecretEngines.GenerateKeys', req), 7235 timeout=t) 7236 except Exception as e: 7237 if self.parent.shouldRetry(tries, e, deadline): 7238 tries += 1 7239 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7240 continue 7241 raise plumbing.convert_error_to_porcelain(e) from e 7242 break 7243 7244 resp = models.GenerateKeysResponse() 7245 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7246 plumbing_response.rate_limit) 7247 return resp 7248 7249 def healthcheck(self, secret_engine_id, timeout=None): 7250 ''' 7251 Healthcheck triggers a healthcheck for all nodes serving a secret engine 7252 ''' 7253 deadline = None if timeout is None else time.time() + timeout 7254 req = HealthcheckRequest() 7255 7256 req.secret_engine_id = (secret_engine_id) 7257 tries = 0 7258 plumbing_response = None 7259 while True: 7260 t = None if deadline is None else deadline - time.time() 7261 try: 7262 plumbing_response = self.stub.Healthcheck( 7263 req, 7264 metadata=self.parent.get_metadata( 7265 'SecretEngines.Healthcheck', req), 7266 timeout=t) 7267 except Exception as e: 7268 if self.parent.shouldRetry(tries, e, deadline): 7269 tries += 1 7270 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7271 continue 7272 raise plumbing.convert_error_to_porcelain(e) from e 7273 break 7274 7275 resp = models.HealthcheckResponse() 7276 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7277 plumbing_response.rate_limit) 7278 resp.status = plumbing.convert_repeated_healthcheck_status_to_porcelain( 7279 plumbing_response.status) 7280 return resp 7281 7282 def rotate(self, id, password_policy, timeout=None): 7283 ''' 7284 Rotate rotates secret engine's credentials 7285 ''' 7286 deadline = None if timeout is None else time.time() + timeout 7287 req = SecretEngineRotateRequest() 7288 7289 req.id = (id) 7290 if password_policy is not None: 7291 req.password_policy.CopyFrom( 7292 plumbing.convert_secret_engine_password_policy_to_plumbing( 7293 password_policy)) 7294 tries = 0 7295 plumbing_response = None 7296 while True: 7297 t = None if deadline is None else deadline - time.time() 7298 try: 7299 plumbing_response = self.stub.Rotate( 7300 req, 7301 metadata=self.parent.get_metadata('SecretEngines.Rotate', 7302 req), 7303 timeout=t) 7304 except Exception as e: 7305 if self.parent.shouldRetry(tries, e, deadline): 7306 tries += 1 7307 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7308 continue 7309 raise plumbing.convert_error_to_porcelain(e) from e 7310 break 7311 7312 resp = models.SecretEngineRotateResponse() 7313 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7314 plumbing_response.rate_limit) 7315 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)
6992 def list(self, filter, *args, timeout=None): 6993 ''' 6994 List returns a list of Secret Engines 6995 ''' 6996 deadline = None if timeout is None else time.time() + timeout 6997 req = SecretEngineListRequest() 6998 req.meta.CopyFrom(ListRequestMetadata()) 6999 if self.parent.page_limit > 0: 7000 req.meta.limit = self.parent.page_limit 7001 if self.parent.snapshot_datetime is not None: 7002 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7003 7004 req.filter = plumbing.quote_filter_args(filter, *args) 7005 7006 def generator(svc, req): 7007 tries = 0 7008 while True: 7009 t = None if deadline is None else deadline - time.time() 7010 try: 7011 plumbing_response = svc.stub.List( 7012 req, 7013 metadata=svc.parent.get_metadata( 7014 'SecretEngines.List', req), 7015 timeout=t) 7016 except Exception as e: 7017 if self.parent.shouldRetry(tries, e, deadline): 7018 tries += 1 7019 time.sleep( 7020 self.parent.exponentialBackoff(tries, deadline)) 7021 continue 7022 raise plumbing.convert_error_to_porcelain(e) from e 7023 tries = 0 7024 for plumbing_item in plumbing_response.secret_engines: 7025 yield plumbing.convert_secret_engine_to_porcelain( 7026 plumbing_item) 7027 if plumbing_response.meta.next_cursor == '': 7028 break 7029 req.meta.cursor = plumbing_response.meta.next_cursor 7030 7031 return generator(self, req)
List returns a list of Secret Engines
def
get(self, id, timeout=None)
7033 def get(self, id, timeout=None): 7034 ''' 7035 Get returns a secret engine details 7036 ''' 7037 deadline = None if timeout is None else time.time() + timeout 7038 req = SecretEngineGetRequest() 7039 if self.parent.snapshot_datetime is not None: 7040 req.meta.CopyFrom(GetRequestMetadata()) 7041 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7042 7043 req.id = (id) 7044 tries = 0 7045 plumbing_response = None 7046 while True: 7047 t = None if deadline is None else deadline - time.time() 7048 try: 7049 plumbing_response = self.stub.Get( 7050 req, 7051 metadata=self.parent.get_metadata('SecretEngines.Get', 7052 req), 7053 timeout=t) 7054 except Exception as e: 7055 if self.parent.shouldRetry(tries, e, deadline): 7056 tries += 1 7057 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7058 continue 7059 raise plumbing.convert_error_to_porcelain(e) from e 7060 break 7061 7062 resp = models.SecretEngineGetResponse() 7063 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 7064 plumbing_response.meta) 7065 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7066 plumbing_response.rate_limit) 7067 resp.secret_engine = plumbing.convert_secret_engine_to_porcelain( 7068 plumbing_response.secret_engine) 7069 return resp
Get returns a secret engine details
def
create(self, secret_engine, timeout=None)
7071 def create(self, secret_engine, timeout=None): 7072 ''' 7073 Create creates a secret engine 7074 ''' 7075 deadline = None if timeout is None else time.time() + timeout 7076 req = SecretEngineCreateRequest() 7077 7078 if secret_engine is not None: 7079 req.secret_engine.CopyFrom( 7080 plumbing.convert_secret_engine_to_plumbing(secret_engine)) 7081 tries = 0 7082 plumbing_response = None 7083 while True: 7084 t = None if deadline is None else deadline - time.time() 7085 try: 7086 plumbing_response = self.stub.Create( 7087 req, 7088 metadata=self.parent.get_metadata('SecretEngines.Create', 7089 req), 7090 timeout=t) 7091 except Exception as e: 7092 if self.parent.shouldRetry(tries, e, deadline): 7093 tries += 1 7094 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7095 continue 7096 raise plumbing.convert_error_to_porcelain(e) from e 7097 break 7098 7099 resp = models.SecretEngineCreateResponse() 7100 resp.meta = plumbing.convert_create_response_metadata_to_porcelain( 7101 plumbing_response.meta) 7102 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7103 plumbing_response.rate_limit) 7104 resp.secret_engine = plumbing.convert_secret_engine_to_porcelain( 7105 plumbing_response.secret_engine) 7106 return resp
Create creates a secret engine
def
update(self, secret_engine, timeout=None)
7108 def update(self, secret_engine, timeout=None): 7109 ''' 7110 Update updates a secret engine 7111 ''' 7112 deadline = None if timeout is None else time.time() + timeout 7113 req = SecretEngineUpdateRequest() 7114 7115 if secret_engine is not None: 7116 req.secret_engine.CopyFrom( 7117 plumbing.convert_secret_engine_to_plumbing(secret_engine)) 7118 tries = 0 7119 plumbing_response = None 7120 while True: 7121 t = None if deadline is None else deadline - time.time() 7122 try: 7123 plumbing_response = self.stub.Update( 7124 req, 7125 metadata=self.parent.get_metadata('SecretEngines.Update', 7126 req), 7127 timeout=t) 7128 except Exception as e: 7129 if self.parent.shouldRetry(tries, e, deadline): 7130 tries += 1 7131 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7132 continue 7133 raise plumbing.convert_error_to_porcelain(e) from e 7134 break 7135 7136 resp = models.SecretEngineUpdateResponse() 7137 resp.meta = plumbing.convert_update_response_metadata_to_porcelain( 7138 plumbing_response.meta) 7139 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7140 plumbing_response.rate_limit) 7141 resp.secret_engine = plumbing.convert_secret_engine_to_porcelain( 7142 plumbing_response.secret_engine) 7143 return resp
Update updates a secret engine
def
delete(self, id, timeout=None)
7145 def delete(self, id, timeout=None): 7146 ''' 7147 Delete deletes a secret engine 7148 ''' 7149 deadline = None if timeout is None else time.time() + timeout 7150 req = SecretEngineDeleteRequest() 7151 7152 req.id = (id) 7153 tries = 0 7154 plumbing_response = None 7155 while True: 7156 t = None if deadline is None else deadline - time.time() 7157 try: 7158 plumbing_response = self.stub.Delete( 7159 req, 7160 metadata=self.parent.get_metadata('SecretEngines.Delete', 7161 req), 7162 timeout=t) 7163 except Exception as e: 7164 if self.parent.shouldRetry(tries, e, deadline): 7165 tries += 1 7166 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7167 continue 7168 raise plumbing.convert_error_to_porcelain(e) from e 7169 break 7170 7171 resp = models.SecretEngineDeleteResponse() 7172 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7173 plumbing_response.rate_limit) 7174 return resp
Delete deletes a secret engine
def
list_secret_stores(self, filter, *args, timeout=None)
7176 def list_secret_stores(self, filter, *args, timeout=None): 7177 ''' 7178 ListSecretStores returns a list of Secret Stores that can be used as a backing store 7179 for Secret Engine 7180 ''' 7181 deadline = None if timeout is None else time.time() + timeout 7182 req = SecretStoreListRequest() 7183 req.meta.CopyFrom(ListRequestMetadata()) 7184 if self.parent.page_limit > 0: 7185 req.meta.limit = self.parent.page_limit 7186 if self.parent.snapshot_datetime is not None: 7187 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7188 7189 req.filter = plumbing.quote_filter_args(filter, *args) 7190 7191 def generator(svc, req): 7192 tries = 0 7193 while True: 7194 t = None if deadline is None else deadline - time.time() 7195 try: 7196 plumbing_response = svc.stub.ListSecretStores( 7197 req, 7198 metadata=svc.parent.get_metadata( 7199 'SecretEngines.ListSecretStores', req), 7200 timeout=t) 7201 except Exception as e: 7202 if self.parent.shouldRetry(tries, e, deadline): 7203 tries += 1 7204 time.sleep( 7205 self.parent.exponentialBackoff(tries, deadline)) 7206 continue 7207 raise plumbing.convert_error_to_porcelain(e) from e 7208 tries = 0 7209 for plumbing_item in plumbing_response.secret_stores: 7210 yield plumbing.convert_secret_store_to_porcelain( 7211 plumbing_item) 7212 if plumbing_response.meta.next_cursor == '': 7213 break 7214 req.meta.cursor = plumbing_response.meta.next_cursor 7215 7216 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)
7218 def generate_keys(self, secret_engine_id, timeout=None): 7219 ''' 7220 GenerateKeys generates a private key, stores it in a secret store and stores a public key in a secret engine 7221 ''' 7222 deadline = None if timeout is None else time.time() + timeout 7223 req = GenerateKeysRequest() 7224 7225 req.secret_engine_id = (secret_engine_id) 7226 tries = 0 7227 plumbing_response = None 7228 while True: 7229 t = None if deadline is None else deadline - time.time() 7230 try: 7231 plumbing_response = self.stub.GenerateKeys( 7232 req, 7233 metadata=self.parent.get_metadata( 7234 'SecretEngines.GenerateKeys', req), 7235 timeout=t) 7236 except Exception as e: 7237 if self.parent.shouldRetry(tries, e, deadline): 7238 tries += 1 7239 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7240 continue 7241 raise plumbing.convert_error_to_porcelain(e) from e 7242 break 7243 7244 resp = models.GenerateKeysResponse() 7245 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7246 plumbing_response.rate_limit) 7247 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)
7249 def healthcheck(self, secret_engine_id, timeout=None): 7250 ''' 7251 Healthcheck triggers a healthcheck for all nodes serving a secret engine 7252 ''' 7253 deadline = None if timeout is None else time.time() + timeout 7254 req = HealthcheckRequest() 7255 7256 req.secret_engine_id = (secret_engine_id) 7257 tries = 0 7258 plumbing_response = None 7259 while True: 7260 t = None if deadline is None else deadline - time.time() 7261 try: 7262 plumbing_response = self.stub.Healthcheck( 7263 req, 7264 metadata=self.parent.get_metadata( 7265 'SecretEngines.Healthcheck', req), 7266 timeout=t) 7267 except Exception as e: 7268 if self.parent.shouldRetry(tries, e, deadline): 7269 tries += 1 7270 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7271 continue 7272 raise plumbing.convert_error_to_porcelain(e) from e 7273 break 7274 7275 resp = models.HealthcheckResponse() 7276 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7277 plumbing_response.rate_limit) 7278 resp.status = plumbing.convert_repeated_healthcheck_status_to_porcelain( 7279 plumbing_response.status) 7280 return resp
Healthcheck triggers a healthcheck for all nodes serving a secret engine
def
rotate(self, id, password_policy, timeout=None)
7282 def rotate(self, id, password_policy, timeout=None): 7283 ''' 7284 Rotate rotates secret engine's credentials 7285 ''' 7286 deadline = None if timeout is None else time.time() + timeout 7287 req = SecretEngineRotateRequest() 7288 7289 req.id = (id) 7290 if password_policy is not None: 7291 req.password_policy.CopyFrom( 7292 plumbing.convert_secret_engine_password_policy_to_plumbing( 7293 password_policy)) 7294 tries = 0 7295 plumbing_response = None 7296 while True: 7297 t = None if deadline is None else deadline - time.time() 7298 try: 7299 plumbing_response = self.stub.Rotate( 7300 req, 7301 metadata=self.parent.get_metadata('SecretEngines.Rotate', 7302 req), 7303 timeout=t) 7304 except Exception as e: 7305 if self.parent.shouldRetry(tries, e, deadline): 7306 tries += 1 7307 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7308 continue 7309 raise plumbing.convert_error_to_porcelain(e) from e 7310 break 7311 7312 resp = models.SecretEngineRotateResponse() 7313 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7314 plumbing_response.rate_limit) 7315 return resp
Rotate rotates secret engine's credentials
class
SecretStoreHealths:
7318class SecretStoreHealths: 7319 ''' 7320 SecretStoreHealths exposes health states for secret stores. 7321 See `strongdm.models.SecretStoreHealth`. 7322 ''' 7323 def __init__(self, channel, client): 7324 self.parent = client 7325 self.stub = SecretStoreHealthsStub(channel) 7326 7327 def list(self, filter, *args, timeout=None): 7328 ''' 7329 List reports the health status of node to secret store pairs. 7330 ''' 7331 deadline = None if timeout is None else time.time() + timeout 7332 req = SecretStoreHealthListRequest() 7333 req.meta.CopyFrom(ListRequestMetadata()) 7334 if self.parent.page_limit > 0: 7335 req.meta.limit = self.parent.page_limit 7336 if self.parent.snapshot_datetime is not None: 7337 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7338 7339 req.filter = plumbing.quote_filter_args(filter, *args) 7340 7341 def generator(svc, req): 7342 tries = 0 7343 while True: 7344 t = None if deadline is None else deadline - time.time() 7345 try: 7346 plumbing_response = svc.stub.List( 7347 req, 7348 metadata=svc.parent.get_metadata( 7349 'SecretStoreHealths.List', req), 7350 timeout=t) 7351 except Exception as e: 7352 if self.parent.shouldRetry(tries, e, deadline): 7353 tries += 1 7354 time.sleep( 7355 self.parent.exponentialBackoff(tries, deadline)) 7356 continue 7357 raise plumbing.convert_error_to_porcelain(e) from e 7358 tries = 0 7359 for plumbing_item in plumbing_response.secret_store_healths: 7360 yield plumbing.convert_secret_store_health_to_porcelain( 7361 plumbing_item) 7362 if plumbing_response.meta.next_cursor == '': 7363 break 7364 req.meta.cursor = plumbing_response.meta.next_cursor 7365 7366 return generator(self, req) 7367 7368 def healthcheck(self, secret_store_id, timeout=None): 7369 ''' 7370 Healthcheck triggers a remote healthcheck request for a secret store. It may take minutes 7371 to propagate across a large network of Nodes. The call will return immediately, and the 7372 updated health of the Secret Store can be retrieved via List. 7373 ''' 7374 deadline = None if timeout is None else time.time() + timeout 7375 req = SecretStoreHealthcheckRequest() 7376 7377 req.secret_store_id = (secret_store_id) 7378 tries = 0 7379 plumbing_response = None 7380 while True: 7381 t = None if deadline is None else deadline - time.time() 7382 try: 7383 plumbing_response = self.stub.Healthcheck( 7384 req, 7385 metadata=self.parent.get_metadata( 7386 'SecretStoreHealths.Healthcheck', req), 7387 timeout=t) 7388 except Exception as e: 7389 if self.parent.shouldRetry(tries, e, deadline): 7390 tries += 1 7391 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7392 continue 7393 raise plumbing.convert_error_to_porcelain(e) from e 7394 break 7395 7396 resp = models.SecretStoreHealthcheckResponse() 7397 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7398 plumbing_response.rate_limit) 7399 return resp
SecretStoreHealths exposes health states for secret stores.
See strongdm.models.SecretStoreHealth.
def
list(self, filter, *args, timeout=None)
7327 def list(self, filter, *args, timeout=None): 7328 ''' 7329 List reports the health status of node to secret store pairs. 7330 ''' 7331 deadline = None if timeout is None else time.time() + timeout 7332 req = SecretStoreHealthListRequest() 7333 req.meta.CopyFrom(ListRequestMetadata()) 7334 if self.parent.page_limit > 0: 7335 req.meta.limit = self.parent.page_limit 7336 if self.parent.snapshot_datetime is not None: 7337 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7338 7339 req.filter = plumbing.quote_filter_args(filter, *args) 7340 7341 def generator(svc, req): 7342 tries = 0 7343 while True: 7344 t = None if deadline is None else deadline - time.time() 7345 try: 7346 plumbing_response = svc.stub.List( 7347 req, 7348 metadata=svc.parent.get_metadata( 7349 'SecretStoreHealths.List', req), 7350 timeout=t) 7351 except Exception as e: 7352 if self.parent.shouldRetry(tries, e, deadline): 7353 tries += 1 7354 time.sleep( 7355 self.parent.exponentialBackoff(tries, deadline)) 7356 continue 7357 raise plumbing.convert_error_to_porcelain(e) from e 7358 tries = 0 7359 for plumbing_item in plumbing_response.secret_store_healths: 7360 yield plumbing.convert_secret_store_health_to_porcelain( 7361 plumbing_item) 7362 if plumbing_response.meta.next_cursor == '': 7363 break 7364 req.meta.cursor = plumbing_response.meta.next_cursor 7365 7366 return generator(self, req)
List reports the health status of node to secret store pairs.
def
healthcheck(self, secret_store_id, timeout=None)
7368 def healthcheck(self, secret_store_id, timeout=None): 7369 ''' 7370 Healthcheck triggers a remote healthcheck request for a secret store. It may take minutes 7371 to propagate across a large network of Nodes. The call will return immediately, and the 7372 updated health of the Secret Store can be retrieved via List. 7373 ''' 7374 deadline = None if timeout is None else time.time() + timeout 7375 req = SecretStoreHealthcheckRequest() 7376 7377 req.secret_store_id = (secret_store_id) 7378 tries = 0 7379 plumbing_response = None 7380 while True: 7381 t = None if deadline is None else deadline - time.time() 7382 try: 7383 plumbing_response = self.stub.Healthcheck( 7384 req, 7385 metadata=self.parent.get_metadata( 7386 'SecretStoreHealths.Healthcheck', req), 7387 timeout=t) 7388 except Exception as e: 7389 if self.parent.shouldRetry(tries, e, deadline): 7390 tries += 1 7391 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7392 continue 7393 raise plumbing.convert_error_to_porcelain(e) from e 7394 break 7395 7396 resp = models.SecretStoreHealthcheckResponse() 7397 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7398 plumbing_response.rate_limit) 7399 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:
7402class SecretStoresHistory: 7403 ''' 7404 SecretStoresHistory records all changes to the state of a SecretStore. 7405 See `strongdm.models.SecretStoreHistory`. 7406 ''' 7407 def __init__(self, channel, client): 7408 self.parent = client 7409 self.stub = SecretStoresHistoryStub(channel) 7410 7411 def list(self, filter, *args, timeout=None): 7412 ''' 7413 List gets a list of SecretStoreHistory records matching a given set of criteria. 7414 ''' 7415 deadline = None if timeout is None else time.time() + timeout 7416 req = SecretStoreHistoryListRequest() 7417 req.meta.CopyFrom(ListRequestMetadata()) 7418 if self.parent.page_limit > 0: 7419 req.meta.limit = self.parent.page_limit 7420 if self.parent.snapshot_datetime is not None: 7421 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7422 7423 req.filter = plumbing.quote_filter_args(filter, *args) 7424 7425 def generator(svc, req): 7426 tries = 0 7427 while True: 7428 t = None if deadline is None else deadline - time.time() 7429 try: 7430 plumbing_response = svc.stub.List( 7431 req, 7432 metadata=svc.parent.get_metadata( 7433 'SecretStoresHistory.List', req), 7434 timeout=t) 7435 except Exception as e: 7436 if self.parent.shouldRetry(tries, e, deadline): 7437 tries += 1 7438 time.sleep( 7439 self.parent.exponentialBackoff(tries, deadline)) 7440 continue 7441 raise plumbing.convert_error_to_porcelain(e) from e 7442 tries = 0 7443 for plumbing_item in plumbing_response.history: 7444 yield plumbing.convert_secret_store_history_to_porcelain( 7445 plumbing_item) 7446 if plumbing_response.meta.next_cursor == '': 7447 break 7448 req.meta.cursor = plumbing_response.meta.next_cursor 7449 7450 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)
7411 def list(self, filter, *args, timeout=None): 7412 ''' 7413 List gets a list of SecretStoreHistory records matching a given set of criteria. 7414 ''' 7415 deadline = None if timeout is None else time.time() + timeout 7416 req = SecretStoreHistoryListRequest() 7417 req.meta.CopyFrom(ListRequestMetadata()) 7418 if self.parent.page_limit > 0: 7419 req.meta.limit = self.parent.page_limit 7420 if self.parent.snapshot_datetime is not None: 7421 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7422 7423 req.filter = plumbing.quote_filter_args(filter, *args) 7424 7425 def generator(svc, req): 7426 tries = 0 7427 while True: 7428 t = None if deadline is None else deadline - time.time() 7429 try: 7430 plumbing_response = svc.stub.List( 7431 req, 7432 metadata=svc.parent.get_metadata( 7433 'SecretStoresHistory.List', req), 7434 timeout=t) 7435 except Exception as e: 7436 if self.parent.shouldRetry(tries, e, deadline): 7437 tries += 1 7438 time.sleep( 7439 self.parent.exponentialBackoff(tries, deadline)) 7440 continue 7441 raise plumbing.convert_error_to_porcelain(e) from e 7442 tries = 0 7443 for plumbing_item in plumbing_response.history: 7444 yield plumbing.convert_secret_store_history_to_porcelain( 7445 plumbing_item) 7446 if plumbing_response.meta.next_cursor == '': 7447 break 7448 req.meta.cursor = plumbing_response.meta.next_cursor 7449 7450 return generator(self, req)
List gets a list of SecretStoreHistory records matching a given set of criteria.
class
WorkflowApprovers:
7453class WorkflowApprovers: 7454 ''' 7455 WorkflowApprovers is an account or a role with the ability to approve requests bound to a workflow. 7456 See `strongdm.models.WorkflowApprover`. 7457 ''' 7458 def __init__(self, channel, client): 7459 self.parent = client 7460 self.stub = WorkflowApproversStub(channel) 7461 7462 def create(self, workflow_approver, timeout=None): 7463 ''' 7464 Create creates a new workflow approver 7465 ''' 7466 deadline = None if timeout is None else time.time() + timeout 7467 req = WorkflowApproversCreateRequest() 7468 7469 if workflow_approver is not None: 7470 req.workflow_approver.CopyFrom( 7471 plumbing.convert_workflow_approver_to_plumbing( 7472 workflow_approver)) 7473 tries = 0 7474 plumbing_response = None 7475 while True: 7476 t = None if deadline is None else deadline - time.time() 7477 try: 7478 plumbing_response = self.stub.Create( 7479 req, 7480 metadata=self.parent.get_metadata( 7481 'WorkflowApprovers.Create', req), 7482 timeout=t) 7483 except Exception as e: 7484 if self.parent.shouldRetry(tries, e, deadline): 7485 tries += 1 7486 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7487 continue 7488 raise plumbing.convert_error_to_porcelain(e) from e 7489 break 7490 7491 resp = models.WorkflowApproversCreateResponse() 7492 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7493 plumbing_response.rate_limit) 7494 resp.workflow_approver = plumbing.convert_workflow_approver_to_porcelain( 7495 plumbing_response.workflow_approver) 7496 return resp 7497 7498 def get(self, id, timeout=None): 7499 ''' 7500 Get reads one workflow approver by ID. 7501 ''' 7502 deadline = None if timeout is None else time.time() + timeout 7503 req = WorkflowApproverGetRequest() 7504 if self.parent.snapshot_datetime is not None: 7505 req.meta.CopyFrom(GetRequestMetadata()) 7506 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7507 7508 req.id = (id) 7509 tries = 0 7510 plumbing_response = None 7511 while True: 7512 t = None if deadline is None else deadline - time.time() 7513 try: 7514 plumbing_response = self.stub.Get( 7515 req, 7516 metadata=self.parent.get_metadata('WorkflowApprovers.Get', 7517 req), 7518 timeout=t) 7519 except Exception as e: 7520 if self.parent.shouldRetry(tries, e, deadline): 7521 tries += 1 7522 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7523 continue 7524 raise plumbing.convert_error_to_porcelain(e) from e 7525 break 7526 7527 resp = models.WorkflowApproverGetResponse() 7528 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 7529 plumbing_response.meta) 7530 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7531 plumbing_response.rate_limit) 7532 resp.workflow_approver = plumbing.convert_workflow_approver_to_porcelain( 7533 plumbing_response.workflow_approver) 7534 return resp 7535 7536 def delete(self, id, timeout=None): 7537 ''' 7538 Delete deletes a workflow approver 7539 ''' 7540 deadline = None if timeout is None else time.time() + timeout 7541 req = WorkflowApproversDeleteRequest() 7542 7543 req.id = (id) 7544 tries = 0 7545 plumbing_response = None 7546 while True: 7547 t = None if deadline is None else deadline - time.time() 7548 try: 7549 plumbing_response = self.stub.Delete( 7550 req, 7551 metadata=self.parent.get_metadata( 7552 'WorkflowApprovers.Delete', req), 7553 timeout=t) 7554 except Exception as e: 7555 if self.parent.shouldRetry(tries, e, deadline): 7556 tries += 1 7557 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7558 continue 7559 raise plumbing.convert_error_to_porcelain(e) from e 7560 break 7561 7562 resp = models.WorkflowApproversDeleteResponse() 7563 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7564 plumbing_response.rate_limit) 7565 return resp 7566 7567 def list(self, filter, *args, timeout=None): 7568 ''' 7569 Lists existing workflow approvers. 7570 ''' 7571 deadline = None if timeout is None else time.time() + timeout 7572 req = WorkflowApproversListRequest() 7573 req.meta.CopyFrom(ListRequestMetadata()) 7574 if self.parent.page_limit > 0: 7575 req.meta.limit = self.parent.page_limit 7576 if self.parent.snapshot_datetime is not None: 7577 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7578 7579 req.filter = plumbing.quote_filter_args(filter, *args) 7580 7581 def generator(svc, req): 7582 tries = 0 7583 while True: 7584 t = None if deadline is None else deadline - time.time() 7585 try: 7586 plumbing_response = svc.stub.List( 7587 req, 7588 metadata=svc.parent.get_metadata( 7589 'WorkflowApprovers.List', req), 7590 timeout=t) 7591 except Exception as e: 7592 if self.parent.shouldRetry(tries, e, deadline): 7593 tries += 1 7594 time.sleep( 7595 self.parent.exponentialBackoff(tries, deadline)) 7596 continue 7597 raise plumbing.convert_error_to_porcelain(e) from e 7598 tries = 0 7599 for plumbing_item in plumbing_response.workflow_approvers: 7600 yield plumbing.convert_workflow_approver_to_porcelain( 7601 plumbing_item) 7602 if plumbing_response.meta.next_cursor == '': 7603 break 7604 req.meta.cursor = plumbing_response.meta.next_cursor 7605 7606 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)
7462 def create(self, workflow_approver, timeout=None): 7463 ''' 7464 Create creates a new workflow approver 7465 ''' 7466 deadline = None if timeout is None else time.time() + timeout 7467 req = WorkflowApproversCreateRequest() 7468 7469 if workflow_approver is not None: 7470 req.workflow_approver.CopyFrom( 7471 plumbing.convert_workflow_approver_to_plumbing( 7472 workflow_approver)) 7473 tries = 0 7474 plumbing_response = None 7475 while True: 7476 t = None if deadline is None else deadline - time.time() 7477 try: 7478 plumbing_response = self.stub.Create( 7479 req, 7480 metadata=self.parent.get_metadata( 7481 'WorkflowApprovers.Create', req), 7482 timeout=t) 7483 except Exception as e: 7484 if self.parent.shouldRetry(tries, e, deadline): 7485 tries += 1 7486 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7487 continue 7488 raise plumbing.convert_error_to_porcelain(e) from e 7489 break 7490 7491 resp = models.WorkflowApproversCreateResponse() 7492 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7493 plumbing_response.rate_limit) 7494 resp.workflow_approver = plumbing.convert_workflow_approver_to_porcelain( 7495 plumbing_response.workflow_approver) 7496 return resp
Create creates a new workflow approver
def
get(self, id, timeout=None)
7498 def get(self, id, timeout=None): 7499 ''' 7500 Get reads one workflow approver by ID. 7501 ''' 7502 deadline = None if timeout is None else time.time() + timeout 7503 req = WorkflowApproverGetRequest() 7504 if self.parent.snapshot_datetime is not None: 7505 req.meta.CopyFrom(GetRequestMetadata()) 7506 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7507 7508 req.id = (id) 7509 tries = 0 7510 plumbing_response = None 7511 while True: 7512 t = None if deadline is None else deadline - time.time() 7513 try: 7514 plumbing_response = self.stub.Get( 7515 req, 7516 metadata=self.parent.get_metadata('WorkflowApprovers.Get', 7517 req), 7518 timeout=t) 7519 except Exception as e: 7520 if self.parent.shouldRetry(tries, e, deadline): 7521 tries += 1 7522 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7523 continue 7524 raise plumbing.convert_error_to_porcelain(e) from e 7525 break 7526 7527 resp = models.WorkflowApproverGetResponse() 7528 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 7529 plumbing_response.meta) 7530 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7531 plumbing_response.rate_limit) 7532 resp.workflow_approver = plumbing.convert_workflow_approver_to_porcelain( 7533 plumbing_response.workflow_approver) 7534 return resp
Get reads one workflow approver by ID.
def
delete(self, id, timeout=None)
7536 def delete(self, id, timeout=None): 7537 ''' 7538 Delete deletes a workflow approver 7539 ''' 7540 deadline = None if timeout is None else time.time() + timeout 7541 req = WorkflowApproversDeleteRequest() 7542 7543 req.id = (id) 7544 tries = 0 7545 plumbing_response = None 7546 while True: 7547 t = None if deadline is None else deadline - time.time() 7548 try: 7549 plumbing_response = self.stub.Delete( 7550 req, 7551 metadata=self.parent.get_metadata( 7552 'WorkflowApprovers.Delete', req), 7553 timeout=t) 7554 except Exception as e: 7555 if self.parent.shouldRetry(tries, e, deadline): 7556 tries += 1 7557 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7558 continue 7559 raise plumbing.convert_error_to_porcelain(e) from e 7560 break 7561 7562 resp = models.WorkflowApproversDeleteResponse() 7563 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7564 plumbing_response.rate_limit) 7565 return resp
Delete deletes a workflow approver
def
list(self, filter, *args, timeout=None)
7567 def list(self, filter, *args, timeout=None): 7568 ''' 7569 Lists existing workflow approvers. 7570 ''' 7571 deadline = None if timeout is None else time.time() + timeout 7572 req = WorkflowApproversListRequest() 7573 req.meta.CopyFrom(ListRequestMetadata()) 7574 if self.parent.page_limit > 0: 7575 req.meta.limit = self.parent.page_limit 7576 if self.parent.snapshot_datetime is not None: 7577 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7578 7579 req.filter = plumbing.quote_filter_args(filter, *args) 7580 7581 def generator(svc, req): 7582 tries = 0 7583 while True: 7584 t = None if deadline is None else deadline - time.time() 7585 try: 7586 plumbing_response = svc.stub.List( 7587 req, 7588 metadata=svc.parent.get_metadata( 7589 'WorkflowApprovers.List', req), 7590 timeout=t) 7591 except Exception as e: 7592 if self.parent.shouldRetry(tries, e, deadline): 7593 tries += 1 7594 time.sleep( 7595 self.parent.exponentialBackoff(tries, deadline)) 7596 continue 7597 raise plumbing.convert_error_to_porcelain(e) from e 7598 tries = 0 7599 for plumbing_item in plumbing_response.workflow_approvers: 7600 yield plumbing.convert_workflow_approver_to_porcelain( 7601 plumbing_item) 7602 if plumbing_response.meta.next_cursor == '': 7603 break 7604 req.meta.cursor = plumbing_response.meta.next_cursor 7605 7606 return generator(self, req)
Lists existing workflow approvers.
class
SnapshotWorkflowApprovers:
7609class SnapshotWorkflowApprovers: 7610 ''' 7611 SnapshotWorkflowApprovers exposes the read only methods of the WorkflowApprovers 7612 service for historical queries. 7613 ''' 7614 def __init__(self, workflow_approvers): 7615 self.workflow_approvers = workflow_approvers 7616 7617 def get(self, id, timeout=None): 7618 ''' 7619 Get reads one workflow approver by ID. 7620 ''' 7621 return self.workflow_approvers.get(id, timeout=timeout) 7622 7623 def list(self, filter, *args, timeout=None): 7624 ''' 7625 Lists existing workflow approvers. 7626 ''' 7627 return self.workflow_approvers.list(filter, *args, timeout=timeout)
SnapshotWorkflowApprovers exposes the read only methods of the WorkflowApprovers service for historical queries.
class
WorkflowApproversHistory:
7630class WorkflowApproversHistory: 7631 ''' 7632 WorkflowApproversHistory provides records of all changes to the state of a WorkflowApprover. 7633 See `strongdm.models.WorkflowApproverHistory`. 7634 ''' 7635 def __init__(self, channel, client): 7636 self.parent = client 7637 self.stub = WorkflowApproversHistoryStub(channel) 7638 7639 def list(self, filter, *args, timeout=None): 7640 ''' 7641 List gets a list of WorkflowApproversHistory records matching a given set of criteria. 7642 ''' 7643 deadline = None if timeout is None else time.time() + timeout 7644 req = WorkflowApproversHistoryListRequest() 7645 req.meta.CopyFrom(ListRequestMetadata()) 7646 if self.parent.page_limit > 0: 7647 req.meta.limit = self.parent.page_limit 7648 if self.parent.snapshot_datetime is not None: 7649 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7650 7651 req.filter = plumbing.quote_filter_args(filter, *args) 7652 7653 def generator(svc, req): 7654 tries = 0 7655 while True: 7656 t = None if deadline is None else deadline - time.time() 7657 try: 7658 plumbing_response = svc.stub.List( 7659 req, 7660 metadata=svc.parent.get_metadata( 7661 'WorkflowApproversHistory.List', req), 7662 timeout=t) 7663 except Exception as e: 7664 if self.parent.shouldRetry(tries, e, deadline): 7665 tries += 1 7666 time.sleep( 7667 self.parent.exponentialBackoff(tries, deadline)) 7668 continue 7669 raise plumbing.convert_error_to_porcelain(e) from e 7670 tries = 0 7671 for plumbing_item in plumbing_response.history: 7672 yield plumbing.convert_workflow_approver_history_to_porcelain( 7673 plumbing_item) 7674 if plumbing_response.meta.next_cursor == '': 7675 break 7676 req.meta.cursor = plumbing_response.meta.next_cursor 7677 7678 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)
7639 def list(self, filter, *args, timeout=None): 7640 ''' 7641 List gets a list of WorkflowApproversHistory records matching a given set of criteria. 7642 ''' 7643 deadline = None if timeout is None else time.time() + timeout 7644 req = WorkflowApproversHistoryListRequest() 7645 req.meta.CopyFrom(ListRequestMetadata()) 7646 if self.parent.page_limit > 0: 7647 req.meta.limit = self.parent.page_limit 7648 if self.parent.snapshot_datetime is not None: 7649 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7650 7651 req.filter = plumbing.quote_filter_args(filter, *args) 7652 7653 def generator(svc, req): 7654 tries = 0 7655 while True: 7656 t = None if deadline is None else deadline - time.time() 7657 try: 7658 plumbing_response = svc.stub.List( 7659 req, 7660 metadata=svc.parent.get_metadata( 7661 'WorkflowApproversHistory.List', req), 7662 timeout=t) 7663 except Exception as e: 7664 if self.parent.shouldRetry(tries, e, deadline): 7665 tries += 1 7666 time.sleep( 7667 self.parent.exponentialBackoff(tries, deadline)) 7668 continue 7669 raise plumbing.convert_error_to_porcelain(e) from e 7670 tries = 0 7671 for plumbing_item in plumbing_response.history: 7672 yield plumbing.convert_workflow_approver_history_to_porcelain( 7673 plumbing_item) 7674 if plumbing_response.meta.next_cursor == '': 7675 break 7676 req.meta.cursor = plumbing_response.meta.next_cursor 7677 7678 return generator(self, req)
List gets a list of WorkflowApproversHistory records matching a given set of criteria.
class
WorkflowRoles:
7681class WorkflowRoles: 7682 ''' 7683 WorkflowRole links a role to a workflow. The linked roles indicate which roles a user must be a part of 7684 to request access to a resource via the workflow. 7685 See `strongdm.models.WorkflowRole`. 7686 ''' 7687 def __init__(self, channel, client): 7688 self.parent = client 7689 self.stub = WorkflowRolesStub(channel) 7690 7691 def create(self, workflow_role, timeout=None): 7692 ''' 7693 Create creates a new workflow role 7694 ''' 7695 deadline = None if timeout is None else time.time() + timeout 7696 req = WorkflowRolesCreateRequest() 7697 7698 if workflow_role is not None: 7699 req.workflow_role.CopyFrom( 7700 plumbing.convert_workflow_role_to_plumbing(workflow_role)) 7701 tries = 0 7702 plumbing_response = None 7703 while True: 7704 t = None if deadline is None else deadline - time.time() 7705 try: 7706 plumbing_response = self.stub.Create( 7707 req, 7708 metadata=self.parent.get_metadata('WorkflowRoles.Create', 7709 req), 7710 timeout=t) 7711 except Exception as e: 7712 if self.parent.shouldRetry(tries, e, deadline): 7713 tries += 1 7714 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7715 continue 7716 raise plumbing.convert_error_to_porcelain(e) from e 7717 break 7718 7719 resp = models.WorkflowRolesCreateResponse() 7720 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7721 plumbing_response.rate_limit) 7722 resp.workflow_role = plumbing.convert_workflow_role_to_porcelain( 7723 plumbing_response.workflow_role) 7724 return resp 7725 7726 def get(self, id, timeout=None): 7727 ''' 7728 Get reads one workflow role by ID. 7729 ''' 7730 deadline = None if timeout is None else time.time() + timeout 7731 req = WorkflowRoleGetRequest() 7732 if self.parent.snapshot_datetime is not None: 7733 req.meta.CopyFrom(GetRequestMetadata()) 7734 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7735 7736 req.id = (id) 7737 tries = 0 7738 plumbing_response = None 7739 while True: 7740 t = None if deadline is None else deadline - time.time() 7741 try: 7742 plumbing_response = self.stub.Get( 7743 req, 7744 metadata=self.parent.get_metadata('WorkflowRoles.Get', 7745 req), 7746 timeout=t) 7747 except Exception as e: 7748 if self.parent.shouldRetry(tries, e, deadline): 7749 tries += 1 7750 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7751 continue 7752 raise plumbing.convert_error_to_porcelain(e) from e 7753 break 7754 7755 resp = models.WorkflowRoleGetResponse() 7756 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 7757 plumbing_response.meta) 7758 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7759 plumbing_response.rate_limit) 7760 resp.workflow_role = plumbing.convert_workflow_role_to_porcelain( 7761 plumbing_response.workflow_role) 7762 return resp 7763 7764 def delete(self, id, timeout=None): 7765 ''' 7766 Delete deletes a workflow role 7767 ''' 7768 deadline = None if timeout is None else time.time() + timeout 7769 req = WorkflowRolesDeleteRequest() 7770 7771 req.id = (id) 7772 tries = 0 7773 plumbing_response = None 7774 while True: 7775 t = None if deadline is None else deadline - time.time() 7776 try: 7777 plumbing_response = self.stub.Delete( 7778 req, 7779 metadata=self.parent.get_metadata('WorkflowRoles.Delete', 7780 req), 7781 timeout=t) 7782 except Exception as e: 7783 if self.parent.shouldRetry(tries, e, deadline): 7784 tries += 1 7785 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7786 continue 7787 raise plumbing.convert_error_to_porcelain(e) from e 7788 break 7789 7790 resp = models.WorkflowRolesDeleteResponse() 7791 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7792 plumbing_response.rate_limit) 7793 return resp 7794 7795 def list(self, filter, *args, timeout=None): 7796 ''' 7797 Lists existing workflow roles. 7798 ''' 7799 deadline = None if timeout is None else time.time() + timeout 7800 req = WorkflowRolesListRequest() 7801 req.meta.CopyFrom(ListRequestMetadata()) 7802 if self.parent.page_limit > 0: 7803 req.meta.limit = self.parent.page_limit 7804 if self.parent.snapshot_datetime is not None: 7805 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7806 7807 req.filter = plumbing.quote_filter_args(filter, *args) 7808 7809 def generator(svc, req): 7810 tries = 0 7811 while True: 7812 t = None if deadline is None else deadline - time.time() 7813 try: 7814 plumbing_response = svc.stub.List( 7815 req, 7816 metadata=svc.parent.get_metadata( 7817 'WorkflowRoles.List', req), 7818 timeout=t) 7819 except Exception as e: 7820 if self.parent.shouldRetry(tries, e, deadline): 7821 tries += 1 7822 time.sleep( 7823 self.parent.exponentialBackoff(tries, deadline)) 7824 continue 7825 raise plumbing.convert_error_to_porcelain(e) from e 7826 tries = 0 7827 for plumbing_item in plumbing_response.workflow_role: 7828 yield plumbing.convert_workflow_role_to_porcelain( 7829 plumbing_item) 7830 if plumbing_response.meta.next_cursor == '': 7831 break 7832 req.meta.cursor = plumbing_response.meta.next_cursor 7833 7834 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)
7691 def create(self, workflow_role, timeout=None): 7692 ''' 7693 Create creates a new workflow role 7694 ''' 7695 deadline = None if timeout is None else time.time() + timeout 7696 req = WorkflowRolesCreateRequest() 7697 7698 if workflow_role is not None: 7699 req.workflow_role.CopyFrom( 7700 plumbing.convert_workflow_role_to_plumbing(workflow_role)) 7701 tries = 0 7702 plumbing_response = None 7703 while True: 7704 t = None if deadline is None else deadline - time.time() 7705 try: 7706 plumbing_response = self.stub.Create( 7707 req, 7708 metadata=self.parent.get_metadata('WorkflowRoles.Create', 7709 req), 7710 timeout=t) 7711 except Exception as e: 7712 if self.parent.shouldRetry(tries, e, deadline): 7713 tries += 1 7714 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7715 continue 7716 raise plumbing.convert_error_to_porcelain(e) from e 7717 break 7718 7719 resp = models.WorkflowRolesCreateResponse() 7720 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7721 plumbing_response.rate_limit) 7722 resp.workflow_role = plumbing.convert_workflow_role_to_porcelain( 7723 plumbing_response.workflow_role) 7724 return resp
Create creates a new workflow role
def
get(self, id, timeout=None)
7726 def get(self, id, timeout=None): 7727 ''' 7728 Get reads one workflow role by ID. 7729 ''' 7730 deadline = None if timeout is None else time.time() + timeout 7731 req = WorkflowRoleGetRequest() 7732 if self.parent.snapshot_datetime is not None: 7733 req.meta.CopyFrom(GetRequestMetadata()) 7734 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7735 7736 req.id = (id) 7737 tries = 0 7738 plumbing_response = None 7739 while True: 7740 t = None if deadline is None else deadline - time.time() 7741 try: 7742 plumbing_response = self.stub.Get( 7743 req, 7744 metadata=self.parent.get_metadata('WorkflowRoles.Get', 7745 req), 7746 timeout=t) 7747 except Exception as e: 7748 if self.parent.shouldRetry(tries, e, deadline): 7749 tries += 1 7750 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7751 continue 7752 raise plumbing.convert_error_to_porcelain(e) from e 7753 break 7754 7755 resp = models.WorkflowRoleGetResponse() 7756 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 7757 plumbing_response.meta) 7758 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7759 plumbing_response.rate_limit) 7760 resp.workflow_role = plumbing.convert_workflow_role_to_porcelain( 7761 plumbing_response.workflow_role) 7762 return resp
Get reads one workflow role by ID.
def
delete(self, id, timeout=None)
7764 def delete(self, id, timeout=None): 7765 ''' 7766 Delete deletes a workflow role 7767 ''' 7768 deadline = None if timeout is None else time.time() + timeout 7769 req = WorkflowRolesDeleteRequest() 7770 7771 req.id = (id) 7772 tries = 0 7773 plumbing_response = None 7774 while True: 7775 t = None if deadline is None else deadline - time.time() 7776 try: 7777 plumbing_response = self.stub.Delete( 7778 req, 7779 metadata=self.parent.get_metadata('WorkflowRoles.Delete', 7780 req), 7781 timeout=t) 7782 except Exception as e: 7783 if self.parent.shouldRetry(tries, e, deadline): 7784 tries += 1 7785 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7786 continue 7787 raise plumbing.convert_error_to_porcelain(e) from e 7788 break 7789 7790 resp = models.WorkflowRolesDeleteResponse() 7791 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7792 plumbing_response.rate_limit) 7793 return resp
Delete deletes a workflow role
def
list(self, filter, *args, timeout=None)
7795 def list(self, filter, *args, timeout=None): 7796 ''' 7797 Lists existing workflow roles. 7798 ''' 7799 deadline = None if timeout is None else time.time() + timeout 7800 req = WorkflowRolesListRequest() 7801 req.meta.CopyFrom(ListRequestMetadata()) 7802 if self.parent.page_limit > 0: 7803 req.meta.limit = self.parent.page_limit 7804 if self.parent.snapshot_datetime is not None: 7805 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7806 7807 req.filter = plumbing.quote_filter_args(filter, *args) 7808 7809 def generator(svc, req): 7810 tries = 0 7811 while True: 7812 t = None if deadline is None else deadline - time.time() 7813 try: 7814 plumbing_response = svc.stub.List( 7815 req, 7816 metadata=svc.parent.get_metadata( 7817 'WorkflowRoles.List', req), 7818 timeout=t) 7819 except Exception as e: 7820 if self.parent.shouldRetry(tries, e, deadline): 7821 tries += 1 7822 time.sleep( 7823 self.parent.exponentialBackoff(tries, deadline)) 7824 continue 7825 raise plumbing.convert_error_to_porcelain(e) from e 7826 tries = 0 7827 for plumbing_item in plumbing_response.workflow_role: 7828 yield plumbing.convert_workflow_role_to_porcelain( 7829 plumbing_item) 7830 if plumbing_response.meta.next_cursor == '': 7831 break 7832 req.meta.cursor = plumbing_response.meta.next_cursor 7833 7834 return generator(self, req)
Lists existing workflow roles.
class
SnapshotWorkflowRoles:
7837class SnapshotWorkflowRoles: 7838 ''' 7839 SnapshotWorkflowRoles exposes the read only methods of the WorkflowRoles 7840 service for historical queries. 7841 ''' 7842 def __init__(self, workflow_roles): 7843 self.workflow_roles = workflow_roles 7844 7845 def get(self, id, timeout=None): 7846 ''' 7847 Get reads one workflow role by ID. 7848 ''' 7849 return self.workflow_roles.get(id, timeout=timeout) 7850 7851 def list(self, filter, *args, timeout=None): 7852 ''' 7853 Lists existing workflow roles. 7854 ''' 7855 return self.workflow_roles.list(filter, *args, timeout=timeout)
SnapshotWorkflowRoles exposes the read only methods of the WorkflowRoles service for historical queries.
class
WorkflowRolesHistory:
7858class WorkflowRolesHistory: 7859 ''' 7860 WorkflowRolesHistory provides records of all changes to the state of a WorkflowRole 7861 See `strongdm.models.WorkflowRoleHistory`. 7862 ''' 7863 def __init__(self, channel, client): 7864 self.parent = client 7865 self.stub = WorkflowRolesHistoryStub(channel) 7866 7867 def list(self, filter, *args, timeout=None): 7868 ''' 7869 List gets a list of WorkflowRolesHistory records matching a given set of criteria. 7870 ''' 7871 deadline = None if timeout is None else time.time() + timeout 7872 req = WorkflowRolesHistoryListRequest() 7873 req.meta.CopyFrom(ListRequestMetadata()) 7874 if self.parent.page_limit > 0: 7875 req.meta.limit = self.parent.page_limit 7876 if self.parent.snapshot_datetime is not None: 7877 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7878 7879 req.filter = plumbing.quote_filter_args(filter, *args) 7880 7881 def generator(svc, req): 7882 tries = 0 7883 while True: 7884 t = None if deadline is None else deadline - time.time() 7885 try: 7886 plumbing_response = svc.stub.List( 7887 req, 7888 metadata=svc.parent.get_metadata( 7889 'WorkflowRolesHistory.List', req), 7890 timeout=t) 7891 except Exception as e: 7892 if self.parent.shouldRetry(tries, e, deadline): 7893 tries += 1 7894 time.sleep( 7895 self.parent.exponentialBackoff(tries, deadline)) 7896 continue 7897 raise plumbing.convert_error_to_porcelain(e) from e 7898 tries = 0 7899 for plumbing_item in plumbing_response.history: 7900 yield plumbing.convert_workflow_role_history_to_porcelain( 7901 plumbing_item) 7902 if plumbing_response.meta.next_cursor == '': 7903 break 7904 req.meta.cursor = plumbing_response.meta.next_cursor 7905 7906 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)
7867 def list(self, filter, *args, timeout=None): 7868 ''' 7869 List gets a list of WorkflowRolesHistory records matching a given set of criteria. 7870 ''' 7871 deadline = None if timeout is None else time.time() + timeout 7872 req = WorkflowRolesHistoryListRequest() 7873 req.meta.CopyFrom(ListRequestMetadata()) 7874 if self.parent.page_limit > 0: 7875 req.meta.limit = self.parent.page_limit 7876 if self.parent.snapshot_datetime is not None: 7877 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7878 7879 req.filter = plumbing.quote_filter_args(filter, *args) 7880 7881 def generator(svc, req): 7882 tries = 0 7883 while True: 7884 t = None if deadline is None else deadline - time.time() 7885 try: 7886 plumbing_response = svc.stub.List( 7887 req, 7888 metadata=svc.parent.get_metadata( 7889 'WorkflowRolesHistory.List', req), 7890 timeout=t) 7891 except Exception as e: 7892 if self.parent.shouldRetry(tries, e, deadline): 7893 tries += 1 7894 time.sleep( 7895 self.parent.exponentialBackoff(tries, deadline)) 7896 continue 7897 raise plumbing.convert_error_to_porcelain(e) from e 7898 tries = 0 7899 for plumbing_item in plumbing_response.history: 7900 yield plumbing.convert_workflow_role_history_to_porcelain( 7901 plumbing_item) 7902 if plumbing_response.meta.next_cursor == '': 7903 break 7904 req.meta.cursor = plumbing_response.meta.next_cursor 7905 7906 return generator(self, req)
List gets a list of WorkflowRolesHistory records matching a given set of criteria.
class
Workflows:
7909class Workflows: 7910 ''' 7911 Workflows are the collection of rules that define the resources to which access can be requested, 7912 the users that can request that access, and the mechanism for approving those requests which can either 7913 be automatic approval or a set of users authorized to approve the requests. 7914 See `strongdm.models.Workflow`. 7915 ''' 7916 def __init__(self, channel, client): 7917 self.parent = client 7918 self.stub = WorkflowsStub(channel) 7919 7920 def create(self, workflow, timeout=None): 7921 ''' 7922 Create creates a new workflow and requires a name for the workflow. 7923 ''' 7924 deadline = None if timeout is None else time.time() + timeout 7925 req = WorkflowCreateRequest() 7926 7927 if workflow is not None: 7928 req.workflow.CopyFrom( 7929 plumbing.convert_workflow_to_plumbing(workflow)) 7930 tries = 0 7931 plumbing_response = None 7932 while True: 7933 t = None if deadline is None else deadline - time.time() 7934 try: 7935 plumbing_response = self.stub.Create( 7936 req, 7937 metadata=self.parent.get_metadata('Workflows.Create', req), 7938 timeout=t) 7939 except Exception as e: 7940 if self.parent.shouldRetry(tries, e, deadline): 7941 tries += 1 7942 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7943 continue 7944 raise plumbing.convert_error_to_porcelain(e) from e 7945 break 7946 7947 resp = models.WorkflowCreateResponse() 7948 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7949 plumbing_response.rate_limit) 7950 resp.workflow = plumbing.convert_workflow_to_porcelain( 7951 plumbing_response.workflow) 7952 return resp 7953 7954 def get(self, id, timeout=None): 7955 ''' 7956 Get reads one workflow by ID. 7957 ''' 7958 deadline = None if timeout is None else time.time() + timeout 7959 req = WorkflowGetRequest() 7960 if self.parent.snapshot_datetime is not None: 7961 req.meta.CopyFrom(GetRequestMetadata()) 7962 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7963 7964 req.id = (id) 7965 tries = 0 7966 plumbing_response = None 7967 while True: 7968 t = None if deadline is None else deadline - time.time() 7969 try: 7970 plumbing_response = self.stub.Get( 7971 req, 7972 metadata=self.parent.get_metadata('Workflows.Get', req), 7973 timeout=t) 7974 except Exception as e: 7975 if self.parent.shouldRetry(tries, e, deadline): 7976 tries += 1 7977 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7978 continue 7979 raise plumbing.convert_error_to_porcelain(e) from e 7980 break 7981 7982 resp = models.WorkflowGetResponse() 7983 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 7984 plumbing_response.meta) 7985 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7986 plumbing_response.rate_limit) 7987 resp.workflow = plumbing.convert_workflow_to_porcelain( 7988 plumbing_response.workflow) 7989 return resp 7990 7991 def delete(self, id, timeout=None): 7992 ''' 7993 Delete deletes an existing workflow. 7994 ''' 7995 deadline = None if timeout is None else time.time() + timeout 7996 req = WorkflowDeleteRequest() 7997 7998 req.id = (id) 7999 tries = 0 8000 plumbing_response = None 8001 while True: 8002 t = None if deadline is None else deadline - time.time() 8003 try: 8004 plumbing_response = self.stub.Delete( 8005 req, 8006 metadata=self.parent.get_metadata('Workflows.Delete', req), 8007 timeout=t) 8008 except Exception as e: 8009 if self.parent.shouldRetry(tries, e, deadline): 8010 tries += 1 8011 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8012 continue 8013 raise plumbing.convert_error_to_porcelain(e) from e 8014 break 8015 8016 resp = models.WorkflowDeleteResponse() 8017 resp.id = (plumbing_response.id) 8018 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8019 plumbing_response.rate_limit) 8020 return resp 8021 8022 def update(self, workflow, timeout=None): 8023 ''' 8024 Update updates an existing workflow. 8025 ''' 8026 deadline = None if timeout is None else time.time() + timeout 8027 req = WorkflowUpdateRequest() 8028 8029 if workflow is not None: 8030 req.workflow.CopyFrom( 8031 plumbing.convert_workflow_to_plumbing(workflow)) 8032 tries = 0 8033 plumbing_response = None 8034 while True: 8035 t = None if deadline is None else deadline - time.time() 8036 try: 8037 plumbing_response = self.stub.Update( 8038 req, 8039 metadata=self.parent.get_metadata('Workflows.Update', req), 8040 timeout=t) 8041 except Exception as e: 8042 if self.parent.shouldRetry(tries, e, deadline): 8043 tries += 1 8044 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8045 continue 8046 raise plumbing.convert_error_to_porcelain(e) from e 8047 break 8048 8049 resp = models.WorkflowUpdateResponse() 8050 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8051 plumbing_response.rate_limit) 8052 resp.workflow = plumbing.convert_workflow_to_porcelain( 8053 plumbing_response.workflow) 8054 return resp 8055 8056 def list(self, filter, *args, timeout=None): 8057 ''' 8058 Lists existing workflows. 8059 ''' 8060 deadline = None if timeout is None else time.time() + timeout 8061 req = WorkflowListRequest() 8062 req.meta.CopyFrom(ListRequestMetadata()) 8063 if self.parent.page_limit > 0: 8064 req.meta.limit = self.parent.page_limit 8065 if self.parent.snapshot_datetime is not None: 8066 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8067 8068 req.filter = plumbing.quote_filter_args(filter, *args) 8069 8070 def generator(svc, req): 8071 tries = 0 8072 while True: 8073 t = None if deadline is None else deadline - time.time() 8074 try: 8075 plumbing_response = svc.stub.List( 8076 req, 8077 metadata=svc.parent.get_metadata( 8078 'Workflows.List', req), 8079 timeout=t) 8080 except Exception as e: 8081 if self.parent.shouldRetry(tries, e, deadline): 8082 tries += 1 8083 time.sleep( 8084 self.parent.exponentialBackoff(tries, deadline)) 8085 continue 8086 raise plumbing.convert_error_to_porcelain(e) from e 8087 tries = 0 8088 for plumbing_item in plumbing_response.workflows: 8089 yield plumbing.convert_workflow_to_porcelain(plumbing_item) 8090 if plumbing_response.meta.next_cursor == '': 8091 break 8092 req.meta.cursor = plumbing_response.meta.next_cursor 8093 8094 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)
7920 def create(self, workflow, timeout=None): 7921 ''' 7922 Create creates a new workflow and requires a name for the workflow. 7923 ''' 7924 deadline = None if timeout is None else time.time() + timeout 7925 req = WorkflowCreateRequest() 7926 7927 if workflow is not None: 7928 req.workflow.CopyFrom( 7929 plumbing.convert_workflow_to_plumbing(workflow)) 7930 tries = 0 7931 plumbing_response = None 7932 while True: 7933 t = None if deadline is None else deadline - time.time() 7934 try: 7935 plumbing_response = self.stub.Create( 7936 req, 7937 metadata=self.parent.get_metadata('Workflows.Create', req), 7938 timeout=t) 7939 except Exception as e: 7940 if self.parent.shouldRetry(tries, e, deadline): 7941 tries += 1 7942 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7943 continue 7944 raise plumbing.convert_error_to_porcelain(e) from e 7945 break 7946 7947 resp = models.WorkflowCreateResponse() 7948 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7949 plumbing_response.rate_limit) 7950 resp.workflow = plumbing.convert_workflow_to_porcelain( 7951 plumbing_response.workflow) 7952 return resp
Create creates a new workflow and requires a name for the workflow.
def
get(self, id, timeout=None)
7954 def get(self, id, timeout=None): 7955 ''' 7956 Get reads one workflow by ID. 7957 ''' 7958 deadline = None if timeout is None else time.time() + timeout 7959 req = WorkflowGetRequest() 7960 if self.parent.snapshot_datetime is not None: 7961 req.meta.CopyFrom(GetRequestMetadata()) 7962 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 7963 7964 req.id = (id) 7965 tries = 0 7966 plumbing_response = None 7967 while True: 7968 t = None if deadline is None else deadline - time.time() 7969 try: 7970 plumbing_response = self.stub.Get( 7971 req, 7972 metadata=self.parent.get_metadata('Workflows.Get', req), 7973 timeout=t) 7974 except Exception as e: 7975 if self.parent.shouldRetry(tries, e, deadline): 7976 tries += 1 7977 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 7978 continue 7979 raise plumbing.convert_error_to_porcelain(e) from e 7980 break 7981 7982 resp = models.WorkflowGetResponse() 7983 resp.meta = plumbing.convert_get_response_metadata_to_porcelain( 7984 plumbing_response.meta) 7985 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 7986 plumbing_response.rate_limit) 7987 resp.workflow = plumbing.convert_workflow_to_porcelain( 7988 plumbing_response.workflow) 7989 return resp
Get reads one workflow by ID.
def
delete(self, id, timeout=None)
7991 def delete(self, id, timeout=None): 7992 ''' 7993 Delete deletes an existing workflow. 7994 ''' 7995 deadline = None if timeout is None else time.time() + timeout 7996 req = WorkflowDeleteRequest() 7997 7998 req.id = (id) 7999 tries = 0 8000 plumbing_response = None 8001 while True: 8002 t = None if deadline is None else deadline - time.time() 8003 try: 8004 plumbing_response = self.stub.Delete( 8005 req, 8006 metadata=self.parent.get_metadata('Workflows.Delete', req), 8007 timeout=t) 8008 except Exception as e: 8009 if self.parent.shouldRetry(tries, e, deadline): 8010 tries += 1 8011 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8012 continue 8013 raise plumbing.convert_error_to_porcelain(e) from e 8014 break 8015 8016 resp = models.WorkflowDeleteResponse() 8017 resp.id = (plumbing_response.id) 8018 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8019 plumbing_response.rate_limit) 8020 return resp
Delete deletes an existing workflow.
def
update(self, workflow, timeout=None)
8022 def update(self, workflow, timeout=None): 8023 ''' 8024 Update updates an existing workflow. 8025 ''' 8026 deadline = None if timeout is None else time.time() + timeout 8027 req = WorkflowUpdateRequest() 8028 8029 if workflow is not None: 8030 req.workflow.CopyFrom( 8031 plumbing.convert_workflow_to_plumbing(workflow)) 8032 tries = 0 8033 plumbing_response = None 8034 while True: 8035 t = None if deadline is None else deadline - time.time() 8036 try: 8037 plumbing_response = self.stub.Update( 8038 req, 8039 metadata=self.parent.get_metadata('Workflows.Update', req), 8040 timeout=t) 8041 except Exception as e: 8042 if self.parent.shouldRetry(tries, e, deadline): 8043 tries += 1 8044 time.sleep(self.parent.exponentialBackoff(tries, deadline)) 8045 continue 8046 raise plumbing.convert_error_to_porcelain(e) from e 8047 break 8048 8049 resp = models.WorkflowUpdateResponse() 8050 resp.rate_limit = plumbing.convert_rate_limit_metadata_to_porcelain( 8051 plumbing_response.rate_limit) 8052 resp.workflow = plumbing.convert_workflow_to_porcelain( 8053 plumbing_response.workflow) 8054 return resp
Update updates an existing workflow.
def
list(self, filter, *args, timeout=None)
8056 def list(self, filter, *args, timeout=None): 8057 ''' 8058 Lists existing workflows. 8059 ''' 8060 deadline = None if timeout is None else time.time() + timeout 8061 req = WorkflowListRequest() 8062 req.meta.CopyFrom(ListRequestMetadata()) 8063 if self.parent.page_limit > 0: 8064 req.meta.limit = self.parent.page_limit 8065 if self.parent.snapshot_datetime is not None: 8066 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8067 8068 req.filter = plumbing.quote_filter_args(filter, *args) 8069 8070 def generator(svc, req): 8071 tries = 0 8072 while True: 8073 t = None if deadline is None else deadline - time.time() 8074 try: 8075 plumbing_response = svc.stub.List( 8076 req, 8077 metadata=svc.parent.get_metadata( 8078 'Workflows.List', req), 8079 timeout=t) 8080 except Exception as e: 8081 if self.parent.shouldRetry(tries, e, deadline): 8082 tries += 1 8083 time.sleep( 8084 self.parent.exponentialBackoff(tries, deadline)) 8085 continue 8086 raise plumbing.convert_error_to_porcelain(e) from e 8087 tries = 0 8088 for plumbing_item in plumbing_response.workflows: 8089 yield plumbing.convert_workflow_to_porcelain(plumbing_item) 8090 if plumbing_response.meta.next_cursor == '': 8091 break 8092 req.meta.cursor = plumbing_response.meta.next_cursor 8093 8094 return generator(self, req)
Lists existing workflows.
class
SnapshotWorkflows:
8097class SnapshotWorkflows: 8098 ''' 8099 SnapshotWorkflows exposes the read only methods of the Workflows 8100 service for historical queries. 8101 ''' 8102 def __init__(self, workflows): 8103 self.workflows = workflows 8104 8105 def get(self, id, timeout=None): 8106 ''' 8107 Get reads one workflow by ID. 8108 ''' 8109 return self.workflows.get(id, timeout=timeout) 8110 8111 def list(self, filter, *args, timeout=None): 8112 ''' 8113 Lists existing workflows. 8114 ''' 8115 return self.workflows.list(filter, *args, timeout=timeout)
SnapshotWorkflows exposes the read only methods of the Workflows service for historical queries.
class
WorkflowsHistory:
8118class WorkflowsHistory: 8119 ''' 8120 WorkflowsHistory provides records of all changes to the state of a Workflow. 8121 See `strongdm.models.WorkflowHistory`. 8122 ''' 8123 def __init__(self, channel, client): 8124 self.parent = client 8125 self.stub = WorkflowsHistoryStub(channel) 8126 8127 def list(self, filter, *args, timeout=None): 8128 ''' 8129 List gets a list of WorkflowHistory records matching a given set of criteria. 8130 ''' 8131 deadline = None if timeout is None else time.time() + timeout 8132 req = WorkflowHistoryListRequest() 8133 req.meta.CopyFrom(ListRequestMetadata()) 8134 if self.parent.page_limit > 0: 8135 req.meta.limit = self.parent.page_limit 8136 if self.parent.snapshot_datetime is not None: 8137 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8138 8139 req.filter = plumbing.quote_filter_args(filter, *args) 8140 8141 def generator(svc, req): 8142 tries = 0 8143 while True: 8144 t = None if deadline is None else deadline - time.time() 8145 try: 8146 plumbing_response = svc.stub.List( 8147 req, 8148 metadata=svc.parent.get_metadata( 8149 'WorkflowsHistory.List', req), 8150 timeout=t) 8151 except Exception as e: 8152 if self.parent.shouldRetry(tries, e, deadline): 8153 tries += 1 8154 time.sleep( 8155 self.parent.exponentialBackoff(tries, deadline)) 8156 continue 8157 raise plumbing.convert_error_to_porcelain(e) from e 8158 tries = 0 8159 for plumbing_item in plumbing_response.history: 8160 yield plumbing.convert_workflow_history_to_porcelain( 8161 plumbing_item) 8162 if plumbing_response.meta.next_cursor == '': 8163 break 8164 req.meta.cursor = plumbing_response.meta.next_cursor 8165 8166 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)
8127 def list(self, filter, *args, timeout=None): 8128 ''' 8129 List gets a list of WorkflowHistory records matching a given set of criteria. 8130 ''' 8131 deadline = None if timeout is None else time.time() + timeout 8132 req = WorkflowHistoryListRequest() 8133 req.meta.CopyFrom(ListRequestMetadata()) 8134 if self.parent.page_limit > 0: 8135 req.meta.limit = self.parent.page_limit 8136 if self.parent.snapshot_datetime is not None: 8137 req.meta.snapshot_at.FromDatetime(self.parent.snapshot_datetime) 8138 8139 req.filter = plumbing.quote_filter_args(filter, *args) 8140 8141 def generator(svc, req): 8142 tries = 0 8143 while True: 8144 t = None if deadline is None else deadline - time.time() 8145 try: 8146 plumbing_response = svc.stub.List( 8147 req, 8148 metadata=svc.parent.get_metadata( 8149 'WorkflowsHistory.List', req), 8150 timeout=t) 8151 except Exception as e: 8152 if self.parent.shouldRetry(tries, e, deadline): 8153 tries += 1 8154 time.sleep( 8155 self.parent.exponentialBackoff(tries, deadline)) 8156 continue 8157 raise plumbing.convert_error_to_porcelain(e) from e 8158 tries = 0 8159 for plumbing_item in plumbing_response.history: 8160 yield plumbing.convert_workflow_history_to_porcelain( 8161 plumbing_item) 8162 if plumbing_response.meta.next_cursor == '': 8163 break 8164 req.meta.cursor = plumbing_response.meta.next_cursor 8165 8166 return generator(self, req)
List gets a list of WorkflowHistory records matching a given set of criteria.